/* This file has been post-processed for GNU C */


/* Automatically generated by
	CCodeGeneratorGlobalStructure Melchor-tonel.1 uuid: 383f77bb-5600-0e00-9ce0-a0da07f47eec
   from
	CoInterpreter VMMaker-tonel.1 uuid: 5079c0bb-5600-0e00-9ce5-325007f47eec
 */
static char __buildInfo[] = "CoInterpreter VMMaker-tonel.1 uuid: 5079c0bb-5600-0e00-9ce5-325007f47eec " __DATE__ ;
char *__interpBuildInfo = __buildInfo;



#if USE_GLOBAL_STRUCT
# define SQ_USE_GLOBAL_STRUCT 1
#else
# define SQ_USE_GLOBAL_STRUCT 0
#endif
#if USE_GLOBAL_STRUCT_REG 
# define SQ_USE_GLOBAL_STRUCT_REG 1
#else
# define SQ_USE_GLOBAL_STRUCT_REG 0
#endif

#include <stddef.h> /* for e.g. alloca */
#include <stdint.h> /* for e.g. alloca */
#include <wchar.h> /* for wint_t */
#if FEATURE_FFI
#include <ffi.h>
#endif //FEATURE_FFI
#if FEATURE_THREADED_FFI
#include "worker.h"
#endif //FEATURE_THREADED_FFI
#include <sys/stat.h> /* for e.g. mkdir */
#include "sqGnu.h"
#include "sigjmp_support.h"
#include "vmCallback.h"
#include "memoryFence.h"
#include "dispdbg.h"
#include "vmMemoryMap.h"
#include "vmRememberedSet.h"
#include "cogStackAlignment.h"
#include "cogmethod.h"
#include "cointerp.h"
#include "cogit.h"



/* StackInterpreter class>>preambleCCode */
/* Disable Intel compiler inlining of warning which is used for breakpoints */
#pragma auto_inline(off)
sqInt warnpid, erroronwarn;
void
warning(char *s) { /* Print an error message but don't necessarily exit. */
	if (erroronwarn) error(s);
	if (warnpid)
		vm_printf("\n%s pid %ld\n", s, (long)warnpid);
	else
		vm_printf("\n%s\n", s);
}
void
warningat(char *s, int l) { /* ditto with line number. */
	/* use alloca to call warning so one does not have to remember to set two breakpoints... */
	char *sl = alloca(strlen(s) + 16);
	sprintf(sl, "%s %d", s, l);
	warning(sl);
}
#pragma auto_inline(on)

void
invalidCompactClassError(char *s) { /* Print a (compact) class index error message and exit. */
	vm_printf("\nClass %s does not have the required class index\n", s);
	exit(-1);
}

#define odd(v) ((int)(v)&1)
#define even(v) (!odd(v))

/* end StackInterpreter class>>preambleCCode */


/*** Constants ***/
#define ActiveProcessIndex 1
#define AlternateHeaderHasPrimFlag 0x80000
#define AlternateHeaderNumLiteralsMask 0x7FFF
#define AutodetectFormat 0
#define BecameActiveClassFlag 8
#define BecameCompiledMethodFlag 2
#define BecamePermanentObject 16
#define BecamePointerObjectFlag 1
#define BytecodeSetHasDirectedSuperSend 1
#define BytecodeSetHasExtensions 1
#define CacheProbeMax 3
#define ClassArray 7
#define ClassArrayCompactIndex 51
#define ClassBitmap 4
#define ClassBitmapCompactIndex 53
#define ClassByteArray 26
#define ClassByteString 6
#define ClassByteStringCompactIndex 52
#define ClassCharacter 19
#define ClassExternalAddress 43
#define ClassFloat 9
#define ClassFloat32Register 31
#define ClassFloat64Register 32
#define ClassFloatCompactIndex 34
#define ClassFullBlockClosure null
#define ClassFullBlockClosureCompactIndex 38
#define ClassLargeNegativeInteger 42
#define ClassLargeNegativeIntegerCompactIndex 32
#define ClassLargePositiveInteger 13
#define ClassLargePositiveIntegerCompactIndex 33
#define ClassMessage 15
#define ClassMessageCompactIndex 35
#define ClassMethodContext 10
#define ClassMethodContextCompactIndex 36
#define ClassMutex 39
#define ClassPoint 12
#define ClassSemaphore 18
#define ClassSmallInteger 5
#define ClosureIndex 4
#define CMMegamorphicIC 4
#define CMMethod 2
#define CMPolymorphicIC 3
#define COGVM 1
#define ComposedFormatDetected 1
#define ComposedFormatForced 3
#define ConstMinusOne 0xFFFFFFFFFFFFFFF9ULL
#define ConstOne 9
#define ConstTwo 17
#define ConstZero 1
#define CSCallbackEnter 3
#define CSCallbackLeave 4
#define CSEnterCriticalSection 5
#define CSExitCriticalSection 6
#define CSResume 7
#define CSSignal 8
#define CSSuspend 9
#define CSWait 10
#define CSYield 11
#define CtxtTempFrameStart 6
#define DumpStackOnLowSpace 0
#define EncounteredUnknownBytecode -6
#define ExcessSignalsIndex 2
#define ExternalObjectsArray 38
#define ExtraRootsSize 2048
#define FailImbalancedPrimitives 1
#define FalseObject 1
#if !defined(FEATURE_FFI) /* Allow this to be overridden on the compiler command line */
# define FEATURE_FFI 0
#endif /* !defined(FEATURE_FFI) */
#if !defined(FEATURE_THREADED_FFI) /* Allow this to be overridden on the compiler command line */
# define FEATURE_THREADED_FFI 0
#endif /* !defined(FEATURE_THREADED_FFI) */
#define FirstLinkIndex 0
#define FoxCallerSavedIP 8
#define FoxIFReceiver -40
#define FoxIFrameFlags -24
#define FoxIFSavedIP -32
#define FoxMethod -8
#define FoxMFReceiver -24
#define FoxSavedFP 0
#define FoxThisContext -16
#define FullClosureCompiledBlockIndex 1
#define FullClosureFirstCopiedValueIndex 4
#define FullClosureNumArgsIndex 2
#define FullClosureOuterContextIndex 0
#define FullClosureReceiverIndex 3
#define GCCheckPrimCall 64
#define GCModeBecome 8
#define GCModeFreeSpace 32
#define GCModeFull 1
#define GCModeIncremental 4
#define GCModeNewSpace 2
#define HasBeenReturnedFromMCPC -1
#define HasBeenReturnedFromMCPCOop 0xFFFFFFFFFFFFFFF9ULL
#define HashMultiplyConstant 1664525
#define HeaderIndex 0
#define IFrameSlots 7
#if !defined(IMMUTABILITY) /* Allow this to be overridden on the compiler command line */
# define IMMUTABILITY 1
#endif /* !defined(IMMUTABILITY) */
#define InstanceSpecificationIndex 2
#define InstructionPointerIndex 1
#define KeyIndex 0
#define LargeContextBit 0x100000
#define LargeContextSlots 62
#define LastLinkIndex 1
#define LiteralStart 1
#define LongStoreBytecode 245
#define MarkObjectsForEnumerationPrimitives 0
#define MarkOnTenure 5
#define MarkStackRootIndex 0x1000
#define MaxExternalPrimitiveTableSize 4096
#define MaxJumpBuf 32
#define MaxLiteralCountForCompile 60
#define MaxNegativeErrorCode -8
#define MaxPrimitiveIndex 660
#define MaxQuickPrimitiveIndex 519
#define MaxRTRefCount 7
#define MessageArgumentsIndex 1
#define MessageLookupClassIndex 2
#define MessageSelectorIndex 0
#define MethodArrayIndex 1
#define MethodCacheClass 2
#define MethodCacheEntries 0x400
#define MethodCacheEntrySize 4
#define MethodCacheMask 0xFFC
#define MethodCacheMethod 3
#define MethodCachePrimFunction 4
#define MethodCacheSelector 1
#define MethodCacheSize 4096
#define MethodDictionaryIndex 1
#define MethodHeaderArgCountShift 27
#define MethodHeaderFlagBitPosition 31
#define MethodHeaderTempCountShift 21
#define MethodIndex 3
#define MethodTooBig -4
#define MFMethodFlagHasContextFlag 1
#define MFMethodFlagIsBlockFlag 2
#define MFMethodFlagsMask 0x7
#define MFMethodMask -0x8
#define MFrameSlots 5
#define MillisecondClockMask 0x1FFFFFFF
#define MinBackwardJumpCountForCompile 40
#define MournQueueRootIndex 4098
#define MyListIndex 3
#define NextLinkIndex 0
#define NilObject 0
#define NotFullyInitialized -1
#define ObjStackFixedSlots 4
#define ObjStackFreex 2
#define ObjStackLimit 0xFF8
#define ObjStackMyx 1
#define ObjStackNextx 3
#define ObjStackPageSlots 0xFFC
#define ObjStackTopx 0
#define OldBecameNewFlag 4
#define OldRememberedSetRootIndex 4099
#define PermToNewRememberedSetRootIndex 4101
#define PermToOldRememberedSetRootIndex 4100
#if !defined(PRIdSQINT) /* Allow this to be overridden on the compiler command line */
# define PRIdSQINT "ld"
#endif /* !defined(PRIdSQINT) */
#define PrimErrBadArgument 3
#define PrimErrBadIndex 4
#define PrimErrBadMethod 12
#define PrimErrBadNumArgs 5
#define PrimErrBadReceiver 2
#define PrimErrFFIException 22
#define PrimErrInappropriate 6
#define PrimErrLimitExceeded 15
#define PrimErrNamedInternal 13
#define PrimErrNoCMemory 10
#define PrimErrNoMemory 9
#define PrimErrNoModification 8
#define PrimErrNotFound 11
#define PrimErrObjectIsPinned 16
#define PrimErrOSError 21
#define PrimErrTableIndex 51
#define PrimErrUnsupported 7
#define PrimErrWritePastObject 17
#define PrimNoErr 0
#define PrimNumberDoExternalCall 218
#define PrimNumberDoPrimitive 118
#define PrimNumberExternalCall 117
#define PrimNumberHashMultiply 159
#define PrimTraceLogSize 256
#define PriorityIndex 2
#define ProcessListsIndex 0
#define ProcessShouldOverflowIndex 9
#define ProcessSignalingLowSpace 22
#define ReceiverIndex 5
#define RemapBufferSize 25
#define ReturnToInterpreter 1
#define ScavengeInProgress 1
#define SchedulerAssociation 3
#define SelectorAboutToReturn 48
#define SelectorAttemptToAssign 50
#define SelectorCannotInterpret 34
#define SelectorCannotReturn 21
#define SelectorDoesNotUnderstand 20
#define SelectorMustBeBoolean 25
#define SelectorRunWithIn 49
#define SelectorSistaTrap 59
#define SelectorStackOverflow 24
#define SelectorStart 2
#define SelectorUnknownBytecode 57
#define SenderIndex 0
#define ShouldNotJIT -8
#define SistaVM 0
#define SlidingCompactionInProgress 2
#define SmallContextSlots 22
#define SpecialSelectors 23
#define SpurFormatDetected 2
#define StackPageReachedButUntraced 1
#define StackPageTraced 2
#define StackPageTraceInvalid -1
#define StackPageUnreached 0
#define StackPointerIndex 2
#define SuperclassIndex 0
#define SuspendedContextIndex 1
#define SuspendedProcessInCallout 11
#define TempVectReadBarrier 0
#define TenureByAge 1
#define TenureByClass 2
#define TenureToShrinkRT 3
#define TheFinalizationSemaphore 41
#define TheInterruptSemaphore 30
#define TheLowSpaceSemaphore 17
#define TheTimerSemaphore 29
#define TraceBlockActivation 17
#define TraceBlockCreation 25
#define TraceBufferSize 768
#define TraceCodeCompaction 49
#define TraceContextSwitch 9
#define TraceFullGC 41
#define TraceIncrementalGC 33
#define TraceIsFromInterpreter 2
#define TraceIsFromMachineCode 1
#define TracePrimitiveFailure 113
#define TracePrimitiveRetry 121
#define TraceStackOverflow 105
#define TraceVMCallback 89
#define TraceVMCallbackReturn 97
#define TrueObject 2
#define ValueIndex 1
#if !defined(VMBIGENDIAN) /* Allow this to be overridden on the compiler command line */
# define VMBIGENDIAN 0
#endif /* !defined(VMBIGENDIAN) */
#define WeaklingStackRootIndex 0x1001
#if !defined(WIN32) /* Allow this to be overridden on the compiler command line */
# define WIN32 0
#endif /* !defined(WIN32) */
#define XIndex 0
#define YIndex 1

typedef struct {
	usqInt	sEdenBytes;
	usqInt	sPastBytes;
	usqInt	sRememberedSetSize;
	usqInt	sRememberedSetRedZone;
	usqInt	sRememberedSetLimit;
	usqInt	sStatTenures;
	usqInt	tTenureCriterion;
	usqInt	tTenureThreshold;
	usqInt	tRefCountToShrinkRT;
	usqInt	eSurvivorBytes;
	usqInt	eRememberedSetSize;
	usqInt	eStatTenures;
 } SpurScavengeLogRecord;


typedef struct {
	usqInt	segStart;
	size_t	segSize;
	sqInt	swizzle;
	usqInt	containsPinned;
	size_t	savedSegSize;
	usqInt	lastFreeObject;
 } SpurSegmentInfo;


typedef struct {
	usqInt	start;
	usqInt	limit;
 } SpurNewSpaceSpace;


typedef struct {
	usqInt	start;
	usqInt	limit;
	usqInt	top;
	usqInt	initialSize;
 } SpurContiguousObjStack;


typedef struct _StackPage {
	char *stackLimit;
	char *headSP;
	char *headFP;
	char *baseFP;
	char *baseAddress;
	char *realStackLimit;
	char *lastAddress;
	int	trace;
	int	padToWord;
	struct _StackPage *nextPage;
	struct _StackPage *prevPage;
 } StackPage;

#define VMStackPage StackPage


typedef struct {
	size_t	dataSize;
	sqInt	hdrOldSpaceSize;
	sqInt	oldBaseAddr;
	sqInt	initialSpecialObjectsOop;
	sqInt	headerFlags;
	sqInt	extraVMMemory;
	sqInt	hdrNumStackPages;
	sqInt	hdrCogCodeSize;
	sqInt	hdrEdenBytes;
	sqInt	hdrMaxExtSemTabSize;
	sqInt	firstSegSize;
	sqInt	freeOldSpaceInImage;
	sqInt	swapBytes;
	sqInt	hdrLastHash;
	sqInt	imageFormat;
	sqInt	imageHeaderSize;
	sqInt	imageVersion;
 } SpurImageHeaderStruct;


typedef struct {
	fileOffset_t	startAddress;
	size_t	dataSize;
 } ComposedMetadataStruct;


typedef struct {
	sqInt (*primitiveGenerator )(void);
	sqInt	primNumArgs;
	sqInt	primMayCallBack;
 } PrimitiveDescriptor;

#define CogPrimitiveDescriptor PrimitiveDescriptor









/*** Function Prototypes ***/


#if !PRODUCTION && defined(PlatformNoDbgRegParms)
# define NoDbgRegParms PlatformNoDbgRegParms
#endif

#if !defined(NoDbgRegParms)
# define NoDbgRegParms /*empty*/
#endif



#if !defined(NeverInline)
# define NeverInline /*empty*/
#endif

extern sqInt interpret(void);
static sqInt NoDbgRegParms existSegmentinImage(sqInt _segmentIndex, sqInt _imageFileName);
static sqInt NoDbgRegParms fileExists(char *_fileName);
static sqInt NoDbgRegParms headerFileNameinImageintobufferSize(sqInt _imageFileName, sqInt _buffer, sqInt _bufferSize);
static void NoDbgRegParms readLineFromintoofSize(sqImageFile _file, char *_lineBuffer, sqInt _bufferSize);
static sqInt NoDbgRegParms segmentMetadataFileinImage(sqInt _segmentIndex, sqInt _imageFileName);
static void NoDbgRegParms extractImageVersionFrominto(sqInt _fileVersion, SpurImageHeaderStruct *_header);
static void NoDbgRegParms loadHeaderToMemory(SpurImageHeaderStruct _header);
extern signed char accessorDepthForPrimitiveIndex(sqInt _primIndex);
static void NoDbgRegParms activateCoggedNewMethod(sqInt _inInterpreter);
static void activateNewMethod(void);
static void NoDbgRegParms addNewMethodToCache(sqInt _classObj);
static void NoDbgRegParms allocateMemoryForImagewithHeader(sqImageFile _f, SpurImageHeaderStruct _header);
extern usqInt argumentCountAddress(void);
static void NoDbgRegParms assertValidExecutionPointersimbarline(usqInt _lip, char *_lifp, char *_lisp, sqInt _inInterpreter, sqInt _ln);
extern void assertValidMachineCodeFrame(sqInt _instrPtr);
static sqInt NoDbgRegParms assertValidStackedInstructionPointersInline(StackPage *_aStackPage, sqInt _ln);
static void NoDbgRegParms assertValidStackedInstructionPointers(sqInt _ln);
static void NoDbgRegParms attemptToSwitchToMachineCode(sqInt _bcpc);
extern void callForCogCompiledCodeCompaction(void);
static void NoDbgRegParms callRegisterArgCogMethodatreceiver(CogMethod *_cogMethod, sqInt _entryOffset, sqInt _rcvr);
extern void ceActivateFailingPrimitiveMethod(sqInt _aPrimitiveMethod);
extern sqInt ceBaseFrameReturn(sqInt _returnValue);
#if IMMUTABILITY
extern sqInt ceCannotAssignTowithIndexvalueToAssign(sqInt _immutableObject, sqInt _index, sqInt _valueToAssign);
#endif /* IMMUTABILITY */
extern sqInt ceCannotResume(void);
extern void ceCheckAndMaybeRetryPrimitive(sqInt primIndex);
extern void ceCheckForInterrupts(void);
extern void ceCheckProfileTick(void);
extern sqInt ceContextinstVar(sqInt _maybeContext, sqInt _slotIndex);
extern sqInt ceContextinstVarvalue(sqInt _maybeMarriedContext, sqInt _slotIndex, sqInt _anOop);
extern void ceInterpretMethodFromPICreceiver(sqInt _aMethodObj, sqInt _rcvr);
extern void ceMNUFromPICMNUMethodreceiver(sqInt _aMethodObj, sqInt _rcvr);
extern sqInt ceNewHashOf(sqInt _anObject);
extern sqInt ceNonLocalReturn(sqInt _returnValue);
extern void ceReapAndResetErrorCodeFor(CogMethod *_cogMethod);
extern void ceReturnToInterpreter(sqInt _anOop);
extern sqInt ceSendAborttonumArgs(sqInt _selector, sqInt _rcvr, sqInt _numArgs);
extern sqInt ceSendFromInLineCacheMiss(sqInt _cogMethodOrPICAddr);
extern void ceSendMustBeBooleanTointerpretingAtDelta(sqInt _aNonBooleanObject, sqInt _jumpSize);
extern sqInt ceSendMustBeBoolean(sqInt _anObject);
extern void ceSendaboveClassBindingtonumArgs(sqInt _selector, sqInt _methodClassBinding, sqInt _rcvr, sqInt _numArgs);
extern void ceSendabovetonumArgs(sqInt _maybeForwardedSelector, sqInt _methodClass, sqInt _receiver, sqInt _numArgs);
extern void ceSendsupertonumArgs(sqInt _maybeForwardedSelector, sqInt _isSuperSend, sqInt _maybeForwardedReceiver, sqInt _numArgs);
extern void ceStackOverflow(sqInt _contextSwitchIfNotNil);
extern void ceTraceBlockActivation(void);
extern void ceTraceLinkedSend(sqInt _theReceiver);
extern void ceTraceStoreOfinto(sqInt _aValue, sqInt _anObject);
extern void checkAssertsEnabledInCoInterpreter(void);
static sqInt NoDbgRegParms checkCodeIntegrity(sqInt _gcModes);
static sqInt checkLogIntegrity(void);
extern void clearTraceLog(void);
extern CogMethod * cogMethodOf(sqInt _aMethodOop);
static void commenceCogCompiledCodeCompaction(void);
extern void compilationBreakpointFor(sqInt selectorOop);
static sqInt NoDbgRegParms contextInstructionPointerframe(sqInt _anIP, char *_theFP);
static sqInt NoDbgRegParms deferStackLimitSmashAroundwith(void (*_functionSymbol)(sqInt), sqInt _arg);
static sqInt NoDbgRegParms divorceAMachineCodeFrameWithCogMethodin(CogMethod *_cogMethod, StackPage *_aStackPage);
extern void dumpPrimTraceLog(void);
extern void dumpTraceLog(void);
static void NoDbgRegParms ensureContextHasBytecodePC(sqInt _aContext);
static void NoDbgRegParms ensureContextIsExecutionSafeAfterAssignToStackPointer(sqInt _aContext);
static sqInt enterSmalltalkExecutiveImplementation(void);
extern void executeCogMethodfromLinkedSendWithReceiver(CogMethod *_cogMethod, sqInt _rcvr);
static void NoDbgRegParms executeCogMethodfromUnlinkedSendWithReceiver(CogMethod *_cogMethod, sqInt _rcvr);
extern void executeCogPICfromLinkedSendWithReceiverandCacheTag(CogMethod *_cogPIC, sqInt _rcvr, sqInt _cacheTag);
static void NoDbgRegParms findNewMethodInClassTag(sqInt _classTagArg);
extern void flushExternalPrimitiveOf(sqInt _methodObj);
static void followForwardedFieldsInCurrentMethod(void);
extern void forceInterruptCheckFromHeartbeat(void);
static sqInt NoDbgRegParms frameHasContext(char *_theFP);
static sqInt NoDbgRegParms frameIsBlockActivation(char *_theFP);
static sqInt NoDbgRegParms frameMethodObject(char *_theFP);
static sqInt NoDbgRegParms frameNumArgs(char *_theFP);
extern usqInt framePointerAddress(void);
static sqInt NoDbgRegParms frameReceiver(char *_theFP);
extern void (*functionPointerForCompiledMethodprimitiveIndex(sqInt _methodObj, sqInt _primIndex))(void) ;
extern sqInt getCheckAllocFiller(void);
extern sqInt getCurrentBytecode(void);
static sqInt NoDbgRegParms handleForwardedSendFaultForReceiverrcvrStackOffsetFromTop(sqInt _forwardedReceiver, sqInt _rcvrStackIndex);
static sqInt NoDbgRegParms handleMNUInMachineCodeToclassForMessage(sqInt _selectorIndex, sqInt _rcvr, sqInt _classForMessage);
extern void ifValidWriteBackStackPointersSaveTo(void *_theCFP, void *_theCSP, char **_savedFPP, char **_savedSPP);
extern usqInt instructionPointerAddress(void);
static sqInt NoDbgRegParms instVarofContext(sqInt _offset, sqInt _aContext);
extern usqInt interpretAddress(void);
static sqInt NeverInline interpreterAllocationReserveBytes(void);
static void interpretMethodFromMachineCode(void);
extern sqInt isCogMethodReference(sqInt _methodHeader);
static sqInt NoDbgRegParms isInstructionPointerInInterpreter(sqInt _anIP);
static sqInt NoDbgRegParms isMachineCodeFrame(char *_theFP);
static sqInt NoDbgRegParms isMachineCodeIP(sqInt _anInstrPointer);
extern sqInt lookupMethodWithoutMNUProcessingForSelectorreceiver(sqInt _selector, sqInt _rcvr);
static void mapPrimTraceLog(void);
static void mapTraceLog(void);
extern void markActiveMethodsAndReferents(void);
static void markAndTracePrimTraceLog(void);
static void markAndTraceTraceLog(void);
static void NoDbgRegParms markCogMethodsAndReferentsOnPage(StackPage *_thePage);
extern sqInt marryFrameCopiesTemps(void);
extern sqInt maxLookupNoMNUErrorCode(void);
static void NoDbgRegParms maybeFlagMethodAsInterpreted(sqInt _aMethod);
static sqInt NoDbgRegParms maybeMethodHasCogMethod(sqInt _anOop);
extern sqInt mcprimFunctionForPrimitiveIndex(sqInt _primIndex);
extern void * methodCacheAddress(void);
extern sqInt methodHasCogMethod(sqInt _aMethodOop);
extern sqInt methodNeedsLargeContext(sqInt _methodObj);
extern sqInt methodShouldBeCogged(sqInt _aMethodObj);
static sqInt NoDbgRegParms methodWithHeaderShouldBeCogged(sqInt _methodHeader);
extern CogMethod * mframeHomeMethodExport(void);
extern CogMethod * mframeHomeMethod(char *_theFP);
static sqInt NoDbgRegParms mframeIsBlockActivation(char *_theFP);
static sqInt NoDbgRegParms mframeReceiver(char *_theFP);
static sqInt minimumUnusedHeadroom(void);
extern sqInt mMethodClass(void);
extern void mnuCompilationBreakpointFor(sqInt selectorOop);
static sqInt NoDbgRegParms mnuMethodOrNilFor(sqInt _rcvr);
static sqInt NoDbgRegParms mustMapMachineCodePCcontext(sqInt _theIP, sqInt _aOnceMarriedContext);
extern usqInt newMethodAddress(void);
extern usqInt nextProfileTickAddress(void);
extern sqInt noAssertHeaderOf(sqInt _methodPointer);
static void NoDbgRegParms postBecomeAction(sqInt _theBecomeEffectsFlags);
static void NoDbgRegParms postGCAction(sqInt _gcModeArg);
static void NoDbgRegParms preGCAction(sqInt _gcModeArg);
extern sqInt primErrTable(void);
extern usqInt primFailCodeAddress(void);
extern usqInt primitiveFailAddress(void);
extern void * primTraceLogAddress(void);
extern usqInt primTraceLogIndexAddress(void);
extern void printCogMethod(CogMethod *_cogMethod);
static void NoDbgRegParms printFrameFlagsForFP(char *_theFP);
static void NoDbgRegParms printFrameMethodFor(char *_theFP);
extern sqInt printFrameWithSP(char *_theFP, char *_theSP);
static void NoDbgRegParms printLogEntryAt(sqInt _i);
extern void printMethodCacheFor(sqInt _thing);
static sqInt NoDbgRegParms printPrimLogEntryAt(sqInt _i);
extern sqInt quickPrimitiveConstantFor(sqInt _aQuickPrimitiveIndex);
extern sqInt (*quickPrimitiveGeneratorFor(sqInt _aQuickPrimitiveIndex))(void) ;
extern sqInt quickPrimitiveInstVarIndexFor(sqInt _primIndex);
extern void rawHeaderOfput(sqInt _methodOop, sqInt _cogMethodOrMethodHeader);
extern void reportMinimumUnusedHeadroom(void);
static sqInt NoDbgRegParms returnToExecutivepostContextSwitch(sqInt _inInterpreter, sqInt _switchedContext);
static sqInt NoDbgRegParms returntoExecutive(sqInt _returnValue, sqInt _inInterpreter);
static void NoDbgRegParms rewriteMethodCacheEntryForExternalPrimitiveToFunction(void (*_localPrimAddress)(void));
extern void setDesiredCogCodeSize(sqInt _dccs);
extern usqInt stackLimitAddress(void);
static sqInt stackPageHeadroom(void);
extern usqInt stackPointerAddress(void);
static void NoDbgRegParms tearDownAndRebuildFrameForCannotReturnBaseFrameReturnFromtoreturnValue(sqInt _contextToReturnFrom, sqInt _contextToReturnTo, sqInt _returnValue);
extern void updateStackZoneReferencesToCompiledCodePreCompaction(void);
extern sqInt validInstructionPointerinMethodframePointer(usqInt _instrPointer, usqInt _aMethod, char *_fp);
extern usqInt varBaseAddress(void);
static sqInt NoDbgRegParms voidVMStateForSnapshotFlushingExternalPrimitivesIf(sqInt _flushExtPrims);
extern char * whereIs(sqInt _anOop);
static void NoDbgRegParms NeverInline widowOrForceToBytecodePC(sqInt _ctxt);
extern sqInt mcprimHashMultiply(sqInt _receiverArg);
static void primitiveCollectCogCodeConstituents(void);
static void primitiveContextXray(void);
static void primitiveFlushCacheByMethod(void);
static void primitiveFlushCacheBySelector(void);
extern usqInt primitiveFunctionPointerAddress(void);
EXPORT(sqInt) primitiveLongRunningPrimitiveSemaphore(void);
EXPORT(sqInt) primitiveMethodPCData(void);
EXPORT(void) primitiveMethodProfilingData(void);
static void primitiveMethodXray(void);
EXPORT(void) primitiveMinimumUnusedHeadroom(void);
static void primitiveObjectAt(void);
static void primitiveObjectAtPut(void);
EXPORT(sqInt) primitiveProfileSemaphore(void);
static void primitiveSignal(void);
static void primitiveSnapshot(void);
static void primitiveTerminateTo(void);
static void primitiveVoidVMState(void);
static void primitiveVoidVMStateForMethod(void);
static size_t NoDbgRegParms CIR_readPermanentSpaceFromImageFileheader(sqInt _imageFileName, SpurImageHeaderStruct aHeader);
static size_t NoDbgRegParms CIR_readSegmentsFromImageFileheader(sqInt _imageFileName, SpurImageHeaderStruct aHeader);
static void NoDbgRegParms CIW_writeImageFilefromHeader(char *_imageFileName, SpurImageHeaderStruct _header);
static size_t NoDbgRegParms writeSegmentnextIndexinImage(SpurSegmentInfo *_segment, sqInt _segmentIndex, char *_imageFileName);
#if IMMUTABILITY
static sqInt NoDbgRegParms canBeImmutable(sqInt _oop);
#endif /* IMMUTABILITY */
extern char * cStringOrNullFor(sqInt _oop);
extern void doWaitSemaphore(sqInt _sema);
extern sqInt failed(void);
static sqInt NoDbgRegParms isNegativeIntegerValueOf(sqInt _oop);
extern sqInt isPositiveMachineIntegerObject(sqInt _oop);
static sqInt NoDbgRegParms magnitude64BitIntegerForneg(usqLong _magnitude, sqInt _isNegative);
static usqLong NoDbgRegParms magnitude64BitValueOf(sqInt _oop);
extern unsigned int positive32BitValueOf(sqInt _oop);
extern usqLong positive64BitValueOf(sqInt _oop);
extern usqIntptr_t positiveMachineIntegerValueOf(sqInt _oop);
static void primitiveAdd(void);
EXPORT(void) primitiveAddLargeIntegers(void);
static void primitiveAdoptInstance(void);
EXPORT(void) primitiveAllInstances(void);
EXPORT(void) primitiveAllObjects(void);
static void primitiveArctan(void);
static void primitiveArrayBecome(void);
static void primitiveArrayBecomeOneWay(void);
static void primitiveArrayBecomeOneWayCopyHash(void);
static void primitiveArrayBecomeOneWayNoCopyHash(void);
static void primitiveAsCharacter(void);
static void primitiveAsFloat(void);
static void primitiveAt(void);
static void primitiveAtPut(void);
static void primitiveBehaviorHash(void);
static void primitiveBitAnd(void);
EXPORT(void) primitiveBitAndLargeIntegers(void);
static void primitiveBitOr(void);
EXPORT(void) primitiveBitOrLargeIntegers(void);
static void primitiveBitShift(void);
EXPORT(void) primitiveBitShiftLargeIntegers(void);
static void primitiveBitXor(void);
EXPORT(void) primitiveBitXorLargeIntegers(void);
static void primitiveBytesLeft(void);
static void primitiveCalloutToFFI(void);
static void primitiveChangeClass(void);
static void primitiveClass(void);
static void primitiveCoarseLocalMicrosecondClock(void);
static void primitiveCoarseUTCMicrosecondClock(void);
static void primitiveConstantFill(void);
static void primitiveCopyObject(void);
static void primitiveDiv(void);
static void primitiveDivide(void);
EXPORT(void) primitiveDivideLargeIntegers(void);
EXPORT(void) primitiveDivLargeIntegers(void);
static void primitiveEqual(void);
EXPORT(void) primitiveEqualLargeIntegers(void);
static void primitiveExp(void);
static void primitiveExponent(void);
extern sqInt primitiveFail(void);
extern sqInt primitiveFailForOSError(sqLong _osError);
extern sqInt primitiveFailFor(sqInt _reasonCode);
extern sqInt primitiveFailureCode(void);
static void primitiveFetchNextMourner(void);
static void primitiveFloatAdd(void);
static void primitiveFloatAt(void);
static void primitiveFloatAtPut(void);
static void primitiveFloatDivide(void);
static void primitiveFloatEqual(void);
static void primitiveFloatGreaterOrEqual(void);
static void primitiveFloatGreaterThan(void);
static void primitiveFloatLessOrEqual(void);
static void primitiveFloatLessThan(void);
static void primitiveFloatMultiply(void);
static void primitiveFloatNotEqual(void);
static void primitiveFloatSubtract(void);
static void primitiveFlushCache(void);
static void primitiveFlushExternalPrimitives(void);
static void primitiveFractionalPart(void);
static void primitiveFullClosureValue(void);
extern void primitiveFullClosureValueNoContextSwitch(void);
static void primitiveFullClosureValueWithArgs(void);
static void primitiveGetAttribute(void);
EXPORT(sqInt) primitiveGetenv(void);
#if IMMUTABILITY
static void primitiveGetImmutability(void);
#else
# define primitiveGetImmutability (void (*)(void))0
#endif /* IMMUTABILITY */
static void primitiveGreaterOrEqual(void);
EXPORT(void) primitiveGreaterOrEqualLargeIntegers(void);
static void primitiveGreaterThan(void);
EXPORT(void) primitiveGreaterThanLargeIntegers(void);
static void primitiveGrowMemoryByAtLeast(void);
static void primitiveHashMultiply(void);
EXPORT(sqInt) primitiveHeartbeatFrequency(void);
EXPORT(sqInt) primitiveHighResClock(void);
static void primitiveIdentical(void);
static void primitiveIdentityHash(void);
EXPORT(sqInt) primitiveImageFormatVersion(void);
static void primitiveImageName(void);
static void primitiveImmediateAsInteger(void);
static void primitiveIntegerAt(void);
static void primitiveIntegerAtPut(void);
EXPORT(sqInt) primitiveInterruptChecksPerMSec(void);
static void primitiveInvokeObjectAsMethod(void);
EXPORT(sqInt) primitiveIsBigEnder(void);
static void primitiveIsPinned(void);
static void primitiveLessOrEqual(void);
EXPORT(void) primitiveLessOrEqualLargeIntegers(void);
static void primitiveLessThan(void);
EXPORT(void) primitiveLessThanLargeIntegers(void);
static void primitiveListBuiltinModule(void);
static void primitiveListExternalModule(void);
static void primitiveLocalMicrosecondClock(void);
static void primitiveLogN(void);
static void primitiveLowSpaceSemaphore(void);
static void primitiveMakePoint(void);
static void primitiveMaxIdentityHash(void);
extern usqInt primitiveMethod(void);
static void primitiveMillisecondClock(void);
EXPORT(sqInt) primitiveMillisecondClockMask(void);
static void primitiveMod(void);
EXPORT(void) primitiveModLargeIntegers(void);
static void primitiveMultiply(void);
EXPORT(void) primitiveMultiplyLargeIntegers(void);
static void primitiveNew(void);
static void primitiveNewMethod(void);
static void primitiveNewOldSpace(void);
static void primitiveNewPinned(void);
static void primitiveNewWithArg(void);
static void primitiveNewWithArgOldSpace(void);
static void primitiveNewWithArgPinned(void);
static void primitiveNextInstance(void);
static void primitiveNextObject(void);
static void primitiveNotEqual(void);
EXPORT(void) primitiveNotEqualLargeIntegers(void);
static void primitiveNotIdentical(void);
static void primitivePerformInSuperclass(void);
static void primitivePerformWithArgs(void);
EXPORT(sqInt) primitiveProfilePrimitive(void);
EXPORT(sqInt) primitiveProfileSample(void);
EXPORT(sqInt) primitiveProfileStart(void);
static void primitiveQuit(void);
static void primitiveQuo(void);
EXPORT(void) primitiveQuoLargeIntegers(void);
static void primitiveRelinquishProcessor(void);
EXPORT(void) primitiveRemLargeIntegers(void);
static void primitiveSecondsClock(void);
#if IMMUTABILITY
static void primitiveSetImmutability(void);
#else
# define primitiveSetImmutability (void (*)(void))0
#endif /* IMMUTABILITY */
static void primitiveSetOrHasIdentityHash(void);
static void primitiveShortAt(void);
static void primitiveShortAtPut(void);
static void primitiveSignalAtBytesLeft(void);
static void primitiveSine(void);
static void primitiveSize(void);
static void primitiveSizeInBytes(void);
static void primitiveSizeInBytesOfInstance(void);
static void primitiveSmallFloatAdd(void);
static void primitiveSmallFloatArctan(void);
static void primitiveSmallFloatDivide(void);
static void primitiveSmallFloatEqual(void);
static void primitiveSmallFloatExp(void);
static void primitiveSmallFloatExponent(void);
static void primitiveSmallFloatFractionalPart(void);
static void primitiveSmallFloatGreaterOrEqual(void);
static void primitiveSmallFloatGreaterThan(void);
static void primitiveSmallFloatLessOrEqual(void);
static void primitiveSmallFloatLessThan(void);
static void primitiveSmallFloatLogN(void);
static void primitiveSmallFloatMultiply(void);
static void primitiveSmallFloatNotEqual(void);
static void primitiveSmallFloatSine(void);
static void primitiveSmallFloatSquareRoot(void);
static void primitiveSmallFloatSubtract(void);
static void primitiveSmallFloatTimesTwoPower(void);
static void primitiveSmallFloatTruncated(void);
static void primitiveSomeInstance(void);
static void primitiveSomeObject(void);
static void primitiveSpecialObjectsOop(void);
static void primitiveSquareRoot(void);
static void primitiveStringAt(void);
static void primitiveStringAtPut(void);
EXPORT(void) primitiveStringCompareWith(void);
static void primitiveStringReplace(void);
static void primitiveSubtract(void);
EXPORT(void) primitiveSubtractLargeIntegers(void);
static void primitiveTestAndSetOwnershipOfCriticalSection(void);
static void primitiveTimesTwoPower(void);
static void primitiveTruncated(void);
static void primitiveUnloadModule(void);
static void primitiveUpdateTimezone(void);
static void primitiveUTCMicrosecondClock(void);
static void primitiveUtcAndTimezoneOffset(void);
EXPORT(sqInt) primitiveUtcWithOffset(void);
static void primitiveVMPath(void);
static void primitiveWait(void);
extern sqInt signalNoResume(sqInt _aSemaphore);
extern int signed32BitValueOf(sqInt _oop);
extern sqLong signed64BitValueOf(sqInt _oop);
extern sqIntptr_t signedMachineIntegerValueOf(sqInt _oop);
extern sqInt success(sqInt _successBoolean);
extern void ceScheduleScavenge(void);
extern sqInt classSmallFloat(void);
static void clearLeakMapAndMapAccessibleObjects(void);
extern void ensureNoForwardedLiteralsIn(sqInt _aMethodObj);
extern usqInt freeStartAddress(void);
extern usqInt getScavengeThreshold(void);
static sqLong NoDbgRegParms headerWhileForwardingOf(sqInt _aCompiledMethodObjOop);
extern sqInt isForwardedClassIndex(sqInt _maybeClassIndex);
extern sqInt isImmediateClass(sqInt _classObj);
extern sqInt methodHeaderOf(sqInt _methodObj);
extern usqInt needGCFlagAddress(void);
extern sqInt receiverTagBitsForMethod(sqInt _aMethodObj);
extern usqInt scavengeThresholdAddress(void);
extern usqInt specialObjectsArrayAddress(void);
extern sqInt withoutForwardingOnandwithsendToCogit(sqInt _obj1, sqInt _obj2, sqInt _aBool, sqInt (*_selector)(sqInt,sqInt,sqInt));
static usqInt NoDbgRegParms addressAfter(sqInt _objOop);
extern sqInt byteSwapped(sqInt _w);
static usqInt NoDbgRegParms bytesInObject(sqInt _objOop);
static double NoDbgRegParms dbgFloatValueOf(sqInt _oop);
static sqInt defaultEdenBytes(void);
static usqInt NoDbgRegParms exponentOfSmallFloat(sqInt _oop);
extern sqInt fetchClassTagOf(sqInt _oop);
static usqInt NoDbgRegParms fetchLong32ofFloatObject(sqInt _fieldIndex, sqInt _oop);
extern sqInt floatObjectOf(double _aFloat);
extern double floatValueOf(sqInt _oop);
static sqInt NoDbgRegParms initFreeChunkWithBytesat(usqLong _numBytes, sqInt _address);
static void NoDbgRegParms initSegmentBridgeWithBytesat(usqLong _numBytes, sqInt _address);
extern sqInt instantiateClassindexableSizeisPinnedisOldSpace(sqInt _classObj, usqInt _nElements, sqInt _isPinned, sqInt _isOldSpace);
extern sqInt integerObjectOf(sqInt _value);
extern sqInt integerValueOf(sqInt _oop);
static sqInt NoDbgRegParms isImmediateFloat(sqInt _oop);
extern sqInt isIntegerObject(sqInt _oop);
extern sqInt isIntegerValue(sqInt _intValue);
static sqInt NoDbgRegParms isLilliputianSize(sqInt _chunkBytes);
extern sqInt isMarked(sqInt _objOop);
static sqInt NoDbgRegParms isSmallFloatValue(double _aFloat);
static sqInt NoDbgRegParms lengthOfformat(sqInt _objOop, sqInt _fmt);
static sqInt maxSlotsForAlloc(void);
static sqInt numFreeLists(void);
extern sqInt shortentoIndexableSize(sqInt _objOop, sqInt _indexableSize);
static double NoDbgRegParms smallFloatValueOf(sqInt _oop);
extern usqInt smallObjectBytesForSlots(sqInt _numSlots);
static sqInt wordIndexableFormat(void);
static void NoDbgRegParms NeverInline addToEphemeronList(sqInt _ephemeronCorpse);
static void NoDbgRegParms NeverInline addToWeakList(sqInt _weakCorpse);
static sqInt allNewSpaceObjectsHaveZeroRTRefCount(void);
static sqInt allWeakSurvivorsOnWeakList(void);
static void NeverInline computeRefCountToShrinkRememberedSet(void);
static sqInt NoDbgRegParms copyAndForwardMourner(sqInt _mourner);
static sqInt NoDbgRegParms copyAndForward(sqInt _survivor);
static sqInt NoDbgRegParms NeverInline copyToOldSpacebytesformat(sqInt _survivor, sqInt _bytesInObject, sqInt _formatOfSurvivor);
static uint64_t NoDbgRegParms firstCorpse(sqInt _headOfCorpseList);
static sqInt futureSpaceIsFull(void);
static sqInt NoDbgRegParms isMaybeOldScavengeSurvivor(sqInt _oop);
static sqInt NoDbgRegParms isScavengeSurvivor(sqInt _oop);
static sqInt NoDbgRegParms isonWeaklingList(sqInt _oop, sqInt _listHead);
static void NeverInline mapOopsFromPermSpace(void);
static usqInt newSpaceCapacity(void);
static sqInt noUnfiredEphemeronsAtEndOfRememberedSet(void);
extern void openScavengeLog(void);
extern void printRememberedSet(void);
static void processEphemerons(void);
static void processWeaklings(void);
static sqInt NoDbgRegParms processWeakSurvivor(sqInt _weakObj);
static void NoDbgRegParms scavengeFutureSurvivorSpaceStartingAt(sqInt _initialAddress);
static void scavengeLoop(void);
static sqInt NoDbgRegParms NeverInline scavengeReferentsOfFromOldSpace(sqInt _referrer);
static void NoDbgRegParms scavengeRememberedSetStartingAt(sqInt _n);
static float scavengerTenuringProportion(void);
static sqInt scavengeUnfiredEphemeronsOnEphemeronList(void);
static void NeverInline writeScavengeLog(void);
static sqInt NoDbgRegParms getLongFromFileswap(sqImageFile _aFile, sqInt _swapFlag);
static sqInt NoDbgRegParms getShortFromFileswap(sqImageFile _aFile, sqInt _swapFlag);
static sqInt NoDbgRegParms getWord32FromFileswap(sqImageFile _aFile, sqInt _swapFlag);
static void NoDbgRegParms putLongtoFile(sqInt _aLong, sqImageFile _aFile);
static void NoDbgRegParms putShorttoFile(short _aShort, sqImageFile _aFile);
static void NoDbgRegParms putWord32toFile(int _aWord32, sqImageFile _aFile);
static sqInt NoDbgRegParms SIW_writeImageFilefromHeader(char *_imageFileName, SpurImageHeaderStruct _header);
static size_t NoDbgRegParms writeSegmentnextSegmenttoFile(SpurSegmentInfo *_segment, SpurSegmentInfo *_nextSegment, sqImageFile _aBinaryStream);
static sqInt NoDbgRegParms accessibleObjectAfter(sqInt _objOop);
static sqInt NoDbgRegParms NeverInline activeAndDeferredScan(sqInt _anEphemeron);
static void NoDbgRegParms addFreeSubTree(sqInt _freeTree);
extern sqInt addGCRoot(sqInt *_varLoc);
extern sqInt addressCouldBeObj(sqInt _address);
extern sqInt addressCouldBeOop(sqInt _address);
static sqInt NoDbgRegParms addToFreeListbytes(sqInt _freeChunk, sqInt _chunkBytes);
static sqInt NoDbgRegParms allInstancesOf(sqInt _aClass);
static sqInt allObjects(void);
static sqInt allObjectsUnmarked(void);
static sqInt allOldMarkedWeakObjectsOnWeaklingStack(void);
static sqInt allocateLargestFreeChunk(void);
static sqInt NoDbgRegParms allocateNewSpaceSlotsformatclassIndex(sqInt _numSlots, sqInt _formatField, sqInt _classIndex);
static sqInt NoDbgRegParms allocateOldSpaceChunkOfBytes(usqInt _chunkBytes);
extern sqInt allocatePinnedSlots(sqInt _nSlots);
static sqInt NoDbgRegParms allocateSlotsForPinningInOldSpacebytesformatclassIndex(sqInt _numSlots, usqInt _totalBytes, sqInt _formatField, sqInt _classIndex);
static sqInt NoDbgRegParms allocateSlotsInOldSpacebytesformatclassIndex(sqInt _numSlots, usqInt _totalBytes, sqInt _formatField, sqInt _classIndex);
static sqInt NoDbgRegParms allocateSlotsInPermSpacebytesformatclassIndex(sqInt _numSlots, usqInt _totalBytes, sqInt _formatField, sqInt _classIndex);
extern sqInt allocateSlotsformatclassIndex(sqInt _numSlots, sqInt _formatField, sqInt _classIndex);
static sqInt allocationUnit(void);
static sqInt allPermSpaceObjectsUnmarked(void);
static sqInt NoDbgRegParms allStrongSlotsOfWeaklingAreMarked(sqInt _aWeakling);
static sqInt allUnscannedEphemeronsAreActive(void);
extern sqInt arrayFormat(void);
static sqInt NoDbgRegParms NeverInline assertInnerValidFreeObject(sqInt _objOop);
static sqInt NoDbgRegParms becomeEffectFlagsFor(sqInt _objOop);
extern sqInt becomewith(sqInt _array1, sqInt _array2);
static sqInt NoDbgRegParms becomewithtwoWaycopyHash(sqInt _array1, sqInt _array2, sqInt _twoWayFlag, sqInt _copyHashFlag);
extern void beRootIfOld(sqInt _oop);
static sqInt bitsSetInFreeSpaceMaskForAllFreeLists(void);
extern usqInt boxedFloatObjectOf(double _aFloat);
static sqInt bridgeSize(void);
static sqInt byteFormatMask(void);
extern sqInt byteSizeOf(sqInt _oop);
static sqInt NoDbgRegParms changeClassOfto(sqInt _rcvr, sqInt _argClass);
extern sqInt characterObjectOf(sqInt _characterCode);
extern usqInt characterValueOf(sqInt _oop);
static sqInt NoDbgRegParms cheapAddressCouldBeInHeap(sqInt _address);
extern sqInt checkedLongAt(sqInt _byteAddress);
static sqInt checkHeapFreeSpaceIntegrity(void);
static sqInt NoDbgRegParms checkHeapIntegrityclassIndicesShouldBeValid(sqInt _excludeUnmarkedObjs, sqInt _classIndicesShouldBeValid);
extern sqInt checkOkayOop(usqInt _oop);
static sqInt NoDbgRegParms checkOopIntegritynamed(sqInt _obj, char *_name);
static sqInt NoDbgRegParms checkOopIntegritynamedindex(sqInt _obj, char *_name, sqInt _i);
extern sqInt classArray(void);
extern sqInt classAtIndex(sqInt _classIndex);
static sqInt NoDbgRegParms classAtIndexput(sqInt _classIndex, sqInt _objOop);
extern sqInt classBitmap(void);
extern sqInt classByteArray(void);
extern sqInt classCharacter(void);
extern sqInt classExternalAddress(void);
extern sqInt classExternalAddressIndex(void);
extern sqInt classFloat(void);
static sqInt NoDbgRegParms classFormatForInstanceFormat(sqInt _aFormat);
extern sqInt classIndexFieldWidth(void);
extern sqInt classIndexOf(sqInt _objOop);
extern sqInt classLargeNegativeInteger(void);
extern sqInt classLargePositiveInteger(void);
extern sqInt classOrNilAtIndex(sqInt _classIndex);
extern sqInt classPoint(void);
extern sqInt classSemaphore(void);
extern sqInt classSmallInteger(void);
extern sqInt classString(void);
extern sqInt classTableMinorIndexMask(void);
extern sqInt classTablePageSize(void);
extern sqInt classTableRootObj(void);
static sqInt classTableRootSlots(void);
extern sqInt classTagForClass(sqInt _classObj);
static void cleanUpPermToNewSpaceRememeberedSet(void);
static void cleanUpPermToOldSpaceRememeberedSet(void);
static void clearLeakMapAndMapAccessibleFreeSpace(void);
static sqInt NoDbgRegParms cloneInOldSpaceforPinning(sqInt _objOop, sqInt _forPinning);
extern sqInt clone(sqInt _objOop);
static sqInt NoDbgRegParms cloneshouldAllocateInPermSpace(sqInt _objOop, sqInt _shouldAllocateInPermSpace);
extern uint64_t codeEnd(void);
extern uint64_t codeStart(void);
extern sqInt compactClassIndexOf(sqInt _objOop);
extern void countMarkedAndUnmarkdObjects(sqInt _printFlags);
static usqLong currentAllocatedBytes(void);
static sqInt NoDbgRegParms doMoveToPermSpaceaddToRememberedSet(sqInt _objOop, sqInt _shouldAddToRememberedSet);
static void NoDbgRegParms doScavenge(sqInt _tenuringCriterion);
static sqInt doValidateObjectMemory(void);
extern sqInt eeInstantiateClassIndexformatnumSlots(sqInt _knownClassIndex, sqInt _objFormat, sqInt _numSlots);
static void NoDbgRegParms emptyObjStack(sqInt _objStack);
static sqInt NoDbgRegParms ensureRoomOnObjStackAt(sqInt _objStackRootIndex);
static sqInt NoDbgRegParms enterIntoClassTable(sqInt _aBehavior);
static sqInt ephemeronFormat(void);
static sqInt NoDbgRegParms existInstancesInNewSpaceOf(sqInt _classObj);
extern sqInt falseObject(void);
extern sqInt fetchByteofObject(sqInt _byteIndex, sqInt _objOop);
static sqInt NoDbgRegParms NeverInline fetchClassOfNonImm(sqInt _objOop);
extern sqInt fetchClassOf(sqInt _oop);
static sqInt NoDbgRegParms fetchClassTagOfNonImm(sqInt _obj);
static float NoDbgRegParms fetchFloat32ofObject(sqInt _index, sqInt _objOop);
static double NoDbgRegParms fetchFloat64ofObject(sqInt _index, sqInt _objOop);
extern sqInt fetchLong32ofObject(sqInt _fieldIndex, sqInt _oop);
static sqInt NoDbgRegParms fetchPointerofFreeChunk(sqInt _fieldIndex, sqInt _objOop);
extern sqInt fetchPointerofObject(sqInt _fieldIndex, sqInt _objOop);
static sqInt findLargestFreeChunk(void);
extern void findStringBeginningWith(char *_aCString);
extern void findString(char *_aCString);
static sqInt firstAccessibleObject(void);
extern void * firstBytePointerOfDataObject(sqInt _objOop);
static void * NoDbgRegParms firstFixedFieldOfMaybeImmediate(sqInt _oop);
extern void * firstFixedField(sqInt _objOop);
extern void * firstIndexableField(sqInt _objOop);
extern sqInt fixedFieldsOfClassFormatMask(void);
extern sqInt fixedFieldsOfClassFormat(sqInt _classFormat);
static sqInt NoDbgRegParms fixedFieldsOfClass(sqInt _objOop);
static sqInt NoDbgRegParms fixedFieldsOfformatlength(sqInt _objOop, sqInt _fmt, sqInt _wordLength);
static sqInt NoDbgRegParms NeverInline fixFollowedFieldofObjectwithInitialValue(sqInt _fieldIndex, sqInt _anObject, sqInt _initialValue);
static sqInt NoDbgRegParms followFieldofObject(sqInt _fieldIndex, sqInt _anObject);
extern sqInt followForwardedObjectFieldstoDepth(sqInt _objOop, sqInt _depth);
extern sqInt followForwarded(sqInt _objOop);
extern sqInt formatOfClassSafe(sqInt _oop);
extern sqInt formatOfClass(sqInt _classPointer);
static sqInt NoDbgRegParms formatOf(sqInt _objOop);
static sqInt forwardedFormat(void);
static sqInt freeChunkNextIndex(void);
static sqInt freeChunkParentIndex(void);
static sqInt freeChunkPrevIndex(void);
static sqInt NoDbgRegParms freeChunkWithBytesat(sqInt _bytes, sqInt _address);
extern sqInt freeObjectWithoutCoalesce(sqInt _objOop);
extern sqInt freeObject(sqInt _objOop);
extern sqInt freePermObject(sqInt _objOop);
extern usqLong NeverInline fullGC(void);
extern sqInt getAvoidSearchingSegmentsWithPinnedObjects(void);
extern VMRememberedSet * getFromOldSpaceRememberedSet(void);
extern VMRememberedSet * getFromPermToNewSpaceRememberedSet(void);
extern VMRememberedSet * getFromPermToOldSpaceRememberedSet(void);
static float getHeapGrowthToSizeGCRatio(void);
extern usqInt getMaxOldSpaceSize(void);
extern VMMemoryMap * getMemoryMap(void);
static sqInt NoDbgRegParms goodContextSize(sqInt _oop);
static size_t NoDbgRegParms growOldSpaceByAtLeastcallingOperation(sqInt _minAmmount, char *_aString);
static sqInt NoDbgRegParms hasIdentityHash(sqInt _objOop);
static sqInt NoDbgRegParms hasOldReferents(sqInt _objOop);
static sqInt NoDbgRegParms hasYoungReferents(sqInt _objOop);
extern usqLong headerForSlotsformatclassIndex(sqInt _numSlots, sqInt _formatField, sqInt _classIndex);
static usqLong NoDbgRegParms headerForSlotshashformatclassIndex(sqInt _numSlots, sqInt _hash, sqInt _formatField, sqInt _classIndex);
static sqInt hiddenRootSlots(void);
#if IMMUTABILITY
extern sqInt immutableBitMask(void);
#endif /* IMMUTABILITY */
extern sqInt indexOfin(sqInt _anElement, sqInt _anObject);
static void NoDbgRegParms inFreeTreeReplacewith(sqInt _treeNode, sqInt _newNode);
static sqInt NoDbgRegParms initialHeadroomgivenFreeOldSpaceInImage(sqInt _extraVmMemory, sqInt _freeOldSpaceInImage);
static sqInt NoDbgRegParms initialInstanceOf(sqInt _classObj);
static void NoDbgRegParms initializeFreeSpacePostLoad(sqInt _freeListObj);
static sqInt NoDbgRegParms initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(sqInt _startAddress, sqInt _numSlots, sqInt _formatField, sqInt _classIndex, sqInt _isPinned);
static void NeverInline initializeNewSpaceVariables(void);
static void NoDbgRegParms initializeObjectMemory(sqInt _bytesToShift);
extern void inOrderPrintFreeTreeprintList(sqInt _freeChunk, sqInt _printNextList);
static void NoDbgRegParms NeverInline inPlaceBecomeandcopyHashFlag(sqInt _obj1, sqInt _obj2, sqInt _copyHashFlag);
extern sqInt instanceSizeOf(sqInt _classObj);
extern sqInt instantiateClassindexableSize(sqInt _classObj, sqInt _nElements);
extern sqInt instantiateClassindexableSizeisPinned(sqInt _classObj, sqInt _nElements, sqInt _isPinned);
static sqInt NoDbgRegParms instantiateClassisPinnedisOldSpace(sqInt _classObj, sqInt _isPinned, sqInt _isOldSpace);
extern sqInt instSpecOfClassFormat(sqInt _classFormat);
static sqInt NoDbgRegParms instSpecOfClass(sqInt _classPointer);
static sqInt NoDbgRegParms isAnyPointerFormat(sqInt _format);
extern sqInt isArrayNonImm(sqInt _oop);
extern sqInt isArray(sqInt _oop);
extern sqInt isBytes(sqInt _oop);
extern sqInt isCharacterObject(sqInt _oop);
extern sqInt isCharacterValue(sqInt _anInteger);
static sqInt NoDbgRegParms isClassAtUniqueIndex(sqInt _aClass);
static sqInt NoDbgRegParms isCompiledMethodFormat(sqInt _format);
static sqInt NoDbgRegParms isCompiledMethodHeader(sqInt _objHeader);
extern sqInt isCompiledMethod(sqInt _objOop);
static sqInt NoDbgRegParms isContextHeader(sqInt _aHeader);
static sqInt NoDbgRegParms isContext(sqInt _oop);
static sqInt NoDbgRegParms isEmptyObjStack(sqInt _objStack);
static sqInt NoDbgRegParms isEnumerableObjectNoAssert(sqInt _objOop);
static sqInt NoDbgRegParms isEnumerableObject(sqInt _objOop);
static sqInt NoDbgRegParms isEphemeronFormat(sqInt _format);
static sqInt NoDbgRegParms isEphemeron(sqInt _objOop);
extern sqInt isFixedSizePointerFormat(sqInt _format);
static sqInt NoDbgRegParms isForwardedClassTag(sqInt _classIndex);
extern sqInt isForwarded(sqInt _objOop);
static sqInt NoDbgRegParms isFreeObject(sqInt _objOop);
static sqInt NoDbgRegParms isFreeOop(sqInt _oop);
extern sqInt isImmediate(sqInt _oop);
extern sqInt isIndexable(sqInt _objOop);
static sqInt NoDbgRegParms isInEden(sqInt _objOop);
static sqInt NoDbgRegParms isInFutureSpace(sqInt _address);
extern sqInt isInMemory(sqInt _address);
static sqInt NoDbgRegParms isInNewSpace(sqInt _objOop);
extern sqInt isInOldSpace(sqInt _address);
static sqInt NoDbgRegParms isInPastSpace(sqInt _address);
extern sqInt isInPermSpace(sqInt _address);
static sqInt NoDbgRegParms isLargeFreeObject(sqInt _objOop);
extern sqInt isMarkedOrPermanent(sqInt _anOop);
static sqInt NoDbgRegParms isMaybeFiredEphemeron(sqInt _objOop);
extern sqInt isNonImmediate(sqInt _oop);
extern sqInt isNotForwarded(sqInt _oop);
static sqInt NoDbgRegParms isObjEphemeron(sqInt _objOop);
static sqInt NoDbgRegParms isObjImmutable(sqInt _anOop);
extern sqInt isOld(sqInt _oop);
extern sqInt isOopCompiledMethod(sqInt _oop);
extern sqInt isOopForwarded(sqInt _oop);
extern sqInt isOopImmutable(sqInt _oop);
extern sqInt isOopMutable(sqInt _oop);
extern sqInt isPermanent(sqInt _oop);
extern sqInt isPermSpaceRememberedSetSane(void);
static sqInt NoDbgRegParms isPermSpaceRememberedSetSaneMemberwithNewSpaceRefswithOldSpaceRefs(sqInt _objOop, sqInt _refersNewSpace, sqInt _refersOldSpace);
extern sqInt isPinned(sqInt _objOop);
extern sqInt isPointers(sqInt _oop);
static sqInt NoDbgRegParms isPureBitsFormat(sqInt _format);
extern sqInt isReallyYoungObject(sqInt _objOop);
extern sqInt isReallyYoung(sqInt _oop);
static sqInt NoDbgRegParms isRemembered(sqInt _objOop);
static sqInt NoDbgRegParms isSegmentBridge(sqInt _objOop);
static sqInt NoDbgRegParms isSemaphoreOop(sqInt _anOop);
extern sqInt isUnambiguouslyForwarder(sqInt _objOop);
extern sqInt isValidClassTag(sqInt _classIndex);
static sqInt NoDbgRegParms isValidObjStackAt(sqInt _objStackRootIndex);
static sqInt NoDbgRegParms isValidObjStackPagemyIndex(sqInt _objStackPage, sqInt _myx);
static sqInt NoDbgRegParms isValidObjStackPagemyIndexfirstPage(sqInt _objStackPage, sqInt _myx, sqInt _isFirstPage);
static sqInt NoDbgRegParms isValidObjStack(sqInt _objStack);
static sqInt NoDbgRegParms isValidToMoveToPermSpace(sqInt _objOop);
static sqInt NoDbgRegParms isWeakFormat(sqInt _format);
static sqInt NoDbgRegParms isWeakNonImm(sqInt _objOop);
extern sqInt isWeak(sqInt _oop);
extern sqInt isWordsOrBytes(sqInt _oop);
extern sqInt isWords(sqInt _oop);
extern sqInt isYoung(sqInt _oop);
static sqInt NoDbgRegParms isinstanceOfcompactClassIndex(sqInt _oop, sqInt _classOop, sqInt _compactClassIndex);
static sqInt NoDbgRegParms isonObjStack(sqInt _oop, sqInt _objStack);
static sqInt NoDbgRegParms keyOfEphemeron(sqInt _objOop);
static sqInt NoDbgRegParms knownClassAtIndex(sqInt _classIndex);
static sqInt lastPointerFormat(void);
extern sqInt lastPointerOfWhileSwizzling(sqInt _objOop);
extern sqInt lastPointerOf(sqInt _objOop);
extern sqInt leakCheckBecome(void);
extern sqInt leakCheckFullGC(void);
extern sqInt leakCheckIncremental(void);
extern sqInt leakCheckNewSpaceGC(void);
static sqInt NoDbgRegParms lengthOfMaybeImmediate(sqInt _oop);
extern sqInt lengthOf(sqInt _objOop);
extern sqInt literalCountOfMethodHeader(sqInt _header);
extern sqInt literalCountOf(sqInt _methodPointer);
extern void longPrintInstancesOf(sqInt _aClassOop);
extern void longPrintInstancesWithClassIndex(sqInt _classIndex);
extern void longPrintReferencesTo(sqInt _anOop);
static void mapExtraRoots(void);
static void NeverInline mapMournQueue(void);
static sqInt NoDbgRegParms markAndShouldScan(sqInt _objOop);
static void NoDbgRegParms markAndTraceClassOf(sqInt _objOop);
static void markAndTraceHiddenRoots(void);
static void NoDbgRegParms markAndTraceObjStackandContents(sqInt _stackOrNil, sqInt _markAndTraceContents);
extern void NeverInline markAndTrace(sqInt _objOop);
static sqInt markInactiveEphemerons(void);
static void NoDbgRegParms NeverInline markObjects(sqInt _objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged);
static void markWeaklingsAndMarkAndFireEphemerons(void);
extern sqInt maybeMethodClassOfseemsToBeInstantiating(sqInt _methodObj, sqInt _format);
extern sqInt maybeSplObj(sqInt _index);
static sqInt memoryActiveProcess(void);
extern sqInt minSlotsForShortening(void);
static void moveToPermSpaceAllOldObjects(void);
static sqInt NoDbgRegParms moveToPermSpaceInBulk(sqInt _anArrayOop);
static sqInt NoDbgRegParms moveToPermSpace(sqInt _objOop);
static sqInt NoDbgRegParms newHashBitsOf(sqInt _objOop);
static sqInt newObjectHash(void);
static sqInt newSpaceIsEmpty(void);
extern sqInt nilObject(void);
static void NeverInline nilUnmarkedWeaklingSlots(void);
static sqInt NoDbgRegParms noCheckClassAtIndex(sqInt _classIndex);
static sqInt NoDbgRegParms noCheckPushonObjStack(sqInt _objOop, sqInt _objStack);
static sqInt NoDbgRegParms noFixupFollowFieldofObject(sqInt _fieldIndex, sqInt _anObject);
static sqInt NoDbgRegParms noInlineFollowForwarded(sqInt _objOop);
static sqInt NoDbgRegParms noInlineObjectAfterlimit(sqInt _objOop, sqInt _limit);
extern sqInt nonIndexablePointerFormat(void);
static sqInt noUnscannedEphemerons(void);
extern sqLong nullHeaderForMachineCodeMethod(void);
static sqInt NoDbgRegParms numBytesOfBytes(sqInt _objOop);
extern sqInt numBytesOf(sqInt _objOop);
extern usqInt numPointerSlotsOf(sqInt _objOop);
static usqInt NoDbgRegParms numSlotsOfAny(sqInt _objOop);
extern usqInt numSlotsOf(sqInt _objOop);
static sqInt NoDbgRegParms numStrongSlotsOfInephemeral(sqInt _objOop);
extern sqInt numStrongSlotsOfWeakling(sqInt _objOop);
extern sqInt objectAfter(sqInt _objOop);
extern sqInt objectBefore(sqInt _objOop);
static sqInt NoDbgRegParms objectStartingAt(sqInt _address);
extern sqInt obsoleteDontUseThisFetchWordofObject(sqInt _fieldIndex, sqInt _oop);
extern sqInt oldSpaceObjectAfter(sqInt _objOop);
static size_t oldSpaceSizeToWrite(void);
static void NoDbgRegParms NeverInline outOfPlaceBecomeandcopyHashFlag(sqInt _obj1, sqInt _obj2, sqInt _copyHashFlag);
static sqInt NoDbgRegParms paddingForFormatInstBytesshiftForElement(sqInt _instBytes, sqInt _shiftForElement);
extern sqInt pinObject(sqInt _objOop);
static sqInt NoDbgRegParms popObjStack(sqInt _objStack);
extern sqInt popRemappableOop(void);
static void NoDbgRegParms postBecomeScanClassTable(sqInt _effectsFlags);
extern sqInt primitiveErrorTable(void);
extern void printActivationsOf(sqInt _aMethodObj);
extern void printBogons(void);
extern void printClassTableEntries(void);
extern void printContextReferencesTo(sqInt _anOop);
extern void printEntity(sqInt _oop);
extern void printForwarders(void);
extern void printFreeChunks(void);
extern void printFreeChunk(sqInt _freeChunk);
static void NoDbgRegParms printFreeChunkprintAsTreeNode(sqInt _freeChunk, sqInt _printAsTreeNode);
extern void printFreeListHeads(void);
extern sqInt printFreeList(sqInt _chunkOrIndex);
extern void printFreeTree(void);
static void NoDbgRegParms printFreeTreeChunk(sqInt _chunkOrZero);
extern void printHeaderOf(sqInt _objOop);
static void NoDbgRegParms printHeaderTypeOf(sqInt _objOop);
extern void printInstancesOf(sqInt _aClassOop);
extern void printInstancesWithClassIndex(sqInt _classIndex);
extern void printInvalidClassTableEntries(void);
#if LLDB
extern void printMarkedOops(void);
#endif /* LLDB */
extern void printMethodImplementorsOf(sqInt _anOop);
extern void printMethodReferencesTo(sqInt _anOop);
extern void printObjectsFromto(sqInt _startAddress, sqInt _endAddress);
extern void printObjectsWithHash(sqInt _hash);
static void NoDbgRegParms printObjStackPagemyIndexpageType(sqInt _objStackPage, sqInt _myx, sqInt _pageType);
static void NoDbgRegParms printObjStackPagemyIndextag(sqInt _objStackPage, sqInt _myx, char *_pageType);
extern void printObjStack(sqInt _objStack);
extern void NeverInline printOopsExcept(sqInt (*_function)(sqInt));
extern void printOopsFromto(sqInt _startAddress, sqInt _endAddress);
extern void NeverInline printOopsSuchThat(sqInt (*_function)(sqInt));
extern void printReferencesTo(sqInt _anOop);
#if LLDB
extern void printUnmarkedOops(void);
#endif /* LLDB */
static sqInt NoDbgRegParms pushOnUnscannedEphemeronsStack(sqInt _anEphemeron);
extern void pushRemappableOop(sqInt _oop);
extern sqInt rawHashBitsOf(sqInt _objOop);
extern sqInt rawHeaderOf(sqInt _methodPointer);
static void * NoDbgRegParms readPointerAtPointer(sqInt _aCArrayAccessor);
static int16_t NoDbgRegParms readSINT16AtPointer(sqInt _aCArrayAccessor);
static int32_t NoDbgRegParms readSINT32AtPointer(sqInt _aCArrayAccessor);
static int64_t NoDbgRegParms readSINT64AtPointer(sqInt _aCArrayAccessor);
static int8_t NoDbgRegParms readSINT8AtPointer(sqInt _aCArrayAccessor);
static uint16_t NoDbgRegParms readUINT16AtPointer(sqInt _aCArrayAccessor);
static uint32_t NoDbgRegParms readUINT32AtPointer(sqInt _aCArrayAccessor);
static uint64_t NoDbgRegParms readUINT64AtPointer(sqInt _aCArrayAccessor);
static uint8_t NoDbgRegParms readUINT8AtPointer(sqInt _aCArrayAccessor);
static void recreateFromPermSpaceRememberedSet(void);
static sqInt NoDbgRegParms relocateObjStackForPlanningCompactor(sqInt _objStack);
extern sqInt rememberObjInCorrectRememberedSet(sqInt _objOop);
extern sqInt removeGCRoot(sqInt *_varLoc);
static void NoDbgRegParms runLeakCheckerForFreeSpace(sqInt _gcModes);
static void NoDbgRegParms runLeakCheckerFor(sqInt _gcModes);
static void NoDbgRegParms runLeakCheckerForexcludeUnmarkedObjsclassIndicesShouldBeValid(sqInt _gcModes, sqInt _excludeUnmarkedObjs, sqInt _classIndicesShouldBeValid);
static void NoDbgRegParms scavengingGCTenuringIf(sqInt _tenuringCriterion);
extern void setAvoidSearchingSegmentsWithPinnedObjects(sqInt _aValue);
extern sqInt setMaxOldSpaceSize(usqInt _limit);
extern void setMaxSlotsForNewSpaceAlloc(sqInt _aValue);
extern void setMinimalPermSpaceSize(sqInt _min);
extern void shortPrintObjectsFromto(sqInt _startAddress, sqInt _endAddress);
extern sqInt shouldRemapOop(sqInt _oop);
static usqInt sizeOfLargestFreeChunk(void);
static sqInt NoDbgRegParms sizeOfObjStack(sqInt _objStack);
static sqInt slidingCompactionInProgress(void);
extern sqInt slotSizeOf(sqInt _oop);
extern sqInt splObj(sqInt _index);
static usqInt NoDbgRegParms startOfObject(sqInt _objOop);
EXPORT(sqInt) statNumGCs(void);
extern uint64_t storeCheckBoundary(void);
extern sqInt storePointerUncheckedofObjectwithValue(sqInt _fieldIndex, sqInt _objOop, sqInt _valuePointer);
extern sqInt storePointerofObjectwithValue(sqInt _fieldIndex, sqInt _objOop, sqInt _valuePointer);
extern sqInt stringForCString(const char *_aCString);
static sqInt NoDbgRegParms sufficientSpaceAfterGC(sqInt _numBytes);
static sqInt NoDbgRegParms swizzleObjStackAt(sqInt _objStackRootIndex);
extern void tenuringIncrementalGC(void);
static sqInt NoDbgRegParms topOfObjStack(sqInt _objStack);
extern sqInt topRemappableOop(void);
static size_t totalBytesInPermanentSpace(void);
static sqInt totalFreeListBytes(void);
extern sqInt trueObject(void);
static sqInt NoDbgRegParms unlinkFreeChunkchunkBytes(sqInt _freeChunk, sqInt _chunkBytes);
static sqInt NoDbgRegParms NeverInline unlinkLilliputianChunkindex(sqInt _freeChunk, sqInt _index);
static void NoDbgRegParms unlinkSolitaryFreeTreeNode(sqInt _freeTreeNode);
extern sqInt unpinObject(sqInt _objOop);
static void NoDbgRegParms updateListStartingAt(sqInt _freeNode);
extern void validateObjectMemory(void);
static sqInt validClassTableHashes(void);
static sqInt validClassTableRootPages(void);
extern sqInt validFreeTree(void);
static sqInt NoDbgRegParms validFreeTreeChunk(sqInt _chunk);
static const char * NoDbgRegParms validFreeTreeChunkparent(sqInt _chunk, sqInt _parent);
static sqInt validObjStacks(void);
extern sqInt vmEndianness(void);
extern sqInt zeroSlotsNonIndexablePointerFormat(void);
static void NeverInline compact(void);
static sqInt NeverInline copyAndUnmarkMobileObjects(void);
static void NoDbgRegParms NeverInline copyAndUnmark(sqInt _firstPass);
static void NoDbgRegParms freeFromupTonextObject(usqInt _initialToFinger, usqInt _limit, sqInt _nextObject);
static sqInt initializeScanCheckingForFullyCompactedHeap(void);
static sqInt NoDbgRegParms isMobile(sqInt _obj);
static sqInt NoDbgRegParms isPostMobile(sqInt _obj);
static sqInt NeverInline planCompactSavingForwarders(void);
static void NoDbgRegParms reinitializeScanFrom(sqInt _initialObject);
extern sqInt remapObj(sqInt _objOop);
static sqInt savedFirstFieldsSpaceWasAllocated(void);
static sqInt NoDbgRegParms scanForFirstFreeAndFirstMobileObjectFrom(sqInt _initialObject);
extern sqInt shouldRemapObj(sqInt _objOop);
static void NoDbgRegParms unmarkInitialImmobileObjectsFreeUnmarked(sqInt _freeUnmarked);
static void unmarkObjectsFromFirstFreeObject(void);
static void NeverInline updatePointers(void);
static void updatePointersInManagerHeapEntities(void);
static void NoDbgRegParms updatePointersInsavedFirstFieldPointer(sqInt _obj, sqInt _firstFieldPtr);
static sqInt NoDbgRegParms useSegmentForSavedFirstFieldsSpace(sqInt _spaceEstimate);
static sqInt NoDbgRegParms validRelocationPlanInPass(sqInt onePass);
static usqInt NoDbgRegParms segLimit(SpurSegmentInfo * self_in_segLimit);
static SpurSegmentInfo * NoDbgRegParms addSegmentOfSize(sqInt _ammount);
static sqInt allBridgesMarked(void);
static void allocateOrExtendSegmentInfos(void);
static sqInt NoDbgRegParms bridgeAt(sqInt _segIndex);
static sqInt NoDbgRegParms bridgeFor(SpurSegmentInfo *_aSegment);
static void NoDbgRegParms bridgeFromto(SpurSegmentInfo *_aSegment, SpurSegmentInfo *_nextSegmentOrNil);
static void checkSegments(void);
static void collapseSegmentsPostSwizzle(void);
static void * NoDbgRegParms firstGapOfSizeAtLeast(sqInt _size);
static size_t firstSegmentBytes(void);
static sqInt NoDbgRegParms isEmptySegment(SpurSegmentInfo *_seg);
static sqInt NoDbgRegParms isInSegments(usqInt _address);
static sqInt NoDbgRegParms isValidSegmentBridge(sqInt _objOop);
static SpurSegmentInfo * NoDbgRegParms nextNonEmptySegmentAfter(sqInt _i);
static void postSnapshot(void);
static void NeverInline prepareForSnapshot(void);
EXPORT(SpurSegmentInfo *) segmentContainingObj(sqInt _objOop);
static sqInt segmentOverlap(void);
static sqInt NoDbgRegParms shrinkObjectMemory(usqInt _delta);
static sqInt someSegmentContainsPinned(void);
static sqInt NoDbgRegParms swizzleObj(sqInt _objOop);
static size_t totalBytesInNonEmptySegments(void);
static usqInt totalBytesInSegments(void);
extern sqInt activeProcess(void);
extern void addIdleUsecs(sqInt _idleUsecs);
static void NoDbgRegParms addLastLinktoList(sqInt _proc, sqInt _aList);
static sqInt NoDbgRegParms addressCouldBeClassObj(sqInt _maybeClassObj);
static char * allOnesAsCharStar(void);
extern sqInt argumentCountOfClosure(sqInt _closurePointer);
extern sqInt argumentCountOfMethodHeader(sqInt _header);
extern sqInt argumentCountOf(sqInt _methodPointer);
extern void * arrayValueOf(sqInt _arrayOop);
extern void assertValidExecutionPointers(usqInt _lip, char *_lifp, char *_lisp);
static void NoDbgRegParms assertValidStackLimits(sqInt _ln);
extern sqInt booleanValueOf(sqInt _obj);
extern sqInt canContextSwitchIfActivatingheader(sqInt _theMethod, sqInt _methodHeader);
extern sqInt characterForAscii(sqInt _ascii);
static sqInt checkDeliveryOfLongRunningPrimitiveSignal(void);
extern sqInt checkedIntegerValueOf(sqInt _intOop);
static sqInt NoDbgRegParms checkForEventsMayContextSwitch(sqInt _mayContextSwitch);
static sqInt checkInterpreterIntegrity(void);
static sqInt NoDbgRegParms checkIsStillMarriedContextcurrentFP(sqInt _aContext, char *_currentFP);
static void NoDbgRegParms checkProfileTick(sqInt _aPrimitiveMethod);
static sqInt checkStackIntegrity(void);
static sqInt NoDbgRegParms checkStackPointerForMaybeMarriedContext(sqInt _aContext);
static sqInt NoDbgRegParms checkStackPointerIndexForFrame(char *_theFP);
static sqInt NoDbgRegParms classNameOfIs(sqInt _aClass, char *_className);
static sqInt NoDbgRegParms contexthasSender(sqInt _thisCntx, sqInt _aContext);
static sqInt NoDbgRegParms contexthasValidInversePCMappingOfin(sqInt _aContext, sqInt _theIP, char *_theFP);
extern sqInt copiedValueCountOfFullClosure(sqInt _closurePointer);
extern sqInt copyBits(void);
extern sqInt copyBitsFromtoat(sqInt x0, sqInt x1, sqInt y);
static sqInt NoDbgRegParms NeverInline couldBeProcess(sqInt _oop);
static sqInt cr(void);
static void NoDbgRegParms createActualMessageTo(sqInt _lookupClass);
static sqInt defaultNumStackPages(void);
static sqInt divorceAllFrames(void);
static void NoDbgRegParms divorceFramesIn(StackPage *_aStackPage);
static void NoDbgRegParms divorceFrameandContext(char *_theFP, sqInt _ctxt);
static sqInt NoDbgRegParms doPrimitiveDivby(sqInt _rcvr, sqInt _arg);
static sqInt NoDbgRegParms doPrimitiveModby(sqInt _rcvr, sqInt _arg);
extern sqInt doSignalSemaphoreWithIndex(sqInt _index);
extern void doWaitSemaphorereEnterInterpreter(sqInt _sema, sqInt _hasToReenter);
static sqInt NoDbgRegParms encodeFrameFieldHasContextisBlocknumArgs(sqInt _hasContext, sqInt _isBlock, sqInt _numArgs);
static sqInt NoDbgRegParms ensureCallerContext(char *_theFP);
static void NoDbgRegParms ensureImageFormatIsUpToDate(sqInt _swapBytes);
static char * NoDbgRegParms ensureIsBaseFrame(char *_aFramePtr);
static char * NoDbgRegParms establishFrameForContextToReturnTo(sqInt _contextToReturnTo);
static sqInt executeQuickPrimitive(void);
static void failUnbalancedPrimitive(void);
extern void * fetchArrayofObject(sqInt _fieldIndex, sqInt _objectPointer);
extern double fetchFloatofObject(sqInt _fieldIndex, sqInt _objectPointer);
extern sqInt fetchIntegerofObject(sqInt _fieldIndex, sqInt _objectPointer);
static sqInt NoDbgRegParms fetchPointerofMarriedContext(sqInt _offset, sqInt _aContext);
static sqInt NoDbgRegParms fetchStackPointerOf(sqInt _aContext);
static sqInt NoDbgRegParms findClassContainingMethodstartingAt(sqInt _meth, sqInt _classObj);
extern sqInt findClassOfMethodforReceiver(sqInt _meth, sqInt _rcvr);
static char * NoDbgRegParms findFrameAboveinPage(char *_theFP, StackPage *_thePage);
static sqInt NoDbgRegParms findHomeForContext(sqInt _aContext);
static sqInt NoDbgRegParms findMethodWithPrimitiveFromContextUpToContext(sqInt _primitive, sqInt _senderContext, sqInt _homeContext);
extern sqInt findSelectorOfMethod(sqInt _meth);
static char * NoDbgRegParms findSPOfon(char *_theFP, StackPage *_thePage);
static sqInt NoDbgRegParms findUnwindThroughContext(sqInt _homeContext);
static void NoDbgRegParms followForwardedFrameContentsstackPointer(char *_theFP, char *_theSP);
static void NoDbgRegParms followForwardingPointersInStackZone(sqInt _theBecomeEffectsFlags);
extern sqInt forceInterruptCheck(void);
static sqInt NoDbgRegParms frameCallerContext(char *_theFP);
static sqInt NoDbgRegParms frameContext(char *_theFP);
static char * NoDbgRegParms frameOfMarriedContext(sqInt _aContext);
static sqInt NoDbgRegParms frameStackedReceiverOffsetNumArgs(sqInt _numArgs);
static sqInt NoDbgRegParms frameStackedReceiverOffset(char *_theFP);
static void freeUntracedStackPages(void);
extern void (*functionPointerForinClass(sqInt _primIdx))(void) ;
extern sqInt getExternalSemaphoreWithIndex(sqInt _index);
extern usqLong getNextWakeupUsecs(void);
extern sqInt * getStackPointer(void);
extern sqInt getThisSessionID(void);
static sqInt NoDbgRegParms handleForwardedSelectorFaultFor(sqInt _selectorOop);
static sqInt NoDbgRegParms handleForwardedSendFaultForTag(sqInt _classTag);
static sqInt NoDbgRegParms handleSpecialSelectorSendFaultForfpsp(sqInt _obj, char *_theFP, char *_theSP);
static void NeverInline handleStackOverflow(void);
static sqInt NoDbgRegParms handleStackOverflowOrEventAllowContextSwitch(sqInt _mayContextSwitch);
extern sqInt hasCheckAllocFiller(void);
extern sqInt hasProfileSemaphore(void);
extern usqInt highBit(usqInt _anUnsignedValue);
static sqInt NoDbgRegParms ifCurrentStackPageHasValidHeadPointers(StackPage *_thePage);
static sqInt NoDbgRegParms iframeIsBlockActivation(char *_theFP);
static usqInt NoDbgRegParms iframeMethod(char *_theFP);
static sqInt NoDbgRegParms iframeReceiver(char *_theFP);
extern sqInt includesBehaviorThatOf(sqInt _aClass, sqInt _aSuperclass);
static sqInt NoDbgRegParms inlineLookupInMethodCacheSelclassTag(sqInt _selector, sqInt _classTag);
extern void ioFilenamefromStringofLengthresolveAliases(char *_aCharBuffer, char *_aFilenameString, sqInt _filenameLength, sqInt aBoolean);
static sqInt NoDbgRegParms isBaseFrame(char *_theFP);
extern sqInt isBooleanObject(sqInt _oop);
extern sqInt isFloatObject(sqInt _oop);
static sqInt NoDbgRegParms isFrameonPage(char *_aFrame, StackPage *_aPage);
extern sqInt isKindOfInteger(sqInt _oop);
extern sqInt isLargeIntegerObject(sqInt _oop);
extern sqInt isLargeNegativeIntegerObject(sqInt _oop);
extern sqInt isLargePositiveIntegerObject(sqInt _oop);
static sqInt NoDbgRegParms isLiveContext(sqInt _oop);
static sqInt NoDbgRegParms isMarriedOrWidowedContext(sqInt _aContext);
static sqInt NoDbgRegParms isMetaPrimitiveIndex(sqInt _primIndex);
static sqInt isPrimitiveFunctionPointerAnIndex(void);
extern sqInt isQuickPrimitiveIndex(sqInt _anInteger);
extern sqInt isReadMediatedContextInstVarIndex(sqInt _index);
static sqInt NoDbgRegParms isSingleContext(sqInt _aContext);
static sqInt NoDbgRegParms isWidowedContextDuringGC(sqInt _aOnceMarriedContext);
static sqInt NoDbgRegParms isWidowedContext(sqInt _aOnceMarriedContext);
extern sqInt isWriteMediatedContextInstVarIndex(sqInt _index);
extern sqInt isKindOfClass(sqInt _oop, sqInt _aClass);
extern sqInt isKindOf(sqInt _oop, char *_className);
extern sqInt isMemberOf(sqInt _oop, char *_className);
static sqInt NoDbgRegParms lengthOfNameOfClass(sqInt _classOop);
extern sqInt literalofMethod(sqInt _offset, sqInt _methodPointer);
extern sqInt loadBitBltFrom(sqInt bb);
extern void loadInitialContext(void);
extern void longPrintOop(sqInt _oop);
extern sqInt longStoreBytecodeForHeader(sqInt methodHeader);
static sqInt NoDbgRegParms lookupInMethodCacheSelclassTag(sqInt _selector, sqInt _classTag);
static sqInt NoDbgRegParms lookupMethodInClass(sqInt _class);
static sqInt NoDbgRegParms lookupMethodWithoutMNUProcessingInClass(sqInt _class);
extern sqInt lookupSelectorinClass(sqInt _selector, sqInt _class);
static StackPage * NoDbgRegParms makeBaseFrameFor(sqInt _aContext);
static void NoDbgRegParms makeContextSnapshotSafe(sqInt _ctxt);
extern usqInt makePointwithxValueyValue(sqInt _xValue, sqInt _yValue);
static void mapInterpreterOops(void);
static void NeverInline mapStackPages(void);
static sqInt NoDbgRegParms markAndTraceStackPages(sqInt _fullGCFlag);
static void NoDbgRegParms markAndTraceStackPage(StackPage *_thePage);
static void markAndTraceUntracedReachableStackPages(void);
static sqInt NoDbgRegParms marriedContextpointsTostackDeltaForCurrentFrame(sqInt _spouseContext, sqInt _anOop, sqInt _stackDeltaForCurrentFrame);
static void NoDbgRegParms marryContextInNewStackPageAndInitializeInterpreterRegisters(sqInt _aContext);
static sqInt NoDbgRegParms marryFrameSP(char *_theFP, char *_theSP);
static sqInt NoDbgRegParms maybeLeakCheckExternalPrimCall(sqInt _aMethodObj);
extern sqInt maybeSelectorOfMethod(sqInt _methodObj);
extern sqInt methodArgumentCount(void);
extern sqInt methodClassAssociationOf(sqInt _methodPointer);
extern sqInt methodClassOf(sqInt _methodPointer);
static sqInt NoDbgRegParms methodHeaderHasPrimitive(sqInt _methodHeader);
extern sqInt methodPrimitiveIndex(void);
extern sqInt methodReturnBool(sqInt _boolean);
extern sqInt methodReturnFloat(double _aFloat);
extern sqInt methodReturnInteger(sqInt _integer);
extern sqInt methodReturnReceiver(void);
extern sqInt methodReturnString(char *_aCString);
extern sqInt methodReturnValue(sqInt _oop);
EXPORT(void) moduleUnloaded(char *aModuleName);
static char * NoDbgRegParms moveFramesInthroughtoPage(StackPage *_oldPage, char *_theFP, StackPage *_newPage);
static char * NoDbgRegParms nameOfClass(sqInt _classOop);
static sqInt NoDbgRegParms noInlineTemporaryin(sqInt _offset, char *_theFP);
static sqInt NoDbgRegParms noMarkedContextsOnPage(StackPage *_thePage);
static sqInt numStkPages(void);
extern sqInt objCouldBeClassObj(sqInt _objOop);
extern sqInt penultimateLiteralOf(sqInt _aMethodOop);
extern sqInt popStack(void);
extern sqInt pop(sqInt _nItems);
extern void popthenPush(sqInt _nItems, sqInt _oop);
extern sqInt positive32BitIntegerFor(unsigned int _integerValue);
extern sqInt positive64BitIntegerFor(usqLong _integerValue);
static sqInt NoDbgRegParms positiveMachineIntegerFor(usqIntptr_t _value);
EXPORT(void) primitiveCompareBytes(void);
static void primitiveEnterCriticalSection(void);
static void primitiveExitCriticalSection(void);
static void primitiveFloat64ArrayAdd(void);
extern sqInt primitiveIndexOfMethodheader(sqInt _theMethod, sqInt _methodHeader);
extern sqInt primitiveIndexOf(sqInt _methodPointer);
static void primitiveResume(void);
static void primitiveSuspend(void);
static void primitiveYield(void);
static void NoDbgRegParms printActivationNameForSelectorstartClass(sqInt _aSelector, sqInt _startClass);
static void NoDbgRegParms printActivationNameForreceiverisBlockfirstTemporary(sqInt _aMethod, sqInt _anObject, sqInt _isBlock, sqInt _maybeMessage);
extern void printAllPermanentObjects(void);
extern void printAllStacks(void);
extern void printCallStack(void);
static sqInt NoDbgRegParms printCallStackFP(char *_theFP);
extern sqInt printCallStackOf(sqInt _aContextOrProcessOrFrame);
static sqInt NoDbgRegParms printCallStackOfcurrentFP(sqInt _aContext, char *_currFP);
extern void printChar(sqInt _aByte);
static sqInt NoDbgRegParms printContextCallStackOf(sqInt _aContext);
extern void printContext(sqInt _aContext);
static void NoDbgRegParms printDecodeMethodHeaderOop(sqInt _methodHeaderOop);
extern void printExternalHeadFrame(void);
static sqInt NoDbgRegParms printFrameAndCallersSPshort(char *_theFP, char *_theSP, sqInt _printShort);
static void NoDbgRegParms printFrameOopat(char *_name, char *_address);
static void NoDbgRegParms printFrameOopindexat(char *_name, sqInt _idx, char *_address);
EXPORT(void) printFramesInPage(StackPage *_thePage);
EXPORT(void) printFramesOnStackPageListInUse(void);
static void NoDbgRegParms printFrameThingandFrameat(char *_name, char *_theFP, char *_address);
static void NoDbgRegParms printFrameThingat(char *_name, char *_address);
static void NoDbgRegParms printFrameThingatextraString(char *_name, char *_address, char *_extraStringOrNil);
static void NoDbgRegParms printFrameThingatextra(char *_name, char *_address, sqInt _extraValue);
extern sqInt printFrame(char *_theFP);
static sqInt NoDbgRegParms printHexnpnp(usqInt _n);
extern sqInt printHexnp(usqInt _n);
extern void printHex(usqInt n);
extern void printLikelyImplementorsOfSelector(sqInt _selector);
extern void printMethodCache(void);
extern void printMethodDictionaryOf(sqInt _behavior);
extern void printMethodDictionary(sqInt _dictionary);
static void NoDbgRegParms printNameOfClasscount(sqInt _classOop, sqInt _cnt);
static void NoDbgRegParms printNum(sqInt n);
static void NoDbgRegParms printOopShort(sqInt _oop);
extern sqInt printOop(sqInt _oop);
extern void printPointersTo(sqInt _anAddress);
extern void printProcessStack(sqInt _aProcess);
extern sqInt printProcsOnList(sqInt _procList);
extern sqInt printStackCallStackOf(sqInt _aContextOrProcessOrFrame);
extern void printStackPageList(void);
extern void printStackPageListInUse(void);
extern void printStackPages(void);
extern void printStackPagesInUse(void);
static void NoDbgRegParms printStackPageuseCount(StackPage *_page, sqInt _n);
extern void printStackReferencesTo(sqInt _oop);
extern void printStringOf(sqInt _oop);
extern void print(char *s);
extern sqInt pushBool(sqInt _trueOrFalse);
static sqInt NoDbgRegParms pushedReceiverOrClosureOfFrame(char *_theFP);
extern void pushFloat(double _f);
extern sqInt pushInteger(sqInt _integerValue);
extern void push(sqInt _object);
static void NoDbgRegParms putToSleepyieldingIf(sqInt _aProcess, sqInt _yieldImplicitly);
static sqInt NoDbgRegParms quickFetchIntegerofObject(sqInt _fieldIndex, sqInt _objectPointer);
static sqInt NoDbgRegParms NeverInline reapAndResetErrorCodeToheader(sqInt _theFP, sqInt _methodHeader);
static sqInt NoDbgRegParms removeFirstLinkOfList(sqInt _aList);
static sqInt NoDbgRegParms resumepreemptedYieldingIffrom(sqInt _aProcess, sqInt _yieldImplicitly, sqInt _sourceCode);
static sqInt retryPrimitiveOnFailure(void);
static sqInt NoDbgRegParms safeMethodClassOf(sqInt _methodPointer);
static sqInt NoDbgRegParms saneFunctionPointerForFailureOfPrimIndex(sqInt _primIndex);
extern void setBreakMNUSelector(char *_aString);
extern void setBreakSelector(char *_aString);
extern sqInt setDesiredEdenBytes(usqLong _bytes);
extern void setDesiredStackPageBytes(sqInt _desiredBytes);
extern void setMaxStacksToPrint(sqInt _anInteger);
extern void setNextWakeupUsecs(usqLong _value);
static void setSignalLowSpaceFlagAndSaveProcess(void);
static void NoDbgRegParms setTraceFlagOnContextsFramesPageIfNeeded(sqInt _aContext);
static sqInt NoDbgRegParms shortPrintContext(sqInt _aContext);
static sqInt NoDbgRegParms shortPrintFrameAndCallers(char *_theFP);
EXPORT(void) shortPrintFramesInPage(StackPage *_thePage);
EXPORT(void) shortPrintFramesOnStackPageListInUse(void);
static sqInt NoDbgRegParms shortPrintFrame(char *_theFP);
extern void shortPrintFrameAndNCallers(char *_theFP, sqInt _n);
static sqInt NoDbgRegParms shortPrintOop(sqInt _oop);
static sqInt NoDbgRegParms shortReversePrintFrameAndCallers(char *_aFramePointer);
static sqInt signalExternalSemaphores(void);
extern sqInt signed32BitIntegerFor(sqInt _integerValue);
extern sqInt signed64BitIntegerFor(sqLong _integerValue);
extern sqInt sizeOfCallPrimitiveBytecode(sqInt methodHeader);
extern sqInt sizeOfLongStoreTempBytecode(sqInt methodHeader);
extern sqInt sizeOfSTArrayFromCPrimitive(void *_cPtr);
static void space(void);
extern sqInt specialSelectorNumArgs(sqInt _index);
extern sqInt specialSelector(sqInt _index);
extern double stackFloatValue(sqInt _offset);
extern sqInt stackIntegerValue(sqInt _offset);
static sqInt stackLimitBytes(void);
static sqInt stackLimitOffset(void);
extern sqInt stackObjectValue(sqInt _offset);
static sqInt stackPageByteSize(void);
static sqInt NoDbgRegParms stackPointerForMaybeMarriedContext(sqInt _aContext);
static sqInt NoDbgRegParms stackPointerIndexForFrame(char *_theFP);
extern usqIntptr_t stackPositiveMachineIntegerValue(sqInt _offset);
extern sqIntptr_t stackSignedMachineIntegerValue(sqInt _offset);
extern sqInt stackTop(void);
extern sqInt stackValue(sqInt _offset);
extern sqInt startPCOfMethodHeader(sqInt _methodHeader);
extern sqInt startPCOfMethod(sqInt _aCompiledMethod);
extern sqInt stObjectat(sqInt _array, sqInt _index);
extern sqInt stObjectatput(sqInt _array, sqInt _index, sqInt _value);
extern sqInt storeIntegerofObjectwithValue(sqInt _fieldIndex, sqInt _objectPointer, sqInt _integerValue);
static char * NoDbgRegParms storeSenderOfFramewithValue(char *_theFP, sqInt _anOop);
extern sqInt stSizeOf(sqInt _oop);
extern sqInt supendActiveProcess(void);
extern sqInt superclassOf(sqInt _classPointer);
static sqInt NoDbgRegParms synchronousSignal(sqInt _aSemaphore);
extern sqInt tempCountOf(sqInt _methodPointer);
extern sqInt temporaryCountOfMethodHeader(sqInt _header);
static void NoDbgRegParms transferTofrom(sqInt _newProc, sqInt _sourceCode);
extern sqInt ultimateLiteralOf(sqInt _aMethodOop);
extern void ultimateLiteralOfput(sqInt _aMethodOop, sqInt _aValue);
static sqInt NoDbgRegParms NeverInline unfollowatIndex(sqInt _litVar, sqInt _literalIndex);
static void NoDbgRegParms updateStateOfSpouseContextForFrameWithSP(char *_theFP, char *_theSP);
static sqInt NoDbgRegParms validBCPCinMethod(sqInt _thePC, usqInt _aMethod);
static sqInt NoDbgRegParms validInstructionPointerinFrame(usqInt _anInstrPointer, char *_fp);
static sqInt validStackPageBaseFrames(void);
static sqInt NoDbgRegParms validStackPageBaseFrame(StackPage *_aPage);
static void NoDbgRegParms NeverInline voidLongRunningPrimitive(char *reason);
static sqInt wakeHighestPriority(void);
static sqInt NoDbgRegParms withSmallIntegerTags(char *_value);
static sqInt NoDbgRegParms cloneContext(sqInt _aContext);
#if FEATURE_FFI
static sqInt doPrimitiveSameThreadCallout(void);
#endif /* FEATURE_FFI */
#if FEATURE_THREADED_FFI
EXPORT(sqInt) doPrimitiveWorkerCallout(void);
#endif /* FEATURE_THREADED_FFI */
#if FEATURE_THREADED_FFI
static sqInt doPrimitiveWorkerExtractReturnValue(void);
#endif /* FEATURE_THREADED_FFI */
extern void * getHandler(sqInt _anOop);
static sqInt NoDbgRegParms isAppropriateForCopyObject(sqInt _oop);
#if FEATURE_FFI
static void NoDbgRegParms marshallAndPushReturnValueFromofTypepoping(sqInt _returnHolder, ffi_type *_ffiType, sqInt _argumentsAndReceiverCount);
#endif /* FEATURE_FFI */
#if FEATURE_FFI
static void NoDbgRegParms marshallArgumentFromatIndexintoofTypewithSize(sqInt _argumentsArrayOop, sqInt _i, sqInt _argHolder, sqInt _argType, sqInt _argTypeSize);
#endif /* FEATURE_FFI */
static sqInt NoDbgRegParms maybeExternalAddressOfstartingAtsize(sqInt _rcvr, sqInt _byteOffset, sqInt _byteSize);
static double NoDbgRegParms NeverInline noInlineLoadFloatOrIntFrom(sqInt _floatOrInt);
static void primitiveClone(void);
static void primitiveContextAt(void);
static void primitiveContextAtPut(void);
static void primitiveContextSize(void);
static void primitiveDoNamedPrimitiveWithArgs(void);
static void primitiveDoPrimitiveWithArgs(void);
static void primitiveExecuteMethod(void);
static void primitiveExecuteMethodArgsArray(void);
static void primitiveExternalCall(void);
EXPORT(void) primitiveFFIAllocate(void);
EXPORT(void) primitiveFFIFree(void);
EXPORT(sqInt) primitiveFFIIntegerAt(void);
EXPORT(sqInt) primitiveFFIIntegerAtPut(void);
static void primitiveFindHandlerContext(void);
static void primitiveFindNextUnwindContext(void);
static void primitiveFullGC(void);
EXPORT(sqInt) primitiveGetCurrentWorkingDirectory(void);
static sqInt NoDbgRegParms primitiveGetVMParameter(sqInt _index);
static void primitiveIncrementalGC(void);
static void primitiveInstVarAt(void);
static void primitiveInstVarAtPut(void);
static void primitiveIsInPermSpace(void);
static void primitiveLoadBoolean8FromBytes(void);
static void primitiveLoadBoolean8FromExternalAddress(void);
static void primitiveLoadChar16FromBytes(void);
static void primitiveLoadChar16FromExternalAddress(void);
static void primitiveLoadChar32FromBytes(void);
static void primitiveLoadChar32FromExternalAddress(void);
static void primitiveLoadChar8FromBytes(void);
static void primitiveLoadChar8FromExternalAddress(void);
static void primitiveLoadFloat32FromBytes(void);
static void primitiveLoadFloat32FromExternalAddress(void);
static void primitiveLoadFloat64FromBytes(void);
static void primitiveLoadFloat64FromExternalAddress(void);
static void primitiveLoadInt16FromBytes(void);
static void primitiveLoadInt16FromExternalAddress(void);
static void primitiveLoadInt32FromBytes(void);
static void primitiveLoadInt32FromExternalAddress(void);
static void primitiveLoadInt64FromBytes(void);
static void primitiveLoadInt64FromExternalAddress(void);
static void primitiveLoadInt8FromBytes(void);
static void primitiveLoadInt8FromExternalAddress(void);
static void primitiveLoadPointerFromBytes(void);
static void primitiveLoadPointerFromExternalAddress(void);
EXPORT(sqInt) primitiveLoadSymbolFromModule(void);
static void primitiveLoadUInt16FromBytes(void);
static void primitiveLoadUInt16FromExternalAddress(void);
static void primitiveLoadUInt32FromBytes(void);
static void primitiveLoadUInt32FromExternalAddress(void);
static void primitiveLoadUInt64FromBytes(void);
static void primitiveLoadUInt64FromExternalAddress(void);
static void primitiveLoadUInt8FromBytes(void);
static void primitiveLoadUInt8FromExternalAddress(void);
EXPORT(sqInt) primitiveLongRunningPrimitive(void);
static void primitiveMoveToPermSpace(void);
static void primitiveMoveToPermSpaceAllOldObjects(void);
static void primitiveMoveToPermSpaceInBulk(void);
static void primitiveObjectPointsTo(void);
static void primitivePerform(void);
static void primitivePin(void);
EXPORT(void) primitiveSameThreadCallout(void);
EXPORT(void) primitiveSetGCSemaphore(void);
static void primitiveSignalAtMilliseconds(void);
static void primitiveSignalAtUTCMicroseconds(void);
static void primitiveSlotAt(void);
static void primitiveSlotAtPut(void);
static void primitiveStoreBoolean8IntoBytes(void);
static void primitiveStoreBoolean8IntoExternalAddress(void);
static void primitiveStoreChar16IntoBytes(void);
static void primitiveStoreChar16IntoExternalAddress(void);
static void primitiveStoreChar32IntoBytes(void);
static void primitiveStoreChar32IntoExternalAddress(void);
static void primitiveStoreChar8IntoBytes(void);
static void primitiveStoreChar8IntoExternalAddress(void);
static void primitiveStoreFloat32IntoBytes(void);
static void primitiveStoreFloat32IntoExternalAddress(void);
static void primitiveStoreFloat64IntoBytes(void);
static void primitiveStoreFloat64IntoExternalAddress(void);
static void primitiveStoreInt16IntoBytes(void);
static void primitiveStoreInt16IntoExternalAddress(void);
static void primitiveStoreInt32IntoBytes(void);
static void primitiveStoreInt32IntoExternalAddress(void);
static void primitiveStoreInt64IntoBytes(void);
static void primitiveStoreInt64IntoExternalAddress(void);
static void primitiveStoreInt8IntoBytes(void);
static void primitiveStoreInt8IntoExternalAddress(void);
static void primitiveStorePointerIntoBytes(void);
static void primitiveStorePointerIntoExternalAddress(void);
static void primitiveStoreStackp(void);
static void primitiveStoreUInt16IntoBytes(void);
static void primitiveStoreUInt16IntoExternalAddress(void);
static void primitiveStoreUInt32IntoBytes(void);
static void primitiveStoreUInt32IntoExternalAddress(void);
static void primitiveStoreUInt64IntoBytes(void);
static void primitiveStoreUInt64IntoExternalAddress(void);
static void primitiveStoreUInt8IntoBytes(void);
static void primitiveStoreUInt8IntoExternalAddress(void);
static void primitiveVMParameter(void);
EXPORT(void) primitiveVoidReceiver(void);
EXPORT(void) primitiveWorkerCallout(void);
EXPORT(void) primitiveWorkerExtractReturnValue(void);
extern sqInt ptEnterInterpreterFromCallback(void *_aPointer);
extern sqInt ptExitInterpreterToCallback(void *_aPointer);
extern void * readAddress(sqInt _anOop);
extern sqInt writeAddressto(sqInt _anOop, void *_aValue);
static sqInt hasToUseComposedFormat(void);
extern sqInt readImageNamed(char *_imageName);
static VMMemoryMap * NoDbgRegParms allocateHeap(VMMemoryMap * self_in_allocateHeap);
static VMMemoryMap * NoDbgRegParms allocatePermObjectsSpace(VMMemoryMap * self_in_allocatePermObjectsSpace);
static void NoDbgRegParms allocateStackPages(VMMemoryMap * self_in_allocateStackPages, sqInt _initialStackSize);
static sqInt NoDbgRegParms allocationGranularity(VMMemoryMap * self_in_allocationGranularity);
static VMMemoryMap * NoDbgRegParms calculateMaskToUse(VMMemoryMap * self_in_calculateMaskToUse);
static sqInt NoDbgRegParms ensureAtLeastPermSpaceOf(VMMemoryMap * self_in_ensureAtLeastPermSpaceOf, sqInt _requestedSize);
static sqInt NoDbgRegParms extendPermObjectsSpaceMinimum(VMMemoryMap * self_in_extendPermObjectsSpaceMinimum, sqInt _minimalSize);
extern sqInt fixedPermSpaceStart(VMMemoryMap * self_in_fixedPermSpaceStart);
extern uint64_t getNewSpaceStart(VMMemoryMap * self_in_getNewSpaceStart);
extern uint64_t getOldSpaceStart(VMMemoryMap * self_in_getOldSpaceStart);
extern sqInt isInCodeZone(VMMemoryMap * self_in_isInCodeZone, sqInt _anOop);
extern sqInt isOldObject(VMMemoryMap * self_in_isOldObject, sqInt _anOop);
extern sqInt isPermanentObject(VMMemoryMap * self_in_isPermanentObject, sqInt _anOop);
extern sqInt isYoungObject(VMMemoryMap * self_in_isYoungObject, sqInt _anOop);
static int64_t NoDbgRegParms permSpaceSize(VMMemoryMap * self_in_permSpaceSize);
static sqInt NoDbgRegParms roundToAllocationSize(VMMemoryMap * self_in_roundToAllocationSize, sqInt _anInteger);
extern uint64_t startOfObjectMemory(VMMemoryMap * self_in_startOfObjectMemory);
static sqInt NoDbgRegParms countNotNilObjects(VMRememberedSet * self_in_countNotNilObjects);
static VMRememberedSet * NoDbgRegParms forgetObject(VMRememberedSet * self_in_forgetObject, sqInt _objOop);
static VMRememberedSet * NoDbgRegParms growRememberedSet(VMRememberedSet * self_in_growRememberedSet);
static VMRememberedSet * NoDbgRegParms initializeRememberedSetShouldStartEmpty(VMRememberedSet * self_in_initializeRememberedSetShouldStartEmpty, sqInt _shouldStartEmpty);
static sqInt NoDbgRegParms isInRememberedSet(VMRememberedSet * self_in_isInRememberedSet, sqInt _objOop);
static sqInt NoDbgRegParms objectOop(VMRememberedSet * self_in_objectOop);
static sqInt * NoDbgRegParms rememberedSetArrayPointerFromObject(VMRememberedSet * self_in_rememberedSetArrayPointerFromObject, sqInt _anOop);
extern sqInt rememberWithoutMarkingAsRemembered(VMRememberedSet * self_in_rememberWithoutMarkingAsRemembered, sqInt _objOop);
extern sqInt remember(VMRememberedSet * self_in_remember, sqInt _objOop);
static VMRememberedSet * NoDbgRegParms shrinkRememberedSet(VMRememberedSet * self_in_shrinkRememberedSet);
static sqInt NoDbgRegParms addressIsInPage(StackPage * self_in_addressIsInPage, char *_address);
static sqInt NoDbgRegParms isFree(StackPage * self_in_isFree);
static void NoDbgRegParms freeStackPageNoAssert(StackPage *_aPage);
static sqInt NoDbgRegParms freeStackPage(StackPage *_aPage);
static void NoDbgRegParms markStackPageMostRecentlyUsed(StackPage *_page);
static void NoDbgRegParms markStackPageNextMostRecentlyUsed(StackPage *_page);
static StackPage * newStackPage(void);
static sqInt NoDbgRegParms pageIndexFor(void *_pointer);
static sqInt pageListIsWellFormed(void);
static StackPage * NoDbgRegParms stackPageAt(sqInt _index);
static StackPage * NoDbgRegParms stackPageFor(void *_pointer);
static double statAverageLivePagesWhenMapping0(void);

/*** Variables ***/
#if SQ_USE_GLOBAL_STRUCT
# define _iss /* define in-struct static as void */
static struct foo {
#else
# define _iss static
#endif
_iss char * stackPointer;
_iss sqInt primFailCode;
_iss VMMemoryMap * memoryMap;
_iss sqInt nilObj;
_iss char * framePointer;
_iss StackPage * stackPage;
_iss sqInt argumentCount;
_iss sqInt specialObjectsOop;
_iss usqInt freeStart;
_iss usqInt newMethod;
_iss char * instructionPointer;
_iss sqInt trueObj;
_iss usqInt method;
_iss StackPage * pages;
_iss VMRememberedSet * fromOldSpaceRememberedSet;
_iss sqInt messageSelector;
_iss char * stackBasePlus1;
_iss sqInt permSpaceFreeStart;
_iss sqInt hiddenRootsObj;
_iss SpurSegmentInfo * segments;
_iss usqInt totalFreeOldSpace;
_iss sqInt falseObj;
_iss usqInt pastSpaceStart;
_iss sqInt bytesPerPage;
_iss sqInt numSegments;
_iss SpurContiguousObjStack * permSpaceForwardersToCleanUp;
_iss sqInt needGCFlag;
_iss unsigned char primTraceLogIndex;
_iss sqInt * freeLists;
_iss usqInt scavengeThreshold;
_iss sqInt traceLogIndex;
_iss sqInt classTableFirstPage;
_iss SpurContiguousObjStack * unscannedEphemerons;
_iss sqInt markStack;
_iss SpurContiguousObjStack savedFirstFieldsSpace;
_iss sqInt weaklingStack;
_iss char * stackLimit;
_iss usqInt firstFreeObject;
_iss usqInt freeListsMask;
_iss StackPage * mostRecentlyUsedPage;
_iss sqInt becomeEffectsFlags;
_iss usqInt lastMobileObject;
_iss sqLong nextProfileTick;
_iss SpurScavengeLogRecord scavengeLogRecord;
_iss sqInt tempOop;
_iss sqInt lkupClass;
_iss sqInt numStackPages;
_iss SpurNewSpaceSpace pastSpace;
_iss sqInt mobileStart;
_iss sqInt mournQueue;
_iss sqInt numClassTablePages;
_iss sqInt profileProcess;
_iss SpurNewSpaceSpace futureSpace;
_iss sqInt futureSurvivorStart;
_iss sqInt profileMethod;
_iss sqInt profileSemaphore;
_iss VMRememberedSet * fromPermToNewSpaceRememberedSet;
_iss sqInt longRunningPrimitiveCheckSemaphore;
_iss sqInt tenureThreshold;
_iss sqInt classTableIndex;
_iss VMRememberedSet * fromPermToOldSpaceRememberedSet;
_iss SpurNewSpaceSpace eden;
_iss char * objStackInvalidBecause;
_iss sqInt sweepIndex;
_iss sqInt ephemeronList;
_iss sqInt longRunningPrimitiveCheckMethod;
_iss sqInt tenureCriterion;
_iss usqInt totalHeapSizeIncludingBridges;
_iss sqInt tempOop2;
_iss sqInt classNameIndex;
_iss sqInt firstFieldOfPermToNewRememberedSet;
_iss sqInt firstFieldOfPermToOldRememberedSet;
_iss usqInt freeOldSpaceStart;
_iss sqInt gcPhaseInProgress;
_iss sqInt growHeadroom;
_iss sqInt invalidObjStackPage;
_iss usqInt objectAfterLastMobileObject;
_iss sqInt maxSlotsForNewSpaceAlloc;
_iss sqInt pendingFinalizationSignals;
_iss sqInt remapBufferCount;
_iss sqInt metaAccessorDepth;
_iss sqInt metaclassNumSlots;
_iss sqInt numSegInfos;
_iss sqInt printedStackFrames;
_iss sqInt savedFirstFieldsSpaceNotInOldSpace;
_iss sqInt extraRootCount;
_iss usqInt firstMobileObject;
_iss sqInt gcMode;
_iss sqInt lastMethodCacheProbeWrite;
_iss sqInt savedFirstFieldSpaceMaxSlots;
_iss sqInt cogCompiledCodeCompactionCalledFor;
_iss sqInt highestRunnableProcessPriority;
_iss sqInt lastCoggableInterpretedBlockMethod;
_iss sqInt lastUncoggableInterpretedBlockMethod;
_iss sqInt maxStackMessagePrinted;
_iss usqLong nextWakeupUsecs;
_iss sqInt preemptionYields;
_iss sqInt thisClassIndex;
_iss sqInt desiredStackPageBytes;
_iss usqLong longRunningPrimitiveStartUsecs;
_iss usqLong longRunningPrimitiveStopUsecs;
_iss usqLong statGCEndUsecs;
_iss sqInt weakList;
_iss sqInt firstFieldOfRememberedSet;
_iss sqInt formatToUse;
_iss usqLong gcStartUsecs;
_iss sqInt marking;
_iss sqLong oldSpaceUsePriorToScavenge;
_iss usqLong statCheckForEvents;
_iss sqInt statTenures;
_iss sqInt avoidSearchingSegmentsWithPinnedObjects;
_iss sqInt bogon;
_iss sqInt cogCodeSize;
_iss sqInt externalPrimitiveTableFirstFreeIndex;
_iss sqInt flagInterpretedMethods;
_iss sqInt lastHash;
_iss usqInt lowSpaceThreshold;
_iss FILE * scavengeLog;
_iss sqInt statSurvivorCount;
_iss sqInt biasForGC;
_iss sqInt globalSessionID;
_iss sqInt imageVersionNumber;
_iss sqInt maxStacksToPrint;
_iss sqInt shrinkThreshold;
_iss usqLong statAllocatedBytes;
_iss sqInt statMaxAllocSegmentTime;
_iss sqInt statNumMaps;
_iss sqInt statScavenges;
_iss sqInt anomaly;
_iss sqInt canSwizzle;
_iss float heapGrowthToSizeGCRatio;
_iss usqInt heapSizeAtPreviousGC;
_iss sqInt imageHeaderFlags;
_iss sqInt longRunningPrimitiveCheckSequenceNumber;
_iss sqInt methodDictLinearSearchLimit;
_iss sqInt statFullGCs;
_iss sqInt statMaxPageCountWhenMapping;
_iss sqInt statPageCountWhenMappingSum;
_iss double tenuringProportion;
_iss char * breakSelector;
_iss sqInt classByteArrayCompactIndex;
_iss sqInt deferSmash;
_iss sqInt deferredSmash;
_iss sqInt extraFramesToMoveOnOverflow;
_iss sqInt imageFloatsBigEndian;
_iss sqInt jmpDepth;
_iss sqInt longRunningPrimitiveSignalUndelivered;
_iss sqInt maxExtSemTabSizeSet;
_iss sqLong osErrorCode;
_iss sqInt refCountToShrinkRT;
_iss sqInt signalLowSpace;
_iss sqInt statCodeCompactionCount;
_iss usqLong statCodeCompactionUsecs;
_iss usqLong statCompactionUsecs;
_iss usqLong statForceInterruptCheck;
_iss usqLong statFullGCUsecs;
_iss sqInt statGrowMemory;
_iss usqLong statIdleUsecs;
_iss usqLong statMarkUsecs;
_iss usqLong statProcessSwitch;
_iss usqLong statSGCDeltaUsecs;
_iss usqLong statScavengeGCUsecs;
_iss sqInt statShrinkMemory;
_iss usqLong statStackOverflow;
_iss usqLong statStackPageDivorce;
_iss usqLong statSweepUsecs;
_iss sqInt edenBytes;
_iss sqInt gcSemaphoreIndex;
_iss usqLong gcSweepEndUsecs;
_iss usqLong longRunningPrimitiveGCUsecs;
_iss sqInt overflowLimit;
_iss StackPage * overflowedPage;
_iss sqInt statMarkCount;
_iss sqInt statRootTableCount;
_iss sqInt tenuringClassIndex;
_iss usqInt exceptionPC;
_iss sqInt statCompactPassCount;
_iss usqLong statIGCDeltaUsecs;
_iss sqInt statRootTableOverflows;
_iss sqIntptr_t methodCache[MethodCacheSize + 1 /* 4097 */];
_iss sqInt traceLog[TraceBufferSize /* 768 */];
_iss sqInt primTraceLog[256];
_iss sqInt *extraRoots[ExtraRootsSize + 1 /* 2049 */];
_iss sqInt remapBuffer[RemapBufferSize + 1 /* 26 */];
_iss usqInt suspendedCallbacks[MaxJumpBuf + 1 /* 33 */];
_iss usqInt suspendedMethods[MaxJumpBuf + 1 /* 33 */];
#undef _iss
#if SQ_USE_GLOBAL_STRUCT
 } fum;
 #if SQ_USE_GLOBAL_STRUCT_REG
# define DECL_MAYBE_SQ_GLOBAL_STRUCT /* using a global reg pointer */
# define DECL_MAYBE_VOLATILE_SQ_GLOBAL_STRUCT /* using a global reg pointer */
#else
# define DECL_MAYBE_SQ_GLOBAL_STRUCT register struct foo * foo = &fum;
# define DECL_MAYBE_VOLATILE_SQ_GLOBAL_STRUCT volatile register struct foo * foo = &fum;
#endif
# define GIV(interpreterInstVar) (foo->interpreterInstVar)
#else
# define DECL_MAYBE_SQ_GLOBAL_STRUCT /* oh, no mr bill! */
# define DECL_MAYBE_VOLATILE_SQ_GLOBAL_STRUCT /* oh no, mr bill! */
# define GIV(interpreterInstVar) interpreterInstVar
#endif
#if SQ_USE_GLOBAL_STRUCT
#if SQ_USE_GLOBAL_STRUCT_REG
#define fooxstr(s) foostr(s)
#define foostr(s)  #s
register struct foo * foo asm(fooxstr(USE_GLOBAL_STRUCT_REG));
#else
static struct foo * foo = &fum;
#endif
#endif
static void (*primitiveFunctionPointer)();
sqInt maxLiteralCountForCompile = MaxLiteralCountForCompile /* 60 */;
sqInt checkForLeaks;
sqInt checkAllocFiller;
jmp_buf reenterInterpreter; /* private export */;
sqInt desiredEdenBytes;
sqInt extraVMMemory;
sqInt desiredNumStackPages;
usqInt maxOldSpaceSize;
static sqInt breakSelectorLength = MinSmallInteger;
sqInt desiredCogCodeSize;
sqInt suppressHeartbeatFlag;
sqInt minBackwardJumpCountForCompile = MinBackwardJumpCountForCompile /* 40 */;
sqInt checkedPluginName;
static void (*primitiveTable[MaxPrimitiveIndex + 2 /* 662 */])(void) = {
	/* 0 */ (void (*)(void))0,
	/* 1 */ primitiveAdd,
	/* 2 */ primitiveSubtract,
	/* 3 */ primitiveLessThan,
	/* 4 */ primitiveGreaterThan,
	/* 5 */ primitiveLessOrEqual,
	/* 6 */ primitiveGreaterOrEqual,
	/* 7 */ primitiveEqual,
	/* 8 */ primitiveNotEqual,
	/* 9 */ primitiveMultiply,
	/* 10 */ primitiveDivide,
	/* 11 */ primitiveMod,
	/* 12 */ primitiveDiv,
	/* 13 */ primitiveQuo,
	/* 14 */ primitiveBitAnd,
	/* 15 */ primitiveBitOr,
	/* 16 */ primitiveBitXor,
	/* 17 */ primitiveBitShift,
	/* 18 */ primitiveMakePoint,
	/* 19 */ (void (*)(void))0,
	/* 20 */ primitiveRemLargeIntegers,
	/* 21 */ primitiveAddLargeIntegers,
	/* 22 */ primitiveSubtractLargeIntegers,
	/* 23 */ primitiveLessThanLargeIntegers,
	/* 24 */ primitiveGreaterThanLargeIntegers,
	/* 25 */ primitiveLessOrEqualLargeIntegers,
	/* 26 */ primitiveGreaterOrEqualLargeIntegers,
	/* 27 */ primitiveEqualLargeIntegers,
	/* 28 */ primitiveNotEqualLargeIntegers,
	/* 29 */ primitiveMultiplyLargeIntegers,
	/* 30 */ primitiveDivideLargeIntegers,
	/* 31 */ primitiveModLargeIntegers,
	/* 32 */ primitiveDivLargeIntegers,
	/* 33 */ primitiveQuoLargeIntegers,
	/* 34 */ primitiveBitAndLargeIntegers,
	/* 35 */ primitiveBitOrLargeIntegers,
	/* 36 */ primitiveBitXorLargeIntegers,
	/* 37 */ primitiveBitShiftLargeIntegers,
	/* 38 */ primitiveFloatAt,
	/* 39 */ primitiveFloatAtPut,
	/* 40 */ primitiveAsFloat,
	/* 41 */ primitiveFloatAdd,
	/* 42 */ primitiveFloatSubtract,
	/* 43 */ primitiveFloatLessThan,
	/* 44 */ primitiveFloatGreaterThan,
	/* 45 */ primitiveFloatLessOrEqual,
	/* 46 */ primitiveFloatGreaterOrEqual,
	/* 47 */ primitiveFloatEqual,
	/* 48 */ primitiveFloatNotEqual,
	/* 49 */ primitiveFloatMultiply,
	/* 50 */ primitiveFloatDivide,
	/* 51 */ primitiveTruncated,
	/* 52 */ primitiveFractionalPart,
	/* 53 */ primitiveExponent,
	/* 54 */ primitiveTimesTwoPower,
	/* 55 */ primitiveSquareRoot,
	/* 56 */ primitiveSine,
	/* 57 */ primitiveArctan,
	/* 58 */ primitiveLogN,
	/* 59 */ primitiveExp,
	/* 60 */ primitiveAt,
	/* 61 */ primitiveAtPut,
	/* 62 */ primitiveSize,
	/* 63 */ primitiveStringAt,
	/* 64 */ primitiveStringAtPut,
	/* 65 */ (void (*)(void))0,
	/* 66 */ (void (*)(void))0,
	/* 67 */ (void (*)(void))0,
	/* 68 */ primitiveObjectAt,
	/* 69 */ primitiveObjectAtPut,
	/* 70 */ primitiveNew,
	/* 71 */ primitiveNewWithArg,
	/* 72 */ primitiveArrayBecomeOneWay,
	/* 73 */ primitiveInstVarAt,
	/* 74 */ primitiveInstVarAtPut,
	/* 75 */ primitiveIdentityHash,
	/* 76 */ primitiveStoreStackp,
	/* 77 */ primitiveSomeInstance,
	/* 78 */ primitiveNextInstance,
	/* 79 */ primitiveNewMethod,
	/* 80 */ (void (*)(void))0,
	/* 81 */ (void (*)(void))0,
	/* 82 */ (void (*)(void))0,
	/* 83 */ primitivePerform,
	/* 84 */ primitivePerformWithArgs,
	/* 85 */ primitiveSignal,
	/* 86 */ primitiveWait,
	/* 87 */ primitiveResume,
	/* 88 */ primitiveSuspend,
	/* 89 */ primitiveFlushCache,
	/* 90 */ primitiveMoveToPermSpace,
	/* 91 */ primitiveMoveToPermSpaceInBulk,
	/* 92 */ primitiveIsInPermSpace,
	/* 93 */ primitiveMoveToPermSpaceAllOldObjects,
	/* 94 */ (void (*)(void))0,
	/* 95 */ (void (*)(void))0,
	/* 96 */ (void (*)(void))0,
	/* 97 */ primitiveSnapshot,
	/* 98 */ (void (*)(void))0,
	/* 99 */ (void (*)(void))0,
	/* 100 */ primitivePerformInSuperclass,
	/* 101 */ (void (*)(void))0,
	/* 102 */ (void (*)(void))0,
	/* 103 */ (void (*)(void))0,
	/* 104 */ (void (*)(void))0,
	/* 105 */ primitiveStringReplace,
	/* 106 */ (void (*)(void))0,
	/* 107 */ (void (*)(void))0,
	/* 108 */ (void (*)(void))0,
	/* 109 */ (void (*)(void))0,
	/* 110 */ primitiveIdentical,
	/* 111 */ primitiveClass,
	/* 112 */ primitiveBytesLeft,
	/* 113 */ primitiveQuit,
	/* 114 */ (void (*)(void))0,
	/* 115 */ primitiveChangeClass,
	/* 116 */ primitiveFlushCacheByMethod,
	/* 117 */ primitiveExternalCall,
	/* 118 */ primitiveDoPrimitiveWithArgs,
	/* 119 */ primitiveFlushCacheBySelector,
	/* 120 */ primitiveCalloutToFFI,
	/* 121 */ primitiveImageName,
	/* 122 */ (void (*)(void))0,
	/* 123 */ (void (*)(void))0,
	/* 124 */ primitiveLowSpaceSemaphore,
	/* 125 */ primitiveSignalAtBytesLeft,
	/* 126 */ (void (*)(void))0,
	/* 127 */ (void (*)(void))0,
	/* 128 */ primitiveArrayBecome,
	/* 129 */ primitiveSpecialObjectsOop,
	/* 130 */ primitiveFullGC,
	/* 131 */ primitiveIncrementalGC,
	/* 132 */ primitiveObjectPointsTo,
	/* 133 */ (void (*)(void))0,
	/* 134 */ (void (*)(void))0,
	/* 135 */ primitiveMillisecondClock,
	/* 136 */ primitiveSignalAtMilliseconds,
	/* 137 */ primitiveSecondsClock,
	/* 138 */ primitiveSomeObject,
	/* 139 */ primitiveNextObject,
	/* 140 */ (void (*)(void))0,
	/* 141 */ (void (*)(void))0,
	/* 142 */ primitiveVMPath,
	/* 143 */ primitiveShortAt,
	/* 144 */ primitiveShortAtPut,
	/* 145 */ primitiveConstantFill,
	/* 146 */ (void (*)(void))0,
	/* 147 */ (void (*)(void))0,
	/* 148 */ primitiveClone,
	/* 149 */ primitiveGetAttribute,
	/* 150 */ (void (*)(void))0,
	/* 151 */ (void (*)(void))0,
	/* 152 */ (void (*)(void))0,
	/* 153 */ (void (*)(void))0,
	/* 154 */ (void (*)(void))0,
	/* 155 */ (void (*)(void))0,
	/* 156 */ (void (*)(void))0,
	/* 157 */ (void (*)(void))0,
	/* 158 */ primitiveStringCompareWith,
	/* 159 */ primitiveHashMultiply,
	/* 160 */ primitiveAdoptInstance,
	/* 161 */ primitiveSetOrHasIdentityHash,
	/* 162 */ (void (*)(void))0,
	/* 163 */ primitiveGetImmutability,
	/* 164 */ primitiveSetImmutability,
	/* 165 */ primitiveIntegerAt,
	/* 166 */ primitiveIntegerAtPut,
	/* 167 */ primitiveYield,
	/* 168 */ primitiveCopyObject,
	/* 169 */ primitiveNotIdentical,
	/* 170 */ primitiveAsCharacter,
	/* 171 */ primitiveImmediateAsInteger,
	/* 172 */ primitiveFetchNextMourner,
	/* 173 */ primitiveSlotAt,
	/* 174 */ primitiveSlotAtPut,
	/* 175 */ primitiveBehaviorHash,
	/* 176 */ primitiveMaxIdentityHash,
	/* 177 */ primitiveAllInstances,
	/* 178 */ primitiveAllObjects,
	/* 179 */ (void (*)(void))0,
	/* 180 */ primitiveGrowMemoryByAtLeast,
	/* 181 */ primitiveSizeInBytesOfInstance,
	/* 182 */ primitiveSizeInBytes,
	/* 183 */ primitiveIsPinned,
	/* 184 */ primitivePin,
	/* 185 */ primitiveExitCriticalSection,
	/* 186 */ primitiveEnterCriticalSection,
	/* 187 */ primitiveTestAndSetOwnershipOfCriticalSection,
	/* 188 */ primitiveExecuteMethodArgsArray,
	/* 189 */ primitiveExecuteMethod,
	/* 190 */ (void (*)(void))0,
	/* 191 */ (void (*)(void))0,
	/* 192 */ (void (*)(void))0,
	/* 193 */ (void (*)(void))0,
	/* 194 */ (void (*)(void))0,
	/* 195 */ primitiveFindNextUnwindContext,
	/* 196 */ primitiveTerminateTo,
	/* 197 */ primitiveFindHandlerContext,
	/* 198 */ (void (*)(void))0,
	/* 199 */ (void (*)(void))0,
	/* 200 */ (void (*)(void))0,
	/* 201 */ (void (*)(void))0,
	/* 202 */ (void (*)(void))0,
	/* 203 */ (void (*)(void))0,
	/* 204 */ (void (*)(void))0,
	/* 205 */ (void (*)(void))0,
	/* 206 */ (void (*)(void))0,
	/* 207 */ primitiveFullClosureValue,
	/* 208 */ primitiveFullClosureValueWithArgs,
	/* 209 */ primitiveFullClosureValueNoContextSwitch,
	/* 210 */ primitiveContextAt,
	/* 211 */ primitiveContextAtPut,
	/* 212 */ primitiveContextSize,
	/* 213 */ primitiveContextXray,
	/* 214 */ primitiveVoidVMState,
	/* 215 */ primitiveVoidVMStateForMethod,
	/* 216 */ primitiveMethodXray,
	/* 217 */ primitiveMethodProfilingData,
	/* 218 */ primitiveDoNamedPrimitiveWithArgs,
	/* 219 */ (void (*)(void))0,
	/* 220 */ (void (*)(void))0,
	/* 221 */ (void (*)(void))0,
	/* 222 */ (void (*)(void))0,
	/* 223 */ (void (*)(void))0,
	/* 224 */ (void (*)(void))0,
	/* 225 */ (void (*)(void))0,
	/* 226 */ (void (*)(void))0,
	/* 227 */ (void (*)(void))0,
	/* 228 */ (void (*)(void))0,
	/* 229 */ (void (*)(void))0,
	/* 230 */ primitiveRelinquishProcessor,
	/* 231 */ (void (*)(void))0,
	/* 232 */ (void (*)(void))0,
	/* 233 */ (void (*)(void))0,
	/* 234 */ (void (*)(void))0,
	/* 235 */ (void (*)(void))0,
	/* 236 */ (void (*)(void))0,
	/* 237 */ (void (*)(void))0,
	/* 238 */ (void (*)(void))0,
	/* 239 */ (void (*)(void))0,
	/* 240 */ primitiveUTCMicrosecondClock,
	/* 241 */ primitiveLocalMicrosecondClock,
	/* 242 */ primitiveSignalAtUTCMicroseconds,
	/* 243 */ primitiveUpdateTimezone,
	/* 244 */ primitiveUtcAndTimezoneOffset,
	/* 245 */ primitiveCoarseUTCMicrosecondClock,
	/* 246 */ primitiveCoarseLocalMicrosecondClock,
	/* 247 */ (void (*)(void))0,
	/* 248 */ primitiveArrayBecomeOneWayNoCopyHash,
	/* 249 */ primitiveArrayBecomeOneWayCopyHash,
	/* 250 */ (void (*)(void))0,
	/* 251 */ (void (*)(void))0,
	/* 252 */ (void (*)(void))0,
	/* 253 */ primitiveCollectCogCodeConstituents,
	/* 254 */ primitiveVMParameter,
	/* 255 */ (void (*)(void))0,
	/* 256 */ (void (*)(void))256,
	/* 257 */ (void (*)(void))257,
	/* 258 */ (void (*)(void))258,
	/* 259 */ (void (*)(void))259,
	/* 260 */ (void (*)(void))260,
	/* 261 */ (void (*)(void))261,
	/* 262 */ (void (*)(void))262,
	/* 263 */ (void (*)(void))263,
	/* 264 */ (void (*)(void))264,
	/* 265 */ (void (*)(void))265,
	/* 266 */ (void (*)(void))266,
	/* 267 */ (void (*)(void))267,
	/* 268 */ (void (*)(void))268,
	/* 269 */ (void (*)(void))269,
	/* 270 */ (void (*)(void))270,
	/* 271 */ (void (*)(void))271,
	/* 272 */ (void (*)(void))272,
	/* 273 */ (void (*)(void))273,
	/* 274 */ (void (*)(void))274,
	/* 275 */ (void (*)(void))275,
	/* 276 */ (void (*)(void))276,
	/* 277 */ (void (*)(void))277,
	/* 278 */ (void (*)(void))278,
	/* 279 */ (void (*)(void))279,
	/* 280 */ (void (*)(void))280,
	/* 281 */ (void (*)(void))281,
	/* 282 */ (void (*)(void))282,
	/* 283 */ (void (*)(void))283,
	/* 284 */ (void (*)(void))284,
	/* 285 */ (void (*)(void))285,
	/* 286 */ (void (*)(void))286,
	/* 287 */ (void (*)(void))287,
	/* 288 */ (void (*)(void))288,
	/* 289 */ (void (*)(void))289,
	/* 290 */ (void (*)(void))290,
	/* 291 */ (void (*)(void))291,
	/* 292 */ (void (*)(void))292,
	/* 293 */ (void (*)(void))293,
	/* 294 */ (void (*)(void))294,
	/* 295 */ (void (*)(void))295,
	/* 296 */ (void (*)(void))296,
	/* 297 */ (void (*)(void))297,
	/* 298 */ (void (*)(void))298,
	/* 299 */ (void (*)(void))299,
	/* 300 */ (void (*)(void))300,
	/* 301 */ (void (*)(void))301,
	/* 302 */ (void (*)(void))302,
	/* 303 */ (void (*)(void))303,
	/* 304 */ (void (*)(void))304,
	/* 305 */ (void (*)(void))305,
	/* 306 */ (void (*)(void))306,
	/* 307 */ (void (*)(void))307,
	/* 308 */ (void (*)(void))308,
	/* 309 */ (void (*)(void))309,
	/* 310 */ (void (*)(void))310,
	/* 311 */ (void (*)(void))311,
	/* 312 */ (void (*)(void))312,
	/* 313 */ (void (*)(void))313,
	/* 314 */ (void (*)(void))314,
	/* 315 */ (void (*)(void))315,
	/* 316 */ (void (*)(void))316,
	/* 317 */ (void (*)(void))317,
	/* 318 */ (void (*)(void))318,
	/* 319 */ (void (*)(void))319,
	/* 320 */ (void (*)(void))320,
	/* 321 */ (void (*)(void))321,
	/* 322 */ (void (*)(void))322,
	/* 323 */ (void (*)(void))323,
	/* 324 */ (void (*)(void))324,
	/* 325 */ (void (*)(void))325,
	/* 326 */ (void (*)(void))326,
	/* 327 */ (void (*)(void))327,
	/* 328 */ (void (*)(void))328,
	/* 329 */ (void (*)(void))329,
	/* 330 */ (void (*)(void))330,
	/* 331 */ (void (*)(void))331,
	/* 332 */ (void (*)(void))332,
	/* 333 */ (void (*)(void))333,
	/* 334 */ (void (*)(void))334,
	/* 335 */ (void (*)(void))335,
	/* 336 */ (void (*)(void))336,
	/* 337 */ (void (*)(void))337,
	/* 338 */ (void (*)(void))338,
	/* 339 */ (void (*)(void))339,
	/* 340 */ (void (*)(void))340,
	/* 341 */ (void (*)(void))341,
	/* 342 */ (void (*)(void))342,
	/* 343 */ (void (*)(void))343,
	/* 344 */ (void (*)(void))344,
	/* 345 */ (void (*)(void))345,
	/* 346 */ (void (*)(void))346,
	/* 347 */ (void (*)(void))347,
	/* 348 */ (void (*)(void))348,
	/* 349 */ (void (*)(void))349,
	/* 350 */ (void (*)(void))350,
	/* 351 */ (void (*)(void))351,
	/* 352 */ (void (*)(void))352,
	/* 353 */ (void (*)(void))353,
	/* 354 */ (void (*)(void))354,
	/* 355 */ (void (*)(void))355,
	/* 356 */ (void (*)(void))356,
	/* 357 */ (void (*)(void))357,
	/* 358 */ (void (*)(void))358,
	/* 359 */ (void (*)(void))359,
	/* 360 */ (void (*)(void))360,
	/* 361 */ (void (*)(void))361,
	/* 362 */ (void (*)(void))362,
	/* 363 */ (void (*)(void))363,
	/* 364 */ (void (*)(void))364,
	/* 365 */ (void (*)(void))365,
	/* 366 */ (void (*)(void))366,
	/* 367 */ (void (*)(void))367,
	/* 368 */ (void (*)(void))368,
	/* 369 */ (void (*)(void))369,
	/* 370 */ (void (*)(void))370,
	/* 371 */ (void (*)(void))371,
	/* 372 */ (void (*)(void))372,
	/* 373 */ (void (*)(void))373,
	/* 374 */ (void (*)(void))374,
	/* 375 */ (void (*)(void))375,
	/* 376 */ (void (*)(void))376,
	/* 377 */ (void (*)(void))377,
	/* 378 */ (void (*)(void))378,
	/* 379 */ (void (*)(void))379,
	/* 380 */ (void (*)(void))380,
	/* 381 */ (void (*)(void))381,
	/* 382 */ (void (*)(void))382,
	/* 383 */ (void (*)(void))383,
	/* 384 */ (void (*)(void))384,
	/* 385 */ (void (*)(void))385,
	/* 386 */ (void (*)(void))386,
	/* 387 */ (void (*)(void))387,
	/* 388 */ (void (*)(void))388,
	/* 389 */ (void (*)(void))389,
	/* 390 */ (void (*)(void))390,
	/* 391 */ (void (*)(void))391,
	/* 392 */ (void (*)(void))392,
	/* 393 */ (void (*)(void))393,
	/* 394 */ (void (*)(void))394,
	/* 395 */ (void (*)(void))395,
	/* 396 */ (void (*)(void))396,
	/* 397 */ (void (*)(void))397,
	/* 398 */ (void (*)(void))398,
	/* 399 */ (void (*)(void))399,
	/* 400 */ (void (*)(void))400,
	/* 401 */ (void (*)(void))401,
	/* 402 */ (void (*)(void))402,
	/* 403 */ (void (*)(void))403,
	/* 404 */ (void (*)(void))404,
	/* 405 */ (void (*)(void))405,
	/* 406 */ (void (*)(void))406,
	/* 407 */ (void (*)(void))407,
	/* 408 */ (void (*)(void))408,
	/* 409 */ (void (*)(void))409,
	/* 410 */ (void (*)(void))410,
	/* 411 */ (void (*)(void))411,
	/* 412 */ (void (*)(void))412,
	/* 413 */ (void (*)(void))413,
	/* 414 */ (void (*)(void))414,
	/* 415 */ (void (*)(void))415,
	/* 416 */ (void (*)(void))416,
	/* 417 */ (void (*)(void))417,
	/* 418 */ (void (*)(void))418,
	/* 419 */ (void (*)(void))419,
	/* 420 */ (void (*)(void))420,
	/* 421 */ (void (*)(void))421,
	/* 422 */ (void (*)(void))422,
	/* 423 */ (void (*)(void))423,
	/* 424 */ (void (*)(void))424,
	/* 425 */ (void (*)(void))425,
	/* 426 */ (void (*)(void))426,
	/* 427 */ (void (*)(void))427,
	/* 428 */ (void (*)(void))428,
	/* 429 */ (void (*)(void))429,
	/* 430 */ (void (*)(void))430,
	/* 431 */ (void (*)(void))431,
	/* 432 */ (void (*)(void))432,
	/* 433 */ (void (*)(void))433,
	/* 434 */ (void (*)(void))434,
	/* 435 */ (void (*)(void))435,
	/* 436 */ (void (*)(void))436,
	/* 437 */ (void (*)(void))437,
	/* 438 */ (void (*)(void))438,
	/* 439 */ (void (*)(void))439,
	/* 440 */ (void (*)(void))440,
	/* 441 */ (void (*)(void))441,
	/* 442 */ (void (*)(void))442,
	/* 443 */ (void (*)(void))443,
	/* 444 */ (void (*)(void))444,
	/* 445 */ (void (*)(void))445,
	/* 446 */ (void (*)(void))446,
	/* 447 */ (void (*)(void))447,
	/* 448 */ (void (*)(void))448,
	/* 449 */ (void (*)(void))449,
	/* 450 */ (void (*)(void))450,
	/* 451 */ (void (*)(void))451,
	/* 452 */ (void (*)(void))452,
	/* 453 */ (void (*)(void))453,
	/* 454 */ (void (*)(void))454,
	/* 455 */ (void (*)(void))455,
	/* 456 */ (void (*)(void))456,
	/* 457 */ (void (*)(void))457,
	/* 458 */ (void (*)(void))458,
	/* 459 */ (void (*)(void))459,
	/* 460 */ (void (*)(void))460,
	/* 461 */ (void (*)(void))461,
	/* 462 */ (void (*)(void))462,
	/* 463 */ (void (*)(void))463,
	/* 464 */ (void (*)(void))464,
	/* 465 */ (void (*)(void))465,
	/* 466 */ (void (*)(void))466,
	/* 467 */ (void (*)(void))467,
	/* 468 */ (void (*)(void))468,
	/* 469 */ (void (*)(void))469,
	/* 470 */ (void (*)(void))470,
	/* 471 */ (void (*)(void))471,
	/* 472 */ (void (*)(void))472,
	/* 473 */ (void (*)(void))473,
	/* 474 */ (void (*)(void))474,
	/* 475 */ (void (*)(void))475,
	/* 476 */ (void (*)(void))476,
	/* 477 */ (void (*)(void))477,
	/* 478 */ (void (*)(void))478,
	/* 479 */ (void (*)(void))479,
	/* 480 */ (void (*)(void))480,
	/* 481 */ (void (*)(void))481,
	/* 482 */ (void (*)(void))482,
	/* 483 */ (void (*)(void))483,
	/* 484 */ (void (*)(void))484,
	/* 485 */ (void (*)(void))485,
	/* 486 */ (void (*)(void))486,
	/* 487 */ (void (*)(void))487,
	/* 488 */ (void (*)(void))488,
	/* 489 */ (void (*)(void))489,
	/* 490 */ (void (*)(void))490,
	/* 491 */ (void (*)(void))491,
	/* 492 */ (void (*)(void))492,
	/* 493 */ (void (*)(void))493,
	/* 494 */ (void (*)(void))494,
	/* 495 */ (void (*)(void))495,
	/* 496 */ (void (*)(void))496,
	/* 497 */ (void (*)(void))497,
	/* 498 */ (void (*)(void))498,
	/* 499 */ (void (*)(void))499,
	/* 500 */ (void (*)(void))500,
	/* 501 */ (void (*)(void))501,
	/* 502 */ (void (*)(void))502,
	/* 503 */ (void (*)(void))503,
	/* 504 */ (void (*)(void))504,
	/* 505 */ (void (*)(void))505,
	/* 506 */ (void (*)(void))506,
	/* 507 */ (void (*)(void))507,
	/* 508 */ (void (*)(void))508,
	/* 509 */ (void (*)(void))509,
	/* 510 */ (void (*)(void))510,
	/* 511 */ (void (*)(void))511,
	/* 512 */ (void (*)(void))512,
	/* 513 */ (void (*)(void))513,
	/* 514 */ (void (*)(void))514,
	/* 515 */ (void (*)(void))515,
	/* 516 */ (void (*)(void))516,
	/* 517 */ (void (*)(void))517,
	/* 518 */ (void (*)(void))518,
	/* 519 */ (void (*)(void))519,
	/* 520 */ (void (*)(void))0,
	/* 521 */ (void (*)(void))0,
	/* 522 */ (void (*)(void))0,
	/* 523 */ (void (*)(void))0,
	/* 524 */ (void (*)(void))0,
	/* 525 */ (void (*)(void))0,
	/* 526 */ (void (*)(void))0,
	/* 527 */ (void (*)(void))0,
	/* 528 */ (void (*)(void))0,
	/* 529 */ (void (*)(void))0,
	/* 530 */ (void (*)(void))0,
	/* 531 */ (void (*)(void))0,
	/* 532 */ (void (*)(void))0,
	/* 533 */ (void (*)(void))0,
	/* 534 */ (void (*)(void))0,
	/* 535 */ (void (*)(void))0,
	/* 536 */ (void (*)(void))0,
	/* 537 */ (void (*)(void))0,
	/* 538 */ (void (*)(void))0,
	/* 539 */ (void (*)(void))0,
	/* 540 */ (void (*)(void))0,
	/* 541 */ primitiveSmallFloatAdd,
	/* 542 */ primitiveSmallFloatSubtract,
	/* 543 */ primitiveSmallFloatLessThan,
	/* 544 */ primitiveSmallFloatGreaterThan,
	/* 545 */ primitiveSmallFloatLessOrEqual,
	/* 546 */ primitiveSmallFloatGreaterOrEqual,
	/* 547 */ primitiveSmallFloatEqual,
	/* 548 */ primitiveSmallFloatNotEqual,
	/* 549 */ primitiveSmallFloatMultiply,
	/* 550 */ primitiveSmallFloatDivide,
	/* 551 */ primitiveSmallFloatTruncated,
	/* 552 */ primitiveSmallFloatFractionalPart,
	/* 553 */ primitiveSmallFloatExponent,
	/* 554 */ primitiveSmallFloatTimesTwoPower,
	/* 555 */ primitiveSmallFloatSquareRoot,
	/* 556 */ primitiveSmallFloatSine,
	/* 557 */ primitiveSmallFloatArctan,
	/* 558 */ primitiveSmallFloatLogN,
	/* 559 */ primitiveSmallFloatExp,
	/* 560 */ (void (*)(void))0,
	/* 561 */ (void (*)(void))0,
	/* 562 */ (void (*)(void))0,
	/* 563 */ (void (*)(void))0,
	/* 564 */ (void (*)(void))0,
	/* 565 */ (void (*)(void))0,
	/* 566 */ (void (*)(void))0,
	/* 567 */ (void (*)(void))0,
	/* 568 */ (void (*)(void))0,
	/* 569 */ (void (*)(void))0,
	/* 570 */ primitiveFlushExternalPrimitives,
	/* 571 */ primitiveUnloadModule,
	/* 572 */ primitiveListBuiltinModule,
	/* 573 */ primitiveListExternalModule,
	/* 574 */ primitiveFloat64ArrayAdd,
	/* 575 */ (void (*)(void))0,
	/* 576 */ (void (*)(void))0,
	/* 577 */ (void (*)(void))0,
	/* 578 */ (void (*)(void))0,
	/* 579 */ (void (*)(void))0,
	/* 580 */ (void (*)(void))0,
	/* 581 */ (void (*)(void))0,
	/* 582 */ (void (*)(void))0,
	/* 583 */ (void (*)(void))0,
	/* 584 */ (void (*)(void))0,
	/* 585 */ (void (*)(void))0,
	/* 586 */ (void (*)(void))0,
	/* 587 */ (void (*)(void))0,
	/* 588 */ (void (*)(void))0,
	/* 589 */ (void (*)(void))0,
	/* 590 */ (void (*)(void))0,
	/* 591 */ (void (*)(void))0,
	/* 592 */ (void (*)(void))0,
	/* 593 */ (void (*)(void))0,
	/* 594 */ (void (*)(void))0,
	/* 595 */ (void (*)(void))0,
	/* 596 */ primitiveNewOldSpace,
	/* 597 */ primitiveNewWithArgOldSpace,
	/* 598 */ primitiveNewPinned,
	/* 599 */ primitiveNewWithArgPinned,
	/* 600 */ primitiveLoadBoolean8FromBytes,
	/* 601 */ primitiveLoadUInt8FromBytes,
	/* 602 */ primitiveLoadInt8FromBytes,
	/* 603 */ primitiveLoadUInt16FromBytes,
	/* 604 */ primitiveLoadInt16FromBytes,
	/* 605 */ primitiveLoadUInt32FromBytes,
	/* 606 */ primitiveLoadInt32FromBytes,
	/* 607 */ primitiveLoadUInt64FromBytes,
	/* 608 */ primitiveLoadInt64FromBytes,
	/* 609 */ primitiveLoadPointerFromBytes,
	/* 610 */ primitiveLoadChar8FromBytes,
	/* 611 */ primitiveLoadChar16FromBytes,
	/* 612 */ primitiveLoadChar32FromBytes,
	/* 613 */ primitiveLoadFloat32FromBytes,
	/* 614 */ primitiveLoadFloat64FromBytes,
	/* 615 */ primitiveStoreBoolean8IntoBytes,
	/* 616 */ primitiveStoreUInt8IntoBytes,
	/* 617 */ primitiveStoreInt8IntoBytes,
	/* 618 */ primitiveStoreUInt16IntoBytes,
	/* 619 */ primitiveStoreInt16IntoBytes,
	/* 620 */ primitiveStoreUInt32IntoBytes,
	/* 621 */ primitiveStoreInt32IntoBytes,
	/* 622 */ primitiveStoreUInt64IntoBytes,
	/* 623 */ primitiveStoreInt64IntoBytes,
	/* 624 */ primitiveStorePointerIntoBytes,
	/* 625 */ primitiveStoreChar8IntoBytes,
	/* 626 */ primitiveStoreChar16IntoBytes,
	/* 627 */ primitiveStoreChar32IntoBytes,
	/* 628 */ primitiveStoreFloat32IntoBytes,
	/* 629 */ primitiveStoreFloat64IntoBytes,
	/* 630 */ primitiveLoadBoolean8FromExternalAddress,
	/* 631 */ primitiveLoadUInt8FromExternalAddress,
	/* 632 */ primitiveLoadInt8FromExternalAddress,
	/* 633 */ primitiveLoadUInt16FromExternalAddress,
	/* 634 */ primitiveLoadInt16FromExternalAddress,
	/* 635 */ primitiveLoadUInt32FromExternalAddress,
	/* 636 */ primitiveLoadInt32FromExternalAddress,
	/* 637 */ primitiveLoadUInt64FromExternalAddress,
	/* 638 */ primitiveLoadInt64FromExternalAddress,
	/* 639 */ primitiveLoadPointerFromExternalAddress,
	/* 640 */ primitiveLoadChar8FromExternalAddress,
	/* 641 */ primitiveLoadChar16FromExternalAddress,
	/* 642 */ primitiveLoadChar32FromExternalAddress,
	/* 643 */ primitiveLoadFloat32FromExternalAddress,
	/* 644 */ primitiveLoadFloat64FromExternalAddress,
	/* 645 */ primitiveStoreBoolean8IntoExternalAddress,
	/* 646 */ primitiveStoreUInt8IntoExternalAddress,
	/* 647 */ primitiveStoreInt8IntoExternalAddress,
	/* 648 */ primitiveStoreUInt16IntoExternalAddress,
	/* 649 */ primitiveStoreInt16IntoExternalAddress,
	/* 650 */ primitiveStoreUInt32IntoExternalAddress,
	/* 651 */ primitiveStoreInt32IntoExternalAddress,
	/* 652 */ primitiveStoreUInt64IntoExternalAddress,
	/* 653 */ primitiveStoreInt64IntoExternalAddress,
	/* 654 */ primitiveStorePointerIntoExternalAddress,
	/* 655 */ primitiveStoreChar8IntoExternalAddress,
	/* 656 */ primitiveStoreChar16IntoExternalAddress,
	/* 657 */ primitiveStoreChar32IntoExternalAddress,
	/* 658 */ primitiveStoreFloat32IntoExternalAddress,
	/* 659 */ primitiveStoreFloat64IntoExternalAddress,
	/* 660 */ (void (*)(void))0,
 0 };
static void (*externalPrimitiveTable[MaxExternalPrimitiveTableSize + 1 /* 4097 */])(void);
static signed char primitiveAccessorDepthTable[MaxPrimitiveIndex + 2 /* 662 */] = {
/*0*/	-1,-1,-1, 0, 0, 0, 0, 0, 0, 0, 0,-1,-1, 0,-1,-1, 0, 0, 0,-1,
/*20*/	0, 0, 0,-1,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0,-1,-1,-1, 0, 0, 0,
/*40*/	0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*60*/	0, 0, 0,-1,-1,-1,-1,-1, 0, 0,-1,-1, 0, 1, 1, 0, 0, 0, 0, 0,
/*80*/	-1,-1,-1, 0,-1,-1, 0, 0, 1,-1, 0, 0, 0,-1,-1,-1,-1,-1,-1,-1,
/*100*/	1,-1,-1,-1,-1, 3,-1,-1,-1,-1, 0, 0,-1,-1,-1, 1,-1,-1, 1, 0,
/*120*/	-1, 0,-1,-1, 0, 0,-1,-1, 0,-1,-1,-1, 1,-1,-1,-1, 0,-1,-1,-1,
/*140*/	-1,-1,-1, 1, 0,-1,-1,-1, 0, 0,-1,-1,-1,-1,-1,-1,-1,-1, 1, 1,
/*160*/	0, 0,-1, 0, 0, 1, 1,-1, 1, 0, 0, 1,-1, 1, 1,-1,-1,-1,-1,-1,
/*180*/	0,-1,-1, 0, 0, 0, 1, 1, 1, 0,-1,-1,-1,-1,-1, 1, 2,-1,-1,-1,
/*200*/	-1,-1,-1,-1,-1,-1,-1, 1, 1, 1, 1, 1, 1, 1,-1, 0,-1, 0, 3,-1,
/*220*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*240*/	-1,-1, 0,-1, 0,-1,-1,-1, 0,-1,-1,-1,-1, 0, 0,-1,-1,-1,-1,-1,
/*260*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*280*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*300*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*320*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*340*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*360*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*380*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*400*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*420*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*440*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*460*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*480*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*500*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*520*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*540*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,-1,-1,-1,-1,-1,
/*560*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0, 0, 0, 1,-1,-1,-1,-1,-1,
/*580*/	-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
/*600*/	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
/*620*/	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/*640*/	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0,
/*660*/	-1
	};
char expensiveAsserts = 0;
struct VirtualMachine* interpreterProxy;
const char *interpreterVersion = "Croquet Closure Cog[Spur] VM [CoInterpreterPrimitives VMMaker-tonel.1]";
volatile int sendTrace;


/*** Macros ***/
#define fieldFormat() "\t#%s : %" PRIdSQINT
#define msgFormat(aMessage) aMessage "%" PRIdSQINT
#define cPICNumCases stackCheckOffset
#define cPICNumCasesHack hack hack hack i.e. the getter macro does all the work
#define nextOpenPIC methodObject
#define nextOpenPICHack hack hack hack i.e. the getter macro does all the work
#define getCodeCompactionCount() integerObjectOf(GIV(statCodeCompactionCount))
#define getCodeCompactionMSecs() integerObjectOf((GIV(statCodeCompactionUsecs) + 500) / 1000)
#define getCogCodeSize() integerObjectOf(GIV(cogCodeSize))
#define getDesiredCogCodeSize() integerObjectOf(desiredCogCodeSize)
#define mnuCompilationBreakpoint(sel, len) do { \
	if ((len) == -breakSelectorLength \
	 && !strncmp((char *)((sel) + BaseHeaderSize), breakSelector, -breakSelectorLength)) { \
		suppressHeartbeatFlag = 1; \
		compilationBreakpointFor(sel); \
	} \
} while (0)
#define primNumberExternalCall() 117
#define primTraceLogIndex(aValue) (GIV(primTraceLogIndex) = (aValue))
#define doFreeFromTask(aTask,anAddress) (free(anAddress))
#define numTagBits() 3
#define shiftForWord() 3
#define smallFloatExponentBits() 8
#define smallFloatExponentOffset() 896
#define smallFloatMantissaBits() 52
#define smallFloatTag() 4
#define tagMask() 0x7
#define wordSize() 8
#define eden() GIV(eden)
#define futureSpace() GIV(futureSpace)
#define futureSurvivorStart() GIV(futureSurvivorStart)
#define pastSpace() GIV(pastSpace)
#define arrayClassIndexPun() 16
#define characterTag() 2
#define classIndexMask() 0x3FFFFF
#define classIsItselfClassIndexPun() 31
#define classTableFirstPage() classTableFirstPage
#define classTableMajorIndexShift() 10
#define firstByteFormat() 16
#define firstClassIndexPun() 16
#define firstCompiledMethodFormat() 24
#define firstLongFormat() 10
#define firstShortFormat() 12
#define fixedFieldsFieldWidth() 16
#define formatFieldWidthShift() 5
#define formatMask() 0x1F
#define formatShift() 24
#define freeStart0() GIV(freeStart)
#define greyBitShift() 31
#define identityHashFullWordShift() 32
#define identityHashHalfWordMask() 0x3FFFFF
#define immutableBitShift() 23
#define indexablePointersFormat() 3
#define isForwardedObjectClassIndexPun() 8
#define isFreeObjectClassIndexPun() 0
#define lastClassIndexPun() 31
#define markedBitFullShift() 55
#define markedBitHalfShift() 23
#define maxOldSpaceSize() maxOldSpaceSize
#define numSlotsFullShift() 56
#define numSlotsHalfShift() 24
#define numSlotsMask() 0xFF
#define pastSpaceStart() GIV(pastSpaceStart)
#define pinnedBitShift() 30
#define remapBufferCount() GIV(remapBufferCount)
#define rememberedBitShift() 29
#define segmentBridgePun() 3
#define sixtyFourBitIndexableFormat() 9
#define sixtyFourBitLongsClassIndexPun() 19
#define smallIntegerTag() 1
#define thirtyTwoBitLongsClassIndexPun() 18
#define unalignedLong32At(addr) long32At(addr)
#define unalignedLong32Atput(addr,value) long32Atput(addr,value)
#define unalignedLong64At(addr) long64At(addr)
#define unalignedLong64Atput(addr,value) long64Atput(addr,value)
#define unalignedShortAt(addr) shortAt(addr)
#define unalignedShortAtput(addr,value) shortAtput(addr,value)
#define weakArrayClassIndexPun() 17
#define weakArrayFormat() 4
#define numSegments() GIV(numSegments)
#define segments() GIV(segments)
#define alternateHeaderNumLiteralsMask() 0x7FFF
#define checkAllocFiller() GIV(checkAllocFiller)
#define enterSmalltalkExecutive() enterSmalltalkExecutiveImplementation()
#define flush() fflush(stdout)
#define initialEnterSmalltalkExecutive() enterSmalltalkExecutiveImplementation()
#define printFloat(f) vm_printf("%g", f)
#define remoteIsInstVarAccess() 128
#define allocatype(numElements, elementType) alloca((numElements)*sizeof(elementType))
#define contentsOf(value) value
#define oopisGreaterThanOrEqualTo(anOop,otherOop) ((usqInt)(anOop) >= (usqInt)(otherOop))
#define oopisGreaterThanOrEqualToandLessThanOrEqualTo(anOop,baseOop,limitOop) ((usqInt)(anOop) >= (usqInt)(baseOop) && (usqInt)(anOop) <= (usqInt)(limitOop))
#define oopisGreaterThanOrEqualToandLessThan(anOop,baseOop,limitOop) ((usqInt)(anOop) >= (usqInt)(baseOop) && (usqInt)(anOop) < (usqInt)(limitOop))
#define oopisGreaterThan(anOop,otherOop) ((usqInt)(anOop) > (usqInt)(otherOop))
#define oopisGreaterThanandLessThan(anOop,baseOop,limitOop) ((usqInt)(anOop) > (usqInt)(baseOop) && (usqInt)(anOop) < (usqInt)(limitOop))
#define oopisLessThanOrEqualTo(anOop,otherOop) ((usqInt)(anOop) <= (usqInt)(otherOop))
#define oopisLessThan(anOop,otherOop) ((usqInt)(anOop) < (usqInt)(otherOop))
#define mostRecentlyUsedPage() GIV(mostRecentlyUsedPage)
#define pageIndexForstackBasePlus1bytesPerPage(pointer,stkBasePlus1,pageByteSize) (((char *)(pointer) - (stkBasePlus1)) / (pageByteSize))
#define stackPageAtpages(index,pages) ((pages) + (index))
#define statMaxPageCountWhenMapping0() GIV(statMaxPageCountWhenMapping)

/*	This is the main interpreter loop. It normally loops forever, fetching and 
	executing bytecodes. When running in the context of a browser plugin VM, 
	however, it must return control to the browser periodically. This should 
	done only when the state of the currently running Squeak thread is safely 
	stored in the object heap. Since this is the case at the moment that a 
	check for interrupts is performed, that is when we return to the browser 
	if it is time to do so. Interrupt checks happen quite frequently.If stacklimit is zero then the stack pages have not been initialized. */
/* StackInterpreter>>#interpret */
sqInt
interpret(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	register sqInt currentBytecode CB_REG;
	sqInt extA;
	sqInt extB;
	sqInt lkupClassTag;
	sqInt localReturnValue;
	register char* local_framePointer FP_REG;
	register char* local_instructionPointer IP_REG;
	register char* local_stackPointer SP_REG;
	sqInt numExtB;
	sqInt stackSlots;
	VMMemoryMap *_aMemoryMap;
	int _count;
	sqInt _index;
	sqInt _numPages;
	StackPage *_page;
	char *_pageStructBase;
	sqInt _slotsPerPage;
	sqInt _stackAddress;
	sqInt _stackPageBytes;
	sqInt _stackPagesBytes;
	usqIntptr_t _structStackPageSize;
	sqInt _theIndex;
	void *_theStackMemory;
    JUMP_TABLE;

#if MULTIPLEBYTECODESETS
	if(!asserta((sizeof(jumpTable)/sizeof(jumpTable[0])) >= 512))
		error("bytecode jumpTable too small");
#endif

	local_stackPointer = GIV(stackPointer);
	local_instructionPointer = GIV(instructionPointer);
	local_framePointer = GIV(framePointer);
	if (GIV(stackLimit) == 0) {
		/* begin initStackPagesAndInterpret */
		/* begin initStackPages */
		_stackPageBytes = stackPageByteSize();
		/* begin computeStackZoneSize */
		_stackPagesBytes = (GIV(numStackPages) * ((sizeof(VMStackPage)) + (stackPageByteSize()))) + BytesPerWord;
		/* end computeStackZoneSize */
		/* begin initializeWithByteSize:inMemoryMap:for: */
		/* begin getMemoryMap */
		_aMemoryMap = GIV(memoryMap);
		/* end getMemoryMap */
		allocateStackPages(_aMemoryMap, _stackPagesBytes);
		_stackAddress = (_aMemoryMap->stackPagesStart);
		_theStackMemory = _stackAddress;
		/* end initializeWithByteSize:inMemoryMap:for: */
		/* begin initializeStack:numSlots:pageSize: */
		stackSlots = _stackPagesBytes / BytesPerWord;
		_slotsPerPage = _stackPageBytes / BytesPerWord;
		_structStackPageSize = sizeof(VMStackPage);
		GIV(bytesPerPage) = _slotsPerPage * BytesPerWord;
		/* begin numStkPages */
		_numPages = GIV(numStackPages);
		/* end numStkPages */
		_pageStructBase = (_theStackMemory + (_numPages * GIV(bytesPerPage))) + BytesPerWord;
		GIV(pages) = ((StackPage *) _pageStructBase );
		assert((((stackPageByteSize()) - (stackLimitBytes())) - (stackLimitOffset())) >= (stackPageHeadroom()));
		for (_index = 0; _index < _numPages; _index += 1) {
			/* begin stackPageAt: */
			_page = stackPageAtpages(_index, GIV(pages));
			/* end stackPageAt: */
			{
				(_page->lastAddress = _theStackMemory + (_index * GIV(bytesPerPage)));
				(_page->baseAddress = ((_page->lastAddress)) + GIV(bytesPerPage));
				(_page->stackLimit = ((_page->baseAddress)) - (((GIV(desiredStackPageBytes) < (((stackPageByteSize()) - ((IFrameSlots + 64) * BytesPerWord)) - (osCogStackPageHeadroom()))) ? GIV(desiredStackPageBytes) : ((stackPageByteSize()) - ((IFrameSlots + 64) * BytesPerWord)) - (osCogStackPageHeadroom()))));
				(_page->realStackLimit = (_page->stackLimit));
				(_page->baseFP = 0);
				(_page->nextPage = stackPageAt(((_index == (_numPages - 1))
					 ? 0
					 : _index + 1)));
				(_page->prevPage = stackPageAt(((_index == 0)
					 ? _numPages - 1
					 : _index - 1)));
			}
		}
		GIV(stackBasePlus1) = ((char *) _theStackMemory ) + 1;
		/* begin stackPageAt: */
		_page = stackPageAtpages(0, GIV(pages));
		/* end stackPageAt: */
		GIV(overflowLimit) = ((((_page->baseAddress)) - ((_page->realStackLimit))) * 3) / 5;
		for (_index = 0; _index < _numPages; _index += 1) {
			/* begin stackPageAt: */
			_page = stackPageAtpages(_index, GIV(pages));
			/* end stackPageAt: */
			assert((pageIndexFor((_page->baseAddress))) == _index);
			assert((pageIndexFor(((_page->baseAddress)) - ((_slotsPerPage - 1) * BytesPerWord))) == _index);
			assert((stackPageFor((_page->baseAddress))) == _page);
			assert((stackPageFor((_page->stackLimit))) == _page);
			/* begin initializePageTraceToInvalid: */
			(_page->trace = StackPageTraceInvalid);
			/* end initializePageTraceToInvalid: */
		}
		/* begin stackPageAt: */
		GIV(mostRecentlyUsedPage) = stackPageAtpages(0, GIV(pages));
		/* end stackPageAt: */
		_page = GIV(mostRecentlyUsedPage);
		_count = 0;
		do {
			_count += 1;
			{
				assert((((char *) ((_page->baseAddress)) ) >= (GIV(stackBasePlus1) - 1)) && (((char *) ((_page->baseAddress)) ) <= ((char *) GIV(pages) )));
				_theIndex = pageIndexForstackBasePlus1bytesPerPage((_page->baseAddress), GIV(stackBasePlus1), GIV(bytesPerPage));
			}
			assert((stackPageAt(_theIndex)) == _page);
			assert((pageIndexFor((_page->baseAddress))) == _theIndex);
			assert((pageIndexFor((_page->stackLimit))) == _theIndex);
			assert((pageIndexFor(((_page->lastAddress)) + 1)) == _theIndex);
		} while (((_page = (_page->nextPage))) != GIV(mostRecentlyUsedPage));
		assert(_count == _numPages);
		assert(pageListIsWellFormed());
		/* end initializeStack:numSlots:pageSize: */
		/* end initStackPages */
		{
			GIV(framePointer) = local_framePointer;
			GIV(instructionPointer) = local_instructionPointer;
			GIV(stackPointer) = local_stackPointer;
			loadInitialContext();
			local_framePointer = GIV(framePointer);
			local_instructionPointer = GIV(instructionPointer);
			local_stackPointer = GIV(stackPointer);
		}
		ioInitHeartbeat();
		{
			GIV(framePointer) = local_framePointer;
			GIV(instructionPointer) = local_instructionPointer;
			GIV(stackPointer) = local_stackPointer;
			initialEnterSmalltalkExecutive();
			local_framePointer = GIV(framePointer);
			local_instructionPointer = GIV(instructionPointer);
			local_stackPointer = GIV(stackPointer);
		}
		{
			GIV(framePointer) = local_framePointer;
			GIV(instructionPointer) = local_instructionPointer;
			GIV(stackPointer) = local_stackPointer;
			return null;
		}
		/* end initStackPagesAndInterpret */
	}
	/* begin initExtensions */
	{
		extA = (numExtB = (extB = 0));
	}
	/* end initExtensions */
	/* begin fetchNextBytecode */
	/* begin fetchByte */
	currentBytecode = byteAtPointer(++local_instructionPointer);
	/* end fetchByte */
	/* end fetchNextBytecode */
	while (1) {
		bytecodeDispatchDebugHook();
		VM_LABEL(bytecodeDispatch);
		switch (currentBytecode) {
			CASE(0)
			{
				/* pushReceiverVariableBytecode */
				{
					VM_LABEL(pushReceiverVariableBytecode);
					{
						sqInt _object;
						sqInt _objOop;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushReceiverVariable: */
							/* begin push: */
							/* begin fetchPointer:ofObject: */
							_objOop = unsignedLongAt(local_framePointer + FoxIFReceiver);
							_object = unsignedLongAt(_objOop + BaseHeaderSize);
							/* end fetchPointer:ofObject: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushReceiverVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(1)
			{
				/* pushReceiverVariableBytecode */
				{
					VM_LABEL(pushReceiverVariableBytecode1);
					{
						sqInt _object;
						sqInt _objOop;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushReceiverVariable: */
							/* begin push: */
							/* begin fetchPointer:ofObject: */
							_objOop = unsignedLongAt(local_framePointer + FoxIFReceiver);
							_object = unsignedLongAt((_objOop + BaseHeaderSize) + 8);
							/* end fetchPointer:ofObject: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushReceiverVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(2)
			{
				/* pushReceiverVariableBytecode */
				{
					VM_LABEL(pushReceiverVariableBytecode2);
					{
						sqInt _object;
						sqInt _objOop;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushReceiverVariable: */
							/* begin push: */
							/* begin fetchPointer:ofObject: */
							_objOop = unsignedLongAt(local_framePointer + FoxIFReceiver);
							_object = unsignedLongAt((_objOop + BaseHeaderSize) + 16);
							/* end fetchPointer:ofObject: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushReceiverVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(3)
			{
				/* pushReceiverVariableBytecode */
				{
					VM_LABEL(pushReceiverVariableBytecode3);
					{
						sqInt _object;
						sqInt _objOop;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushReceiverVariable: */
							/* begin push: */
							/* begin fetchPointer:ofObject: */
							_objOop = unsignedLongAt(local_framePointer + FoxIFReceiver);
							_object = unsignedLongAt((_objOop + BaseHeaderSize) + 24);
							/* end fetchPointer:ofObject: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushReceiverVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(4)
			{
				/* pushReceiverVariableBytecode */
				{
					VM_LABEL(pushReceiverVariableBytecode4);
					{
						sqInt _object;
						sqInt _objOop;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushReceiverVariable: */
							/* begin push: */
							/* begin fetchPointer:ofObject: */
							_objOop = unsignedLongAt(local_framePointer + FoxIFReceiver);
							_object = unsignedLongAt((_objOop + BaseHeaderSize) + 32);
							/* end fetchPointer:ofObject: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushReceiverVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(5)
			{
				/* pushReceiverVariableBytecode */
				{
					VM_LABEL(pushReceiverVariableBytecode5);
					{
						sqInt _object;
						sqInt _objOop;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushReceiverVariable: */
							/* begin push: */
							/* begin fetchPointer:ofObject: */
							_objOop = unsignedLongAt(local_framePointer + FoxIFReceiver);
							_object = unsignedLongAt((_objOop + BaseHeaderSize) + 40);
							/* end fetchPointer:ofObject: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushReceiverVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(6)
			{
				/* pushReceiverVariableBytecode */
				{
					VM_LABEL(pushReceiverVariableBytecode6);
					{
						sqInt _object;
						sqInt _objOop;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushReceiverVariable: */
							/* begin push: */
							/* begin fetchPointer:ofObject: */
							_objOop = unsignedLongAt(local_framePointer + FoxIFReceiver);
							_object = unsignedLongAt((_objOop + BaseHeaderSize) + 48);
							/* end fetchPointer:ofObject: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushReceiverVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(7)
			{
				/* pushReceiverVariableBytecode */
				{
					VM_LABEL(pushReceiverVariableBytecode7);
					{
						sqInt _object;
						sqInt _objOop;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushReceiverVariable: */
							/* begin push: */
							/* begin fetchPointer:ofObject: */
							_objOop = unsignedLongAt(local_framePointer + FoxIFReceiver);
							_object = unsignedLongAt((_objOop + BaseHeaderSize) + 56);
							/* end fetchPointer:ofObject: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushReceiverVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(8)
			{
				/* pushReceiverVariableBytecode */
				{
					VM_LABEL(pushReceiverVariableBytecode8);
					{
						sqInt _object;
						sqInt _objOop;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushReceiverVariable: */
							/* begin push: */
							/* begin fetchPointer:ofObject: */
							_objOop = unsignedLongAt(local_framePointer + FoxIFReceiver);
							_object = unsignedLongAt((_objOop + BaseHeaderSize) + 64);
							/* end fetchPointer:ofObject: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushReceiverVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(9)
			{
				/* pushReceiverVariableBytecode */
				{
					VM_LABEL(pushReceiverVariableBytecode9);
					{
						sqInt _object;
						sqInt _objOop;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushReceiverVariable: */
							/* begin push: */
							/* begin fetchPointer:ofObject: */
							_objOop = unsignedLongAt(local_framePointer + FoxIFReceiver);
							_object = unsignedLongAt((_objOop + BaseHeaderSize) + 72);
							/* end fetchPointer:ofObject: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushReceiverVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(10)
			{
				/* pushReceiverVariableBytecode */
				{
					VM_LABEL(pushReceiverVariableBytecode10);
					{
						sqInt _object;
						sqInt _objOop;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushReceiverVariable: */
							/* begin push: */
							/* begin fetchPointer:ofObject: */
							_objOop = unsignedLongAt(local_framePointer + FoxIFReceiver);
							_object = unsignedLongAt((_objOop + BaseHeaderSize) + 80);
							/* end fetchPointer:ofObject: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushReceiverVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(11)
			{
				/* pushReceiverVariableBytecode */
				{
					VM_LABEL(pushReceiverVariableBytecode11);
					{
						sqInt _object;
						sqInt _objOop;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushReceiverVariable: */
							/* begin push: */
							/* begin fetchPointer:ofObject: */
							_objOop = unsignedLongAt(local_framePointer + FoxIFReceiver);
							_object = unsignedLongAt((_objOop + BaseHeaderSize) + 88);
							/* end fetchPointer:ofObject: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushReceiverVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(12)
			{
				/* pushReceiverVariableBytecode */
				{
					VM_LABEL(pushReceiverVariableBytecode12);
					{
						sqInt _object;
						sqInt _objOop;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushReceiverVariable: */
							/* begin push: */
							/* begin fetchPointer:ofObject: */
							_objOop = unsignedLongAt(local_framePointer + FoxIFReceiver);
							_object = unsignedLongAt((_objOop + BaseHeaderSize) + 96);
							/* end fetchPointer:ofObject: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushReceiverVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(13)
			{
				/* pushReceiverVariableBytecode */
				{
					VM_LABEL(pushReceiverVariableBytecode13);
					{
						sqInt _object;
						sqInt _objOop;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushReceiverVariable: */
							/* begin push: */
							/* begin fetchPointer:ofObject: */
							_objOop = unsignedLongAt(local_framePointer + FoxIFReceiver);
							_object = unsignedLongAt((_objOop + BaseHeaderSize) + 104);
							/* end fetchPointer:ofObject: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushReceiverVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(14)
			{
				/* pushReceiverVariableBytecode */
				{
					VM_LABEL(pushReceiverVariableBytecode14);
					{
						sqInt _object;
						sqInt _objOop;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushReceiverVariable: */
							/* begin push: */
							/* begin fetchPointer:ofObject: */
							_objOop = unsignedLongAt(local_framePointer + FoxIFReceiver);
							_object = unsignedLongAt((_objOop + BaseHeaderSize) + 112);
							/* end fetchPointer:ofObject: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushReceiverVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(15)
			{
				/* pushReceiverVariableBytecode */
				{
					VM_LABEL(pushReceiverVariableBytecode15);
					{
						sqInt _object;
						sqInt _objOop;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushReceiverVariable: */
							/* begin push: */
							/* begin fetchPointer:ofObject: */
							_objOop = unsignedLongAt(local_framePointer + FoxIFReceiver);
							_object = unsignedLongAt((_objOop + BaseHeaderSize) + 120);
							/* end fetchPointer:ofObject: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushReceiverVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(16)
			{
				/* pushLiteralVariable16CasesBytecode */
				{
					VM_LABEL(pushLiteralVariable16CasesBytecode);
					{
						sqInt _literalIndex;
						sqInt _litVar;
						sqInt _object;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralVariable: */
							_literalIndex = 0;
							{
								assert(GIV(method) == (iframeMethod(local_framePointer)));
								/* begin fetchPointer:ofObject: */
								_litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_literalIndex + LiteralStart) ) << 3) ));
								/* end fetchPointer:ofObject: */
							}
							if (((long64At(_litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								_litVar = unfollowatIndex(_litVar, _literalIndex);
							}
							/* begin push: */
							_object = unsignedLongAt((_litVar + BaseHeaderSize) + 8);
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(17)
			{
				/* pushLiteralVariable16CasesBytecode */
				{
					VM_LABEL(pushLiteralVariable16CasesBytecode1);
					{
						sqInt _literalIndex;
						sqInt _litVar;
						sqInt _object;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralVariable: */
							_literalIndex = 1;
							{
								assert(GIV(method) == (iframeMethod(local_framePointer)));
								/* begin fetchPointer:ofObject: */
								_litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_literalIndex + LiteralStart) ) << 3) ));
								/* end fetchPointer:ofObject: */
							}
							if (((long64At(_litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								_litVar = unfollowatIndex(_litVar, _literalIndex);
							}
							/* begin push: */
							_object = unsignedLongAt((_litVar + BaseHeaderSize) + 8);
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(18)
			{
				/* pushLiteralVariable16CasesBytecode */
				{
					VM_LABEL(pushLiteralVariable16CasesBytecode2);
					{
						sqInt _literalIndex;
						sqInt _litVar;
						sqInt _object;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralVariable: */
							_literalIndex = 2;
							{
								assert(GIV(method) == (iframeMethod(local_framePointer)));
								/* begin fetchPointer:ofObject: */
								_litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_literalIndex + LiteralStart) ) << 3) ));
								/* end fetchPointer:ofObject: */
							}
							if (((long64At(_litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								_litVar = unfollowatIndex(_litVar, _literalIndex);
							}
							/* begin push: */
							_object = unsignedLongAt((_litVar + BaseHeaderSize) + 8);
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(19)
			{
				/* pushLiteralVariable16CasesBytecode */
				{
					VM_LABEL(pushLiteralVariable16CasesBytecode3);
					{
						sqInt _literalIndex;
						sqInt _litVar;
						sqInt _object;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralVariable: */
							_literalIndex = 3;
							{
								assert(GIV(method) == (iframeMethod(local_framePointer)));
								/* begin fetchPointer:ofObject: */
								_litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_literalIndex + LiteralStart) ) << 3) ));
								/* end fetchPointer:ofObject: */
							}
							if (((long64At(_litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								_litVar = unfollowatIndex(_litVar, _literalIndex);
							}
							/* begin push: */
							_object = unsignedLongAt((_litVar + BaseHeaderSize) + 8);
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(20)
			{
				/* pushLiteralVariable16CasesBytecode */
				{
					VM_LABEL(pushLiteralVariable16CasesBytecode4);
					{
						sqInt _literalIndex;
						sqInt _litVar;
						sqInt _object;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralVariable: */
							_literalIndex = 4;
							{
								assert(GIV(method) == (iframeMethod(local_framePointer)));
								/* begin fetchPointer:ofObject: */
								_litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_literalIndex + LiteralStart) ) << 3) ));
								/* end fetchPointer:ofObject: */
							}
							if (((long64At(_litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								_litVar = unfollowatIndex(_litVar, _literalIndex);
							}
							/* begin push: */
							_object = unsignedLongAt((_litVar + BaseHeaderSize) + 8);
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(21)
			{
				/* pushLiteralVariable16CasesBytecode */
				{
					VM_LABEL(pushLiteralVariable16CasesBytecode5);
					{
						sqInt _literalIndex;
						sqInt _litVar;
						sqInt _object;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralVariable: */
							_literalIndex = 5;
							{
								assert(GIV(method) == (iframeMethod(local_framePointer)));
								/* begin fetchPointer:ofObject: */
								_litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_literalIndex + LiteralStart) ) << 3) ));
								/* end fetchPointer:ofObject: */
							}
							if (((long64At(_litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								_litVar = unfollowatIndex(_litVar, _literalIndex);
							}
							/* begin push: */
							_object = unsignedLongAt((_litVar + BaseHeaderSize) + 8);
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(22)
			{
				/* pushLiteralVariable16CasesBytecode */
				{
					VM_LABEL(pushLiteralVariable16CasesBytecode6);
					{
						sqInt _literalIndex;
						sqInt _litVar;
						sqInt _object;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralVariable: */
							_literalIndex = 6;
							{
								assert(GIV(method) == (iframeMethod(local_framePointer)));
								/* begin fetchPointer:ofObject: */
								_litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_literalIndex + LiteralStart) ) << 3) ));
								/* end fetchPointer:ofObject: */
							}
							if (((long64At(_litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								_litVar = unfollowatIndex(_litVar, _literalIndex);
							}
							/* begin push: */
							_object = unsignedLongAt((_litVar + BaseHeaderSize) + 8);
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(23)
			{
				/* pushLiteralVariable16CasesBytecode */
				{
					VM_LABEL(pushLiteralVariable16CasesBytecode7);
					{
						sqInt _literalIndex;
						sqInt _litVar;
						sqInt _object;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralVariable: */
							_literalIndex = 7;
							{
								assert(GIV(method) == (iframeMethod(local_framePointer)));
								/* begin fetchPointer:ofObject: */
								_litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_literalIndex + LiteralStart) ) << 3) ));
								/* end fetchPointer:ofObject: */
							}
							if (((long64At(_litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								_litVar = unfollowatIndex(_litVar, _literalIndex);
							}
							/* begin push: */
							_object = unsignedLongAt((_litVar + BaseHeaderSize) + 8);
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(24)
			{
				/* pushLiteralVariable16CasesBytecode */
				{
					VM_LABEL(pushLiteralVariable16CasesBytecode8);
					{
						sqInt _literalIndex;
						sqInt _litVar;
						sqInt _object;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralVariable: */
							_literalIndex = 8;
							{
								assert(GIV(method) == (iframeMethod(local_framePointer)));
								/* begin fetchPointer:ofObject: */
								_litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_literalIndex + LiteralStart) ) << 3) ));
								/* end fetchPointer:ofObject: */
							}
							if (((long64At(_litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								_litVar = unfollowatIndex(_litVar, _literalIndex);
							}
							/* begin push: */
							_object = unsignedLongAt((_litVar + BaseHeaderSize) + 8);
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(25)
			{
				/* pushLiteralVariable16CasesBytecode */
				{
					VM_LABEL(pushLiteralVariable16CasesBytecode9);
					{
						sqInt _literalIndex;
						sqInt _litVar;
						sqInt _object;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralVariable: */
							_literalIndex = 9;
							{
								assert(GIV(method) == (iframeMethod(local_framePointer)));
								/* begin fetchPointer:ofObject: */
								_litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_literalIndex + LiteralStart) ) << 3) ));
								/* end fetchPointer:ofObject: */
							}
							if (((long64At(_litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								_litVar = unfollowatIndex(_litVar, _literalIndex);
							}
							/* begin push: */
							_object = unsignedLongAt((_litVar + BaseHeaderSize) + 8);
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(26)
			{
				/* pushLiteralVariable16CasesBytecode */
				{
					VM_LABEL(pushLiteralVariable16CasesBytecode10);
					{
						sqInt _literalIndex;
						sqInt _litVar;
						sqInt _object;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralVariable: */
							_literalIndex = 10;
							{
								assert(GIV(method) == (iframeMethod(local_framePointer)));
								/* begin fetchPointer:ofObject: */
								_litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_literalIndex + LiteralStart) ) << 3) ));
								/* end fetchPointer:ofObject: */
							}
							if (((long64At(_litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								_litVar = unfollowatIndex(_litVar, _literalIndex);
							}
							/* begin push: */
							_object = unsignedLongAt((_litVar + BaseHeaderSize) + 8);
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(27)
			{
				/* pushLiteralVariable16CasesBytecode */
				{
					VM_LABEL(pushLiteralVariable16CasesBytecode11);
					{
						sqInt _literalIndex;
						sqInt _litVar;
						sqInt _object;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralVariable: */
							_literalIndex = 11;
							{
								assert(GIV(method) == (iframeMethod(local_framePointer)));
								/* begin fetchPointer:ofObject: */
								_litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_literalIndex + LiteralStart) ) << 3) ));
								/* end fetchPointer:ofObject: */
							}
							if (((long64At(_litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								_litVar = unfollowatIndex(_litVar, _literalIndex);
							}
							/* begin push: */
							_object = unsignedLongAt((_litVar + BaseHeaderSize) + 8);
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(28)
			{
				/* pushLiteralVariable16CasesBytecode */
				{
					VM_LABEL(pushLiteralVariable16CasesBytecode12);
					{
						sqInt _literalIndex;
						sqInt _litVar;
						sqInt _object;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralVariable: */
							_literalIndex = 12;
							{
								assert(GIV(method) == (iframeMethod(local_framePointer)));
								/* begin fetchPointer:ofObject: */
								_litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_literalIndex + LiteralStart) ) << 3) ));
								/* end fetchPointer:ofObject: */
							}
							if (((long64At(_litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								_litVar = unfollowatIndex(_litVar, _literalIndex);
							}
							/* begin push: */
							_object = unsignedLongAt((_litVar + BaseHeaderSize) + 8);
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(29)
			{
				/* pushLiteralVariable16CasesBytecode */
				{
					VM_LABEL(pushLiteralVariable16CasesBytecode13);
					{
						sqInt _literalIndex;
						sqInt _litVar;
						sqInt _object;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralVariable: */
							_literalIndex = 13;
							{
								assert(GIV(method) == (iframeMethod(local_framePointer)));
								/* begin fetchPointer:ofObject: */
								_litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_literalIndex + LiteralStart) ) << 3) ));
								/* end fetchPointer:ofObject: */
							}
							if (((long64At(_litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								_litVar = unfollowatIndex(_litVar, _literalIndex);
							}
							/* begin push: */
							_object = unsignedLongAt((_litVar + BaseHeaderSize) + 8);
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(30)
			{
				/* pushLiteralVariable16CasesBytecode */
				{
					VM_LABEL(pushLiteralVariable16CasesBytecode14);
					{
						sqInt _literalIndex;
						sqInt _litVar;
						sqInt _object;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralVariable: */
							_literalIndex = 14;
							{
								assert(GIV(method) == (iframeMethod(local_framePointer)));
								/* begin fetchPointer:ofObject: */
								_litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_literalIndex + LiteralStart) ) << 3) ));
								/* end fetchPointer:ofObject: */
							}
							if (((long64At(_litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								_litVar = unfollowatIndex(_litVar, _literalIndex);
							}
							/* begin push: */
							_object = unsignedLongAt((_litVar + BaseHeaderSize) + 8);
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(31)
			{
				/* pushLiteralVariable16CasesBytecode */
				{
					VM_LABEL(pushLiteralVariable16CasesBytecode15);
					{
						sqInt _literalIndex;
						sqInt _litVar;
						sqInt _object;
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralVariable: */
							_literalIndex = 15;
							{
								assert(GIV(method) == (iframeMethod(local_framePointer)));
								/* begin fetchPointer:ofObject: */
								_litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_literalIndex + LiteralStart) ) << 3) ));
								/* end fetchPointer:ofObject: */
							}
							if (((long64At(_litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								_litVar = unfollowatIndex(_litVar, _literalIndex);
							}
							/* begin push: */
							_object = unsignedLongAt((_litVar + BaseHeaderSize) + 8);
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(32)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 8) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(33)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode1);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 16) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(34)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode2);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 24) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(35)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode3);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 32) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(36)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode4);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 40) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(37)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode5);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 48) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(38)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode6);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 56) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(39)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode7);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 64) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(40)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode8);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 72) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(41)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode9);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 80) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(42)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode10);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 88) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(43)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode11);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 96) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(44)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode12);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 104) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(45)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode13);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 112) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(46)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode14);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 120) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(47)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode15);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 128) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(48)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode16);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 136) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(49)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode17);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 144) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(50)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode18);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 152) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(51)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode19);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 160) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(52)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode20);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 168) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(53)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode21);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 176) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(54)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode22);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 184) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(55)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode23);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 192) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(56)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode24);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 200) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(57)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode25);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 208) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(58)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode26);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 216) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(59)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode27);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 224) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(60)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode28);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 232) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(61)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode29);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 240) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(62)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode30);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 0xF8) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(63)
			{
				/* pushLiteralConstantBytecode */
				{
					VM_LABEL(pushLiteralConstantBytecode31);
					{
						char *_sp;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushLiteralConstant: */
							/* begin push: */
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + 256) /* end fetchPointer:ofObject: */));
							local_stackPointer = _sp;
							/* end push: */
							/* end pushLiteralConstant: */
						}
					}
				}
			}
			BREAK;
			CASE(64)
			{
				/* pushTemporaryVariableBytecode */
				{
					VM_LABEL(pushTemporaryVariableBytecode);
					{
						sqInt _frameNumArgs;
						sqInt _object;
						char *_sp;

						{
							sqInt t7;

							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushTemporaryVariable: */
							/* begin push: */
							if (0 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								t7 = unsignedLongAt((local_framePointer + FoxCallerSavedIP) + (_frameNumArgs * BytesPerWord));
							}
 else {
								t7 = unsignedLongAt(((local_framePointer + FoxIFReceiver) - BytesPerWord) + (_frameNumArgs * BytesPerWord));
							}
							_object = t7;
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushTemporaryVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(65)
			{
				/* pushTemporaryVariableBytecode */
				{
					VM_LABEL(pushTemporaryVariableBytecode1);
					{
						sqInt _frameNumArgs;
						sqInt _object;
						char *_sp;

						{
							sqInt t7;

							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushTemporaryVariable: */
							/* begin push: */
							if (1 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								t7 = unsignedLongAt((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 1) * BytesPerWord));
							}
 else {
								t7 = unsignedLongAt(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 1) * BytesPerWord));
							}
							_object = t7;
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushTemporaryVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(66)
			{
				/* pushTemporaryVariableBytecode */
				{
					VM_LABEL(pushTemporaryVariableBytecode2);
					{
						sqInt _frameNumArgs;
						sqInt _object;
						char *_sp;

						{
							sqInt t7;

							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushTemporaryVariable: */
							/* begin push: */
							if (2 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								t7 = unsignedLongAt((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 2) * BytesPerWord));
							}
 else {
								t7 = unsignedLongAt(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 2) * BytesPerWord));
							}
							_object = t7;
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushTemporaryVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(67)
			{
				/* pushTemporaryVariableBytecode */
				{
					VM_LABEL(pushTemporaryVariableBytecode3);
					{
						sqInt _frameNumArgs;
						sqInt _object;
						char *_sp;

						{
							sqInt t7;

							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushTemporaryVariable: */
							/* begin push: */
							if (3 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								t7 = unsignedLongAt((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 3) * BytesPerWord));
							}
 else {
								t7 = unsignedLongAt(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 3) * BytesPerWord));
							}
							_object = t7;
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushTemporaryVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(68)
			{
				/* pushTemporaryVariableBytecode */
				{
					VM_LABEL(pushTemporaryVariableBytecode4);
					{
						sqInt _frameNumArgs;
						sqInt _object;
						char *_sp;

						{
							sqInt t7;

							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushTemporaryVariable: */
							/* begin push: */
							if (4 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								t7 = unsignedLongAt((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 4) * BytesPerWord));
							}
 else {
								t7 = unsignedLongAt(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 4) * BytesPerWord));
							}
							_object = t7;
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushTemporaryVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(69)
			{
				/* pushTemporaryVariableBytecode */
				{
					VM_LABEL(pushTemporaryVariableBytecode5);
					{
						sqInt _frameNumArgs;
						sqInt _object;
						char *_sp;

						{
							sqInt t7;

							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushTemporaryVariable: */
							/* begin push: */
							if (5 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								t7 = unsignedLongAt((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 5) * BytesPerWord));
							}
 else {
								t7 = unsignedLongAt(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 5) * BytesPerWord));
							}
							_object = t7;
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushTemporaryVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(70)
			{
				/* pushTemporaryVariableBytecode */
				{
					VM_LABEL(pushTemporaryVariableBytecode6);
					{
						sqInt _frameNumArgs;
						sqInt _object;
						char *_sp;

						{
							sqInt t7;

							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushTemporaryVariable: */
							/* begin push: */
							if (6 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								t7 = unsignedLongAt((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 6) * BytesPerWord));
							}
 else {
								t7 = unsignedLongAt(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 6) * BytesPerWord));
							}
							_object = t7;
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushTemporaryVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(71)
			{
				/* pushTemporaryVariableBytecode */
				{
					VM_LABEL(pushTemporaryVariableBytecode7);
					{
						sqInt _frameNumArgs;
						sqInt _object;
						char *_sp;

						{
							sqInt t7;

							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushTemporaryVariable: */
							/* begin push: */
							if (7 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								t7 = unsignedLongAt((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 7) * BytesPerWord));
							}
 else {
								t7 = unsignedLongAt(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 7) * BytesPerWord));
							}
							_object = t7;
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushTemporaryVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(72)
			{
				/* pushTemporaryVariableBytecode */
				{
					VM_LABEL(pushTemporaryVariableBytecode8);
					{
						sqInt _frameNumArgs;
						sqInt _object;
						char *_sp;

						{
							sqInt t7;

							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushTemporaryVariable: */
							/* begin push: */
							if (8 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								t7 = unsignedLongAt((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 8) * BytesPerWord));
							}
 else {
								t7 = unsignedLongAt(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 8) * BytesPerWord));
							}
							_object = t7;
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushTemporaryVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(73)
			{
				/* pushTemporaryVariableBytecode */
				{
					VM_LABEL(pushTemporaryVariableBytecode9);
					{
						sqInt _frameNumArgs;
						sqInt _object;
						char *_sp;

						{
							sqInt t7;

							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushTemporaryVariable: */
							/* begin push: */
							if (9 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								t7 = unsignedLongAt((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 9) * BytesPerWord));
							}
 else {
								t7 = unsignedLongAt(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 9) * BytesPerWord));
							}
							_object = t7;
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushTemporaryVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(74)
			{
				/* pushTemporaryVariableBytecode */
				{
					VM_LABEL(pushTemporaryVariableBytecode10);
					{
						sqInt _frameNumArgs;
						sqInt _object;
						char *_sp;

						{
							sqInt t7;

							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushTemporaryVariable: */
							/* begin push: */
							if (10 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								t7 = unsignedLongAt((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 10) * BytesPerWord));
							}
 else {
								t7 = unsignedLongAt(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 10) * BytesPerWord));
							}
							_object = t7;
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushTemporaryVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(75)
			{
				/* pushTemporaryVariableBytecode */
				{
					VM_LABEL(pushTemporaryVariableBytecode11);
					{
						sqInt _frameNumArgs;
						sqInt _object;
						char *_sp;

						{
							sqInt t7;

							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushTemporaryVariable: */
							/* begin push: */
							if (11 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								t7 = unsignedLongAt((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 11) * BytesPerWord));
							}
 else {
								t7 = unsignedLongAt(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 11) * BytesPerWord));
							}
							_object = t7;
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
							/* end pushTemporaryVariable: */
						}
					}
				}
			}
			BREAK;
			CASE(76)
			{
				/* pushReceiverBytecode */
				{
					VM_LABEL(pushReceiverBytecode);
					{
						sqInt _object;
						char *_sp;

						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin push: */
						_object = unsignedLongAt(local_framePointer + FoxIFReceiver);
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
						local_stackPointer = _sp;
						/* end push: */
					}
				}
			}
			BREAK;
			CASE(77)
			{
				/* pushConstantTrueBytecode */
				{
					VM_LABEL(pushConstantTrueBytecode);
					{
						char *_sp;

						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin push: */
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), GIV(trueObj));
						local_stackPointer = _sp;
						/* end push: */
					}
				}
			}
			BREAK;
			CASE(78)
			{
				/* pushConstantFalseBytecode */
				{
					VM_LABEL(pushConstantFalseBytecode);
					{
						char *_sp;

						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin push: */
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), GIV(falseObj));
						local_stackPointer = _sp;
						/* end push: */
					}
				}
			}
			BREAK;
			CASE(79)
			{
				/* pushConstantNilBytecode */
				{
					VM_LABEL(pushConstantNilBytecode);
					{
						char *_sp;

						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin push: */
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), GIV(nilObj));
						local_stackPointer = _sp;
						/* end push: */
					}
				}
			}
			BREAK;
			CASE(80)
			{
				/* pushConstantZeroBytecode */
				{
					VM_LABEL(pushConstantZeroBytecode);
					{
						char *_sp;

						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin push: */
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), ConstZero);
						local_stackPointer = _sp;
						/* end push: */
					}
				}
			}
			BREAK;
			CASE(81)
			{
				/* pushConstantOneBytecode */
				{
					VM_LABEL(pushConstantOneBytecode);
					{
						char *_sp;

						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin push: */
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), ConstOne);
						local_stackPointer = _sp;
						/* end push: */
					}
				}
			}
			BREAK;
			CASE(82)
			{
				/* extPushPseudoVariable */
				{
					VM_LABEL(extPushPseudoVariable);
					{
						sqInt _objOop;
						sqInt _objOop2;
						char *_sp;
						sqInt _theThingToPush;

						switch (extB) {
							case 0:
							{
								/* begin ensureFrameIsMarried:SP: */
								if (((isMachineCodeIP(((usqInt) (unsignedLongAt(local_framePointer + FoxMethod)) )))
									 ? ((unsignedLongAt(local_framePointer + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
									 : (byteAt((local_framePointer + FoxIFrameFlags) + 2)) != 0)) {
									assert(isContext(frameContext(local_framePointer)));
									_theThingToPush = unsignedLongAt(local_framePointer + FoxThisContext);
									goto l25;
								}
								_theThingToPush = marryFrameSP(local_framePointer, local_stackPointer);
								l25:
								;
								/* end ensureFrameIsMarried:SP: */
							}
							break;
							case 1:
							{
								/* begin memoryActiveProcess */
								/* begin fetchPointer:ofObject: */
								/* begin fetchPointer:ofObject: */
								/* begin splObj: */
								/* begin fetchPointer:ofObject: */
								_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								/* end splObj: */
								_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								_theThingToPush = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								/* end memoryActiveProcess */
							}
							break;
							default:
							{
								goto respondToUnknownBytecode;
							}
						}
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin push: */
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _theThingToPush);
						local_stackPointer = _sp;
						/* end push: */
						extB = 0;
						numExtB = 0;
					}
				}
			}
			BREAK;
			CASE(83)
			{
				/* duplicateTopBytecode */
				{
					VM_LABEL(duplicateTopBytecode);
					{
						sqInt _object;
						char *_sp;

						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin push: */
						_object = unsignedLongAt(local_stackPointer);
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
						local_stackPointer = _sp;
						/* end push: */
					}
				}
			}
			BREAK;
			CASE(84)
			CASE(85)
			CASE(86)
			CASE(87)
			{
				/* unknownBytecode */
				{
					VM_LABEL(unknownBytecode);
					{
						/* goto respondToUnknownBytecode */
					}
				}
				respondToUnknownBytecode:
/* respondToUnknownBytecode */
				{
					VM_LABEL(respondToUnknownBytecode);
					{
						sqInt t0;
						int t2;
						int t3;
						sqInt _ourContext;
						char *_sp;
						char *_theFP;
						char *_theSP;

						if (SelectorUnknownBytecode < (numSlotsOf(GIV(specialObjectsOop)))) {
							/* begin fetchPointer:ofObject: */
							t0 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorUnknownBytecode ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
						} else {
							t0 = SelectorUnknownBytecode < (numSlotsOf(GIV(specialObjectsOop)));
						}
						GIV(messageSelector) = t0;
						t2 = GIV(messageSelector) == null;
						if (t2) {
							t3 = t2;
						} else {
							t3 = GIV(messageSelector) == GIV(nilObj);
						}
						if (t3) {
							error("Unknown bytecode");
						}
						/* begin ensureFrameIsMarried:SP: */
						_theFP = local_framePointer;
						_theSP = local_stackPointer;
						if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
							 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
							 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0)) {
							assert(isContext(frameContext(_theFP)));
							_ourContext = unsignedLongAt(_theFP + FoxThisContext);
							goto l460;
						}
						_ourContext = marryFrameSP(_theFP, _theSP);
						l460:
						;
						/* end ensureFrameIsMarried:SP: */
						local_instructionPointer -= 1;
						/* begin push: */
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _ourContext);
						local_stackPointer = _sp;
						/* end push: */
						GIV(argumentCount) = 0;
						goto normalSend;
					}
				}
			}
			BREAK;
			CASE(88)
			{
				/* returnReceiver */
				{
					VM_LABEL(returnReceiver);
					{
						/* begin receiver */
						localReturnValue = unsignedLongAt(local_framePointer + FoxIFReceiver);
						/* end receiver */
						/* goto commonReturn */
					}
				}
				commonReturn:
/* commonReturn */
				{
					VM_LABEL(commonReturn);
					{
						sqInt t17;
						sqInt _aMethodObj;
						sqInt _callerContextOrNil;
						sqInt _callerContextOrNil2;
						sqInt _callerContextOrNil3;
						char *_callerFP;
						sqInt _closure;
						sqInt _contextToReturnTo;
						sqInt _currentCtx;
						char *_frameToReturnTo;
						sqInt _home;
						StackPage *_newPage;
						sqInt _nextCntx;
						sqInt _objOop;
						sqInt _objOop2;
						sqInt _ourContext;
						sqInt _ourContext2;
						sqInt _ourContext3;
						sqInt _ourContext4;
						sqInt _senderOop;
						sqInt _senderOop2;
						char *_sp;
						char *_sp2;
						char *_sp22;
						char *_sp23;
						char *_sp24;
						char *_sp3;
						char *_sp32;
						char *_sp4;
						char *_sp5;
						char *_sp6;
						char *_theFP;
						char *_theFP2;
						char *_theFP3;
						char *_theFP4;
						char *_theFP5;
						char *_theFP6;
						StackPage *_thePage;
						StackPage *_thePage2;
						StackPage *_thePage3;
						StackPage *_thePage4;
						char *_theSP;
						char *_theSP2;
						char *_theSP3;
						char *_theSP4;
						sqInt _unwindContextOrNilOrZero;
						sqInt _valuePointer;
						sqInt _valuePointer2;

						_frameToReturnTo = ((char *) 0 );
						_theFP = ((char *) 0 );
						if (!((byteAt((local_framePointer + FoxIFrameFlags) + 3)) != 0)) {
							goto commonCallerReturn;
							goto l461;
						}
						/* begin writeBackHeadFramePointers */
						assert((local_framePointer - local_stackPointer) < (LargeContextSlots * BytesPerOop));
						assert(GIV(stackPage) == (mostRecentlyUsedPage()));
						assert(!(isFree(GIV(stackPage))));
						/* begin setHeadFP:andSP:inPage: */
						_theSP4 = local_stackPointer;
						assert(_theSP4 < local_framePointer);
						assert((_theSP4 < ((GIV(stackPage)->baseAddress))) && (_theSP4 > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
						assert((local_framePointer < ((GIV(stackPage)->baseAddress))) && (local_framePointer > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
						{
							(GIV(stackPage)->headFP = local_framePointer);
							(GIV(stackPage)->headSP = _theSP4);
						}
						/* end setHeadFP:andSP:inPage: */
						assert(pageListIsWellFormed());
						/* end writeBackHeadFramePointers */
						_closure = unsignedLongAt(local_framePointer + (frameStackedReceiverOffset(local_framePointer)));
						_home = null;
						while (_closure != GIV(nilObj)) {
							int t10;
							int t16;
							int t17;
							int t4;
							int t5;
							int t9;

							/* begin followField:ofObject: */
							/* begin fetchPointer:ofObject: */
							_objOop = unsignedLongAt((_closure + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureOuterContextIndex ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							t4 = (_objOop & (tagMask())) == 0;
							if (t4) {
								t5 = ((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
							} else {
								t5 = t4;
							}
							if (t5) {
								_objOop = fixFollowedFieldofObjectwithInitialValue(FullClosureOuterContextIndex, _closure, _objOop);
							}
							_home = _objOop;
							/* end followField:ofObject: */
							t9 = (_home & (tagMask())) == 0;
							if (t9) {
								t10 = ((longAt(_home)) & (classIndexMask())) == ClassMethodContextCompactIndex;
							} else {
								t10 = t9;
							}
							if (!t10) {
								/* begin sendCannotReturn: */
								/* begin ensureFrameIsMarried:SP: */
								_theFP2 = local_framePointer;
								_theSP = local_stackPointer;
								if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP2 + FoxMethod)) )))
									 ? ((unsignedLongAt(_theFP2 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
									 : (byteAt((_theFP2 + FoxIFrameFlags) + 2)) != 0)) {
									assert(isContext(frameContext(_theFP2)));
									_ourContext = unsignedLongAt(_theFP2 + FoxThisContext);
									goto l466;
								}
								_ourContext = marryFrameSP(_theFP2, _theSP);
								l466:
								;
								/* end ensureFrameIsMarried:SP: */
								/* begin push: */
								unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _ourContext);
								local_stackPointer = _sp;
								/* end push: */
								/* begin push: */
								unsignedLongAtput((_sp2 = local_stackPointer - BytesPerWord), localReturnValue);
								local_stackPointer = _sp2;
								/* end push: */
								/* begin splObj: */
								/* begin fetchPointer:ofObject: */
								GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorCannotReturn ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								/* end splObj: */
								GIV(argumentCount) = 1;
								goto normalSend;
								goto l496;
								l496:
								;
								/* end sendCannotReturn: */
								goto l461;
							}
							/* begin followField:ofObject: */
							/* begin fetchPointer:ofObject: */
							_objOop2 = unsignedLongAt((_home + BaseHeaderSize) + ((sqInt) (((usqInt) ClosureIndex ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							t16 = (_objOop2 & (tagMask())) == 0;
							if (t16) {
								t17 = ((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
							} else {
								t17 = t16;
							}
							if (t17) {
								_objOop2 = fixFollowedFieldofObjectwithInitialValue(ClosureIndex, _home, _objOop2);
							}
							_closure = _objOop2;
							/* end followField:ofObject: */
						}
						{
							GIV(framePointer) = local_framePointer;
							t17 = findUnwindThroughContext(_home);
							local_framePointer = GIV(framePointer);
						}
						_unwindContextOrNilOrZero = t17;
						if (_unwindContextOrNilOrZero == GIV(nilObj)) {
							/* begin sendCannotReturn: */
							/* begin ensureFrameIsMarried:SP: */
							_theFP3 = local_framePointer;
							_theSP2 = local_stackPointer;
							if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP3 + FoxMethod)) )))
								 ? ((unsignedLongAt(_theFP3 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
								 : (byteAt((_theFP3 + FoxIFrameFlags) + 2)) != 0)) {
								assert(isContext(frameContext(_theFP3)));
								_ourContext2 = unsignedLongAt(_theFP3 + FoxThisContext);
								goto l476;
							}
							_ourContext2 = marryFrameSP(_theFP3, _theSP2);
							l476:
							;
							/* end ensureFrameIsMarried:SP: */
							/* begin push: */
							unsignedLongAtput((_sp3 = local_stackPointer - BytesPerWord), _ourContext2);
							local_stackPointer = _sp3;
							/* end push: */
							/* begin push: */
							unsignedLongAtput((_sp22 = local_stackPointer - BytesPerWord), localReturnValue);
							local_stackPointer = _sp22;
							/* end push: */
							/* begin splObj: */
							/* begin fetchPointer:ofObject: */
							GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorCannotReturn ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							/* end splObj: */
							GIV(argumentCount) = 1;
							goto normalSend;
							goto l478;
							l478:
							;
							/* end sendCannotReturn: */
							goto l461;
						}
						if (_unwindContextOrNilOrZero != 0) {
							/* begin internalAboutToReturn:through: */
							/* begin ensureFrameIsMarried:SP: */
							if (((isMachineCodeIP(((usqInt) (unsignedLongAt(local_framePointer + FoxMethod)) )))
								 ? ((unsignedLongAt(local_framePointer + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
								 : (byteAt((local_framePointer + FoxIFrameFlags) + 2)) != 0)) {
								assert(isContext(frameContext(local_framePointer)));
								_ourContext3 = unsignedLongAt(local_framePointer + FoxThisContext);
								goto l492;
							}
							_ourContext3 = marryFrameSP(local_framePointer, local_stackPointer);
							l492:
							;
							/* end ensureFrameIsMarried:SP: */
							/* begin push: */
							unsignedLongAtput((_sp4 = local_stackPointer - BytesPerWord), _ourContext3);
							local_stackPointer = _sp4;
							/* end push: */
							/* begin push: */
							unsignedLongAtput((_sp23 = local_stackPointer - BytesPerWord), localReturnValue);
							local_stackPointer = _sp23;
							/* end push: */
							/* begin push: */
							unsignedLongAtput((_sp32 = local_stackPointer - BytesPerWord), _unwindContextOrNilOrZero);
							local_stackPointer = _sp32;
							/* end push: */
							/* begin splObj: */
							/* begin fetchPointer:ofObject: */
							GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorAboutToReturn ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							/* end splObj: */
							GIV(argumentCount) = 2;
							goto normalSend;
							goto l487;
							l487:
							;
							/* end internalAboutToReturn:through: */
							goto l461;
						}
						_contextToReturnTo = null;
						if ((((unsignedLongAt((_home + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
							assert(checkIsStillMarriedContextcurrentFP(_home, local_framePointer));
							/* begin frameOfMarriedContext: */
							/* begin fetchPointer:ofObject: */
							_senderOop = unsignedLongAt((_home + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							{
								assert(((_senderOop & 7) == 1));
								_theFP = pointerForOop(_senderOop - 1);
							}
							/* end frameOfMarriedContext: */
							if ((unsignedLongAt(_theFP + FoxSavedFP)) == 0) {
								/* begin frameCallerContext: */
								assert(isBaseFrame(_theFP));
								/* begin stackPageFor: */
								/* begin stackPageAt: */
								_thePage2 = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
								/* end stackPageAt: */
								/* end stackPageFor: */
								_callerContextOrNil = unsignedLongAt((_thePage2->baseAddress));
								assert(addressCouldBeObj(_callerContextOrNil));
								assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
								_contextToReturnTo = _callerContextOrNil;
								/* end frameCallerContext: */
							} else {
								_frameToReturnTo = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP));
							}
						} else {
							int t3;
							int t4;
							sqInt t5;

							/* begin fetchPointer:ofObject: */
							_contextToReturnTo = unsignedLongAt((_home + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							t3 = (_contextToReturnTo & (tagMask())) == 0;
							if (t3) {
								t4 = ((longAt(_contextToReturnTo)) & (classIndexMask())) == ClassMethodContextCompactIndex;
							} else {
								t4 = t3;
							}
							if (t4) {
								t5 = (((unsignedLongAt((_contextToReturnTo + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1);
							} else {
								t5 = t4;
							}
							if (t5) {
								assert(checkIsStillMarriedContextcurrentFP(_contextToReturnTo, local_framePointer));
								/* begin frameOfMarriedContext: */
								/* begin fetchPointer:ofObject: */
								_senderOop2 = unsignedLongAt((_contextToReturnTo + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								{
									assert(((_senderOop2 & 7) == 1));
									_frameToReturnTo = pointerForOop(_senderOop2 - 1);
								}
								/* end frameOfMarriedContext: */
								_contextToReturnTo = null;
							}
						}
						if (_contextToReturnTo != null) {
							char * t0;

							{
								GIV(framePointer) = local_framePointer;
								GIV(instructionPointer) = local_instructionPointer;
								GIV(stackPointer) = local_stackPointer;
								t0 = establishFrameForContextToReturnTo(_contextToReturnTo);
								local_framePointer = GIV(framePointer);
								local_instructionPointer = GIV(instructionPointer);
								local_stackPointer = GIV(stackPointer);
							}
							_frameToReturnTo = t0;
							if (_frameToReturnTo == 0) {
								/* begin sendCannotReturn: */
								/* begin ensureFrameIsMarried:SP: */
								_theFP4 = local_framePointer;
								_theSP3 = local_stackPointer;
								if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP4 + FoxMethod)) )))
									 ? ((unsignedLongAt(_theFP4 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
									 : (byteAt((_theFP4 + FoxIFrameFlags) + 2)) != 0)) {
									assert(isContext(frameContext(_theFP4)));
									_ourContext4 = unsignedLongAt(_theFP4 + FoxThisContext);
									goto l467;
								}
								_ourContext4 = marryFrameSP(_theFP4, _theSP3);
								l467:
								;
								/* end ensureFrameIsMarried:SP: */
								/* begin push: */
								unsignedLongAtput((_sp5 = local_stackPointer - BytesPerWord), _ourContext4);
								local_stackPointer = _sp5;
								/* end push: */
								/* begin push: */
								unsignedLongAtput((_sp24 = local_stackPointer - BytesPerWord), localReturnValue);
								local_stackPointer = _sp24;
								/* end push: */
								/* begin splObj: */
								/* begin fetchPointer:ofObject: */
								GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorCannotReturn ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								/* end splObj: */
								GIV(argumentCount) = 1;
								goto normalSend;
								goto l462;
								l462:
								;
								/* end sendCannotReturn: */
								goto l461;
							}
						}
						assert(pageListIsWellFormed());
						/* begin stackPageFor: */
						/* begin stackPageAt: */
						_newPage = stackPageAtpages((assert((((char *) _frameToReturnTo ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _frameToReturnTo ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_frameToReturnTo, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
						/* end stackPageAt: */
						/* end stackPageFor: */
						if (_newPage != GIV(stackPage)) {
							/* begin frameCallerContext: */
							_theFP6 = (GIV(stackPage)->baseFP);
							assert(isBaseFrame(_theFP6));
							/* begin stackPageFor: */
							/* begin stackPageAt: */
							_thePage4 = stackPageAtpages((assert((((char *) _theFP6 ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP6 ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP6, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
							/* end stackPageAt: */
							/* end stackPageFor: */
							_callerContextOrNil3 = unsignedLongAt((_thePage4->baseAddress));
							assert(addressCouldBeObj(_callerContextOrNil3));
							assert((_callerContextOrNil3 == (nilObject())) || (isContext(_callerContextOrNil3)));
							_currentCtx = _callerContextOrNil3;
							/* end frameCallerContext: */
							freeStackPage(GIV(stackPage));
							while (1) {
								sqInt t1;

								assert(isContext(_currentCtx));
								t1 = (((unsignedLongAt((_currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1);
								if (((t1)
									 ? (stackPageFor((_theFP = frameOfMarriedContext(_currentCtx)))) == _newPage
									 : 0)) 
									break;
								if ((((unsignedLongAt((_currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
									/* begin stackPageFor: */
									/* begin stackPageAt: */
									_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
									/* end stackPageAt: */
									/* end stackPageFor: */
									if (_theFP != ((_thePage->headFP))) {
										moveFramesInthroughtoPage(_thePage, findFrameAboveinPage(_theFP, _thePage), newStackPage());
									}
									/* begin frameCallerContext: */
									_theFP5 = (_thePage->baseFP);
									assert(isBaseFrame(_theFP5));
									/* begin stackPageFor: */
									/* begin stackPageAt: */
									_thePage3 = stackPageAtpages((assert((((char *) _theFP5 ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP5 ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP5, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
									/* end stackPageAt: */
									/* end stackPageFor: */
									_callerContextOrNil2 = unsignedLongAt((_thePage3->baseAddress));
									assert(addressCouldBeObj(_callerContextOrNil2));
									assert((_callerContextOrNil2 == (nilObject())) || (isContext(_callerContextOrNil2)));
									_currentCtx = _callerContextOrNil2;
									/* end frameCallerContext: */
									freeStackPage(_thePage);
								} else {
									/* begin fetchPointer:ofObject: */
									_nextCntx = unsignedLongAt((_currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									/* begin markContextAsDead: */
									assert(isContext(_currentCtx));
									{
										/* begin storePointerUnchecked:ofObject:withValue: */
										_valuePointer = GIV(nilObj);
										assert(!(isOopForwarded(_currentCtx)));
										longAtput((_currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), _valuePointer);
										/* end storePointerUnchecked:ofObject:withValue: */
										/* begin storePointerUnchecked:ofObject:withValue: */
										_valuePointer2 = GIV(nilObj);
										assert(!(isOopForwarded(_currentCtx)));
										longAtput((_currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), _valuePointer2);
										/* end storePointerUnchecked:ofObject:withValue: */
									}
									/* end markContextAsDead: */
									_currentCtx = _nextCntx;
								}
							}
							/* begin setStackPageAndLimit: */
							assert(_newPage != 0);
							GIV(stackPage) = _newPage;
							if (GIV(stackLimit) != ((char *) ((usqInt) -1 ) )) {
								GIV(stackLimit) = (GIV(stackPage)->stackLimit);
							}
							markStackPageMostRecentlyUsed(_newPage);
							/* end setStackPageAndLimit: */
							local_stackPointer = (GIV(stackPage)->headSP);
							local_framePointer = (GIV(stackPage)->headFP);
						}
						if (local_framePointer == _frameToReturnTo) {
							local_instructionPointer = pointerForOop(unsignedLongAt(local_stackPointer));
						} else {
							do {
								_callerFP = local_framePointer;
								local_framePointer = pointerForOop(unsignedLongAt(local_framePointer + FoxSavedFP));
							} while (local_framePointer != _frameToReturnTo);
							local_instructionPointer = pointerForOop(unsignedLongAt(_callerFP + FoxCallerSavedIP));
							local_stackPointer = ((assert(!(isBaseFrame(_callerFP))), (_callerFP + (frameStackedReceiverOffset(_callerFP))) + BytesPerWord)) - BytesPerWord;
						}
						/* begin maybeReturnToMachineCodeFrame */
						if (((usqInt) ((usqInt) local_instructionPointer ) ) < (startOfObjectMemory(getMemoryMap()))) {
							if (((usqInt) local_instructionPointer ) != (ceReturnToInterpreterPC())) {
								/* begin returnToMachineCodeFrame */
								assertCStackWellAligned();
								assert(!(isInstructionPointerInInterpreter(local_instructionPointer)));
								assert(isMachineCodeFrame(local_framePointer));
								assertValidExecutionPointersimbarline(((usqInt) local_instructionPointer ), local_framePointer, local_stackPointer, 0, __LINE__);
								unsignedLongAtput(local_stackPointer, local_instructionPointer);
								/* begin push: */
								unsignedLongAtput((_sp6 = local_stackPointer - BytesPerWord), localReturnValue);
								local_stackPointer = _sp6;
								/* end push: */
								/* begin callEnilopmart: */
								{
									GIV(framePointer) = local_framePointer;
									GIV(instructionPointer) = local_instructionPointer;
									GIV(stackPointer) = local_stackPointer;
									ceEnterCogCodePopReceiverReg();
									local_framePointer = GIV(framePointer);
									local_instructionPointer = GIV(instructionPointer);
									local_stackPointer = GIV(stackPointer);
								}
								/* end callEnilopmart: */
								{
									assert(0);
								}
								/* end returnToMachineCodeFrame */
								goto l493;
							}
							local_instructionPointer = pointerForOop(unsignedLongAt(local_framePointer + FoxIFSavedIP));
						}
						l493:
						;
						/* end maybeReturnToMachineCodeFrame */
						/* begin setMethod: */
						_aMethodObj = unsignedLongAt(local_framePointer + FoxMethod);
						assert(((usqInt) _aMethodObj ) >= (startOfObjectMemory(getMemoryMap())));
						{
							GIV(method) = _aMethodObj;
							assert(isOopCompiledMethod(GIV(method)));
						}
						/* end setMethod: */
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						unsignedLongAtput(local_stackPointer, localReturnValue);
					}
				}
				l461:
				;
				/* end case */
			}
			BREAK;
			CASE(89)
			{
				/* returnTrue */
				{
					VM_LABEL(returnTrue);
					{
						/* begin trueObject */
						localReturnValue = GIV(trueObj);
						/* end trueObject */
						goto commonReturn;
					}
				}
			}
			BREAK;
			CASE(90)
			{
				/* returnFalse */
				{
					VM_LABEL(returnFalse);
					{
						/* begin falseObject */
						localReturnValue = GIV(falseObj);
						/* end falseObject */
						goto commonReturn;
					}
				}
			}
			BREAK;
			CASE(91)
			{
				/* returnNil */
				{
					VM_LABEL(returnNil);
					{
						/* begin nilObject */
						localReturnValue = GIV(nilObj);
						/* end nilObject */
						goto commonReturn;
					}
				}
			}
			BREAK;
			CASE(92)
			{
				/* returnTopFromMethod */
				{
					VM_LABEL(returnTopFromMethod);
					{
						localReturnValue = unsignedLongAt(local_stackPointer);
						goto commonReturn;
					}
				}
			}
			BREAK;
			CASE(93)
			{
				/* returnNilFromBlock */
				{
					VM_LABEL(returnNilFromBlock);
					{
						/* begin nilObject */
						localReturnValue = GIV(nilObj);
						/* end nilObject */
						goto commonCallerReturn;
					}
				}
			}
			BREAK;
			CASE(94)
			{
				/* returnTopFromBlock */
				{
					VM_LABEL(returnTopFromBlock);
					{
						localReturnValue = unsignedLongAt(local_stackPointer);
						/* goto commonCallerReturn */
					}
				}
				commonCallerReturn:
/* commonCallerReturn */
				{
					VM_LABEL(commonCallerReturn);
					{
						sqInt _aMethodObj;
						sqInt _aMethodObj2;
						sqInt _callerContextOrNil;
						char *_callerFP;
						char *_callersFPOrNull;
						sqInt _contextToReturnFrom;
						sqInt _contextToReturnTo;
						char *_fp;
						char *_frameAbove;
						StackPage *_lruOrFree;
						StackPage *_newPage;
						sqInt _retToContext;
						sqInt _senderOop;
						char *_sp;
						char *_sp2;
						char *_sp3;
						char *_sp4;
						char *_sp5;
						char *_theFP;
						StackPage *_thePage;
						StackPage *_thePage2;
						char *_theSP;

						_callersFPOrNull = pointerForOop(unsignedLongAt(local_framePointer + FoxSavedFP));
						if (_callersFPOrNull == 0) {
							int t16;
							int t17;
							int t20;

							assert(local_framePointer == ((GIV(stackPage)->baseFP)));
							/* begin baseFrameReturn */
							/* begin frameCallerContext: */
							assert(isBaseFrame(local_framePointer));
							/* begin stackPageFor: */
							/* begin stackPageAt: */
							_thePage2 = stackPageAtpages((assert((((char *) local_framePointer ) >= (GIV(stackBasePlus1) - 1)) && (((char *) local_framePointer ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(local_framePointer, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
							/* end stackPageAt: */
							/* end stackPageFor: */
							_callerContextOrNil = unsignedLongAt((_thePage2->baseAddress));
							assert(addressCouldBeObj(_callerContextOrNil));
							assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
							_contextToReturnTo = _callerContextOrNil;
							/* end frameCallerContext: */
							freeStackPageNoAssert(GIV(stackPage));
							/* begin isContext: */
							t16 = (_contextToReturnTo & (tagMask())) == 0;
							if (t16) {
								t17 = ((longAt(_contextToReturnTo)) & (classIndexMask())) == ClassMethodContextCompactIndex;
							} else {
								t17 = t16;
							}
							_retToContext = t17;
							/* end isContext: */
							if (_retToContext) {
								sqInt t0;

								t0 = (((unsignedLongAt((_contextToReturnTo + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1);
								if (t0) {
									t20 = !(isWidowedContext(_contextToReturnTo));
								} else {
									t20 = t0;
								}
							} else {
								t20 = _retToContext;
							}
							if (t20) {
								/* begin frameOfMarriedContext: */
								/* begin fetchPointer:ofObject: */
								_senderOop = unsignedLongAt((_contextToReturnTo + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								{
									assert(((_senderOop & 7) == 1));
									_theFP = pointerForOop(_senderOop - 1);
								}
								/* end frameOfMarriedContext: */
								/* begin stackPageFor: */
								/* begin stackPageAt: */
								_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
								/* end stackPageAt: */
								/* end stackPageFor: */
								if (!(_theFP == ((_thePage->headFP)))) {
									/* begin findFrameAbove:inPage: */
									_fp = (_thePage->headFP);
									if (_fp == _theFP) {
										_frameAbove = 0;
										goto l511;
									}
									while (((_callerFP = pointerForOop(unsignedLongAt(_fp + FoxSavedFP)))) != 0) {
										if (_callerFP == _theFP) {
											_frameAbove = _fp;
											goto l511;
										}
										_fp = _callerFP;
									}
									error("did not find theFP in stack page");
									_frameAbove = 0;
									l511:
									;
									/* end findFrameAbove:inPage: */
									/* begin newStackPage */
									_lruOrFree = (GIV(mostRecentlyUsedPage)->nextPage);
									if (((_lruOrFree->baseFP)) == 0) {
										_newPage = _lruOrFree;
										goto l508;
									}
									divorceFramesIn(_lruOrFree);
									_newPage = _lruOrFree;
									l508:
									;
									/* end newStackPage */
									assert(_newPage == GIV(stackPage));
									moveFramesInthroughtoPage(_thePage, _frameAbove, _newPage);
									markStackPageMostRecentlyUsed(_newPage);
									_theFP = (_thePage->headFP);
								}
							} else {
								sqInt t0;
								StackPage * t2;

								if (_retToContext) {
									t0 = (((unsignedLongAt((_contextToReturnTo + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ))) & 7) == 1);
								} else {
									t0 = _retToContext;
								}
								if (!t0) {
									sqInt t16;

									/* begin baseFrameCannotReturnTo: */
									_contextToReturnFrom = longAt(((GIV(stackPage)->baseAddress)) - BytesPerWord);
									{
										GIV(framePointer) = local_framePointer;
										GIV(instructionPointer) = local_instructionPointer;
										GIV(stackPointer) = local_stackPointer;
										tearDownAndRebuildFrameForCannotReturnBaseFrameReturnFromtoreturnValue(_contextToReturnFrom, _contextToReturnTo, localReturnValue);
										local_framePointer = GIV(framePointer);
										local_instructionPointer = GIV(instructionPointer);
										local_stackPointer = GIV(stackPointer);
									}
									/* begin externalCannotReturn:from: */
									/* begin push: */
									unsignedLongAtput((_sp5 = local_stackPointer - BytesPerWord), _contextToReturnFrom);
									local_stackPointer = _sp5;
									/* end push: */
									/* begin push: */
									unsignedLongAtput((_sp2 = local_stackPointer - BytesPerWord), localReturnValue);
									local_stackPointer = _sp2;
									/* end push: */
									/* begin push: */
									unsignedLongAtput((_sp3 = local_stackPointer - BytesPerWord), local_instructionPointer);
									local_stackPointer = _sp3;
									/* end push: */
									t16 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorCannotReturn ) << (shiftForWord())) ));
									{
										GIV(framePointer) = local_framePointer;
										GIV(instructionPointer) = local_instructionPointer;
										GIV(stackPointer) = local_stackPointer;
										ceSendAborttonumArgs(t16, _contextToReturnFrom, 1);
										local_framePointer = GIV(framePointer);
										local_instructionPointer = GIV(instructionPointer);
										local_stackPointer = GIV(stackPointer);
									}
									/* end externalCannotReturn:from: */
									/* end baseFrameCannotReturnTo: */
									goto l512;
								}
								{
									GIV(framePointer) = local_framePointer;
									GIV(instructionPointer) = local_instructionPointer;
									GIV(stackPointer) = local_stackPointer;
									t2 = makeBaseFrameFor(_contextToReturnTo);
									local_framePointer = GIV(framePointer);
									local_instructionPointer = GIV(instructionPointer);
									local_stackPointer = GIV(stackPointer);
								}
								_thePage = t2;
								_theFP = (_thePage->headFP);
							}
							_theSP = (_thePage->headSP);
							/* begin setStackPageAndLimit: */
							assert(_thePage != 0);
							GIV(stackPage) = _thePage;
							if (GIV(stackLimit) != ((char *) ((usqInt) -1 ) )) {
								GIV(stackLimit) = (GIV(stackPage)->stackLimit);
							}
							markStackPageMostRecentlyUsed(_thePage);
							/* end setStackPageAndLimit: */
							assert((stackPageFor(_theFP)) == GIV(stackPage));
							local_stackPointer = _theSP;
							local_framePointer = _theFP;
							local_instructionPointer = pointerForOop(unsignedLongAt(local_stackPointer));
							/* begin maybeReturnToMachineCodeFrame */
							if (((usqInt) ((usqInt) local_instructionPointer ) ) < (startOfObjectMemory(getMemoryMap()))) {
								if (((usqInt) local_instructionPointer ) != (ceReturnToInterpreterPC())) {
									/* begin returnToMachineCodeFrame */
									assertCStackWellAligned();
									assert(!(isInstructionPointerInInterpreter(local_instructionPointer)));
									assert(isMachineCodeFrame(local_framePointer));
									assertValidExecutionPointersimbarline(((usqInt) local_instructionPointer ), local_framePointer, local_stackPointer, 0, __LINE__);
									unsignedLongAtput(local_stackPointer, local_instructionPointer);
									/* begin push: */
									unsignedLongAtput((_sp4 = local_stackPointer - BytesPerWord), localReturnValue);
									local_stackPointer = _sp4;
									/* end push: */
									/* begin callEnilopmart: */
									{
										GIV(framePointer) = local_framePointer;
										GIV(instructionPointer) = local_instructionPointer;
										GIV(stackPointer) = local_stackPointer;
										ceEnterCogCodePopReceiverReg();
										local_framePointer = GIV(framePointer);
										local_instructionPointer = GIV(instructionPointer);
										local_stackPointer = GIV(stackPointer);
									}
									/* end callEnilopmart: */
									{
										assert(0);
									}
									/* end returnToMachineCodeFrame */
									goto l509;
								}
								local_instructionPointer = pointerForOop(unsignedLongAt(local_framePointer + FoxIFSavedIP));
							}
							l509:
							;
							/* end maybeReturnToMachineCodeFrame */
							assert(checkIsStillMarriedContextcurrentFP(_contextToReturnTo, local_framePointer));
							/* begin setMethod: */
							_aMethodObj2 = unsignedLongAt(local_framePointer + FoxMethod);
							assert(((usqInt) _aMethodObj2 ) >= (startOfObjectMemory(getMemoryMap())));
							{
								GIV(method) = _aMethodObj2;
								assert(isOopCompiledMethod(GIV(method)));
							}
							/* end setMethod: */
							unsignedLongAtput(local_stackPointer, localReturnValue);
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							goto l512;
							l512:
							;
							/* end baseFrameReturn */
							goto l497;
						}
						local_instructionPointer = pointerForOop(unsignedLongAt(local_framePointer + FoxCallerSavedIP));
						local_stackPointer = local_framePointer + (frameStackedReceiverOffsetNumArgs(((isMachineCodeIP(((usqInt) (unsignedLongAt(local_framePointer + FoxMethod)) )))
							 ? ((((CogMethod *) ((unsignedLongAt(local_framePointer + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
							 : byteAt((local_framePointer + FoxIFrameFlags) + 1))));
						local_framePointer = _callersFPOrNull;
						/* begin maybeReturnToMachineCodeFrame */
						if (((usqInt) ((usqInt) local_instructionPointer ) ) < (startOfObjectMemory(getMemoryMap()))) {
							if (((usqInt) local_instructionPointer ) != (ceReturnToInterpreterPC())) {
								/* begin returnToMachineCodeFrame */
								assertCStackWellAligned();
								assert(!(isInstructionPointerInInterpreter(local_instructionPointer)));
								assert(isMachineCodeFrame(local_framePointer));
								assertValidExecutionPointersimbarline(((usqInt) local_instructionPointer ), local_framePointer, local_stackPointer, 0, __LINE__);
								unsignedLongAtput(local_stackPointer, local_instructionPointer);
								/* begin push: */
								unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), localReturnValue);
								local_stackPointer = _sp;
								/* end push: */
								/* begin callEnilopmart: */
								{
									GIV(framePointer) = local_framePointer;
									GIV(instructionPointer) = local_instructionPointer;
									GIV(stackPointer) = local_stackPointer;
									ceEnterCogCodePopReceiverReg();
									local_framePointer = GIV(framePointer);
									local_instructionPointer = GIV(instructionPointer);
									local_stackPointer = GIV(stackPointer);
								}
								/* end callEnilopmart: */
								{
									assert(0);
								}
								/* end returnToMachineCodeFrame */
								goto l510;
							}
							local_instructionPointer = pointerForOop(unsignedLongAt(local_framePointer + FoxIFSavedIP));
						}
						l510:
						;
						/* end maybeReturnToMachineCodeFrame */
						/* begin setMethod: */
						_aMethodObj = unsignedLongAt(local_framePointer + FoxMethod);
						assert(((usqInt) _aMethodObj ) >= (startOfObjectMemory(getMemoryMap())));
						{
							GIV(method) = _aMethodObj;
							assert(isOopCompiledMethod(GIV(method)));
						}
						/* end setMethod: */
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						unsignedLongAtput(local_stackPointer, localReturnValue);
					}
				}
				l497:
				;
				/* end case */
			}
			BREAK;
			CASE(95)
			{
				/* extNopBytecode */
				{
					VM_LABEL(extNopBytecode);
					{
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						numExtB = (extA = (extB = 0));
					}
				}
			}
			BREAK;
			CASE(96)
			{
				/* bytecodePrimAdd */
				{
					VM_LABEL(bytecodePrimAdd);
					{
						sqInt _arg;
						double _arg2;
						usqLong _bits;
						usqLong _bits2;
						sqInt _objOop;
						sqInt _rcvr;
						double _rcvr2;
						sqInt _result;
						double _result2;
						double _result3;
						usqLong _rot;
						usqLong _rot2;
						sqInt _shift;
						sqInt _shift2;
						char *_sp;
						char *_sp2;
						sqInt _tagBits;
						sqInt _tagBits2;
						double _value;
						double _value2;

						_result2 = 0;
						_result3 = 0;
						_value = 0;
						_value2 = 0;
						_rcvr = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						_arg = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
						if ((_rcvr & _arg) & (smallIntegerTag())) {
							_result = (_rcvr >> 3) + (_arg >> 3);
							if ((((((usqInt) _result ) >> 60) + 1) & 15) <= 1) {
								/* begin pop:thenPush: */
								unsignedLongAtput((_sp = local_stackPointer + ((2 - 1) * BytesPerWord)), ((((usqInt) _result ) << 3) | 1));
								local_stackPointer = _sp;
								/* end pop:thenPush: */
								/* begin fetchNextBytecode */
								/* begin fetchByte */
								currentBytecode = byteAtPointer(++local_instructionPointer);
								/* end fetchByte */
								/* end fetchNextBytecode */
								goto l36;
							}
						} else {
							/* begin initPrimCall */
							GIV(primFailCode) = 0;
							/* end initPrimCall */
							/* begin primitiveFloatAdd:toArg: */
							/* begin loadFloatOrIntFrom: */
							if (((_tagBits = _rcvr & (tagMask()))) != 0) {
								int t1;
								int t2;

								if (_tagBits == (smallFloatTag())) {
									/* begin smallFloatValueOf: */
									/* begin smallFloatBitsOf: */
									assert(isImmediateFloat(_rcvr));
									_rot = ((usqInt) ((usqInt) _rcvr ) ) >> (numTagBits());
									if (_rot > 1) {
										_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
									}
									/* begin rotateRight: */
									_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
									/* end rotateRight: */
									_bits = _rot;
									/* end smallFloatBitsOf: */
									{
										memcpy(&_value, &_bits, sizeof(_value));
										_rcvr2 = _value;
										goto l40;
									}
									_rcvr2 = null;
									goto l40;
									/* end smallFloatValueOf: */
								}
								t1 = _tagBits == (smallIntegerTag());
								if (t1) {
									_shift = (64 - (numTagBits())) - (smallFloatMantissaBits());
									t2 = (((sqInt) ((sqInt) (((usqInt) _rcvr ) << _shift) ) ) >> _shift) == _rcvr;
								} else {
									t2 = t1;
								}
								if (t2) {
									_rcvr2 = ((double) (_rcvr >> 3) );
									goto l40;
								}
							} else {
								if (((longAt(_rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
									fetchFloatAtinto(_rcvr + BaseHeaderSize, _result3);
									_rcvr2 = _result3;
									goto l40;
								}
							}
							/* begin primitiveFail */
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
							/* end primitiveFail */
							_rcvr2 = 0.0;
							l40:
							;
							/* end loadFloatOrIntFrom: */
							/* begin loadFloatOrIntFrom: */
							if (((_tagBits2 = _arg & (tagMask()))) != 0) {
								int t1;
								int t2;

								if (_tagBits2 == (smallFloatTag())) {
									/* begin smallFloatValueOf: */
									/* begin smallFloatBitsOf: */
									assert(isImmediateFloat(_arg));
									_rot2 = ((usqInt) ((usqInt) _arg ) ) >> (numTagBits());
									if (_rot2 > 1) {
										_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
									}
									/* begin rotateRight: */
									_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
									/* end rotateRight: */
									_bits2 = _rot2;
									/* end smallFloatBitsOf: */
									{
										memcpy(&_value2, &_bits2, sizeof(_value2));
										_arg2 = _value2;
										goto l45;
									}
									_arg2 = null;
									goto l45;
									/* end smallFloatValueOf: */
								}
								t1 = _tagBits2 == (smallIntegerTag());
								if (t1) {
									_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits());
									t2 = (((sqInt) ((sqInt) (((usqInt) _arg ) << _shift2) ) ) >> _shift2) == _arg;
								} else {
									t2 = t1;
								}
								if (t2) {
									_arg2 = ((double) (_arg >> 3) );
									goto l45;
								}
							} else {
								if (((longAt(_arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
									fetchFloatAtinto(_arg + BaseHeaderSize, _result2);
									_arg2 = _result2;
									goto l45;
								}
							}
							/* begin primitiveFail */
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
							/* end primitiveFail */
							_arg2 = 0.0;
							l45:
							;
							/* end loadFloatOrIntFrom: */
							if (!GIV(primFailCode)) {
								/* begin pop:thenPushFloat: */
								unsignedLongAtput((_sp2 = local_stackPointer + ((2 - 1) * BytesPerWord)), floatObjectOf(_rcvr2 + _arg2));
								local_stackPointer = _sp2;
								/* end pop:thenPushFloat: */
							}
							/* end primitiveFloatAdd:toArg: */
							if (!GIV(primFailCode)) {
								/* begin fetchNextBytecode */
								/* begin fetchByte */
								currentBytecode = byteAtPointer(++local_instructionPointer);
								/* end fetchByte */
								/* end fetchNextBytecode */
								goto l36;
							}
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (0 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
				l36:
				;
				/* end case */
			}
			BREAK;
			CASE(97)
			{
				/* bytecodePrimSubtract */
				{
					VM_LABEL(bytecodePrimSubtract);
					{
						sqInt _arg;
						double _arg2;
						usqLong _bits;
						usqLong _bits2;
						sqInt _objOop;
						sqInt _rcvr;
						double _rcvr2;
						sqInt _result;
						double _result2;
						double _result3;
						usqLong _rot;
						usqLong _rot2;
						sqInt _shift;
						sqInt _shift2;
						char *_sp;
						char *_sp2;
						sqInt _tagBits;
						sqInt _tagBits2;
						double _value;
						double _value2;

						_result2 = 0;
						_result3 = 0;
						_value = 0;
						_value2 = 0;
						_rcvr = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						_arg = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
						if ((_rcvr & _arg) & (smallIntegerTag())) {
							_result = (_rcvr >> 3) - (_arg >> 3);
							if ((((((usqInt) _result ) >> 60) + 1) & 15) <= 1) {
								/* begin pop:thenPush: */
								unsignedLongAtput((_sp = local_stackPointer + ((2 - 1) * BytesPerWord)), ((((usqInt) _result ) << 3) | 1));
								local_stackPointer = _sp;
								/* end pop:thenPush: */
								/* begin fetchNextBytecode */
								/* begin fetchByte */
								currentBytecode = byteAtPointer(++local_instructionPointer);
								/* end fetchByte */
								/* end fetchNextBytecode */
								goto l47;
							}
						} else {
							/* begin initPrimCall */
							GIV(primFailCode) = 0;
							/* end initPrimCall */
							/* begin primitiveFloatSubtract:fromArg: */
							/* begin loadFloatOrIntFrom: */
							if (((_tagBits = _rcvr & (tagMask()))) != 0) {
								int t1;
								int t2;

								if (_tagBits == (smallFloatTag())) {
									/* begin smallFloatValueOf: */
									/* begin smallFloatBitsOf: */
									assert(isImmediateFloat(_rcvr));
									_rot = ((usqInt) ((usqInt) _rcvr ) ) >> (numTagBits());
									if (_rot > 1) {
										_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
									}
									/* begin rotateRight: */
									_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
									/* end rotateRight: */
									_bits = _rot;
									/* end smallFloatBitsOf: */
									{
										memcpy(&_value, &_bits, sizeof(_value));
										_rcvr2 = _value;
										goto l51;
									}
									_rcvr2 = null;
									goto l51;
									/* end smallFloatValueOf: */
								}
								t1 = _tagBits == (smallIntegerTag());
								if (t1) {
									_shift = (64 - (numTagBits())) - (smallFloatMantissaBits());
									t2 = (((sqInt) ((sqInt) (((usqInt) _rcvr ) << _shift) ) ) >> _shift) == _rcvr;
								} else {
									t2 = t1;
								}
								if (t2) {
									_rcvr2 = ((double) (_rcvr >> 3) );
									goto l51;
								}
							} else {
								if (((longAt(_rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
									fetchFloatAtinto(_rcvr + BaseHeaderSize, _result3);
									_rcvr2 = _result3;
									goto l51;
								}
							}
							/* begin primitiveFail */
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
							/* end primitiveFail */
							_rcvr2 = 0.0;
							l51:
							;
							/* end loadFloatOrIntFrom: */
							/* begin loadFloatOrIntFrom: */
							if (((_tagBits2 = _arg & (tagMask()))) != 0) {
								int t1;
								int t2;

								if (_tagBits2 == (smallFloatTag())) {
									/* begin smallFloatValueOf: */
									/* begin smallFloatBitsOf: */
									assert(isImmediateFloat(_arg));
									_rot2 = ((usqInt) ((usqInt) _arg ) ) >> (numTagBits());
									if (_rot2 > 1) {
										_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
									}
									/* begin rotateRight: */
									_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
									/* end rotateRight: */
									_bits2 = _rot2;
									/* end smallFloatBitsOf: */
									{
										memcpy(&_value2, &_bits2, sizeof(_value2));
										_arg2 = _value2;
										goto l56;
									}
									_arg2 = null;
									goto l56;
									/* end smallFloatValueOf: */
								}
								t1 = _tagBits2 == (smallIntegerTag());
								if (t1) {
									_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits());
									t2 = (((sqInt) ((sqInt) (((usqInt) _arg ) << _shift2) ) ) >> _shift2) == _arg;
								} else {
									t2 = t1;
								}
								if (t2) {
									_arg2 = ((double) (_arg >> 3) );
									goto l56;
								}
							} else {
								if (((longAt(_arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
									fetchFloatAtinto(_arg + BaseHeaderSize, _result2);
									_arg2 = _result2;
									goto l56;
								}
							}
							/* begin primitiveFail */
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
							/* end primitiveFail */
							_arg2 = 0.0;
							l56:
							;
							/* end loadFloatOrIntFrom: */
							if (!GIV(primFailCode)) {
								/* begin pop:thenPushFloat: */
								unsignedLongAtput((_sp2 = local_stackPointer + ((2 - 1) * BytesPerWord)), floatObjectOf(_rcvr2 - _arg2));
								local_stackPointer = _sp2;
								/* end pop:thenPushFloat: */
							}
							/* end primitiveFloatSubtract:fromArg: */
							if (!GIV(primFailCode)) {
								/* begin fetchNextBytecode */
								/* begin fetchByte */
								currentBytecode = byteAtPointer(++local_instructionPointer);
								/* end fetchByte */
								/* end fetchNextBytecode */
								goto l47;
							}
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (1 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
				l47:
				;
				/* end case */
			}
			BREAK;
			CASE(98)
			{
				/* bytecodePrimLessThanSistaV1 */
				{
					VM_LABEL(bytecodePrimLessThanSistaV1);
					{
						sqInt _aBool;
						sqInt _arg;
						double _arg2;
						usqLong _bits;
						usqLong _bits2;
						sqInt _objOop;
						sqInt _rcvr;
						double _rcvr2;
						double _result;
						double _result2;
						usqLong _rot;
						usqLong _rot2;
						sqInt _shift;
						sqInt _shift2;
						sqInt _tagBits;
						sqInt _tagBits2;
						double _value;
						double _value2;

						_result = 0;
						_result2 = 0;
						_value = 0;
						_value2 = 0;
						_rcvr = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						_arg = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
						if ((_rcvr & _arg) & (smallIntegerTag())) {
							/* begin booleanCheatSistaV1: */
							if (_rcvr < _arg) {
								/* goto booleanCheatTrueSistaV1 */
							} else {
								goto booleanCheatFalseSistaV1;
							}
							/* end booleanCheatSistaV1: */
							goto l58;
						}
						/* begin initPrimCall */
						GIV(primFailCode) = 0;
						/* end initPrimCall */
						/* begin primitiveFloatLess:thanArg: */
						/* begin loadFloatOrIntFrom: */
						if (((_tagBits = _rcvr & (tagMask()))) != 0) {
							int t1;
							int t2;

							if (_tagBits == (smallFloatTag())) {
								/* begin smallFloatValueOf: */
								/* begin smallFloatBitsOf: */
								assert(isImmediateFloat(_rcvr));
								_rot = ((usqInt) ((usqInt) _rcvr ) ) >> (numTagBits());
								if (_rot > 1) {
									_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
								}
								/* begin rotateRight: */
								_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
								/* end rotateRight: */
								_bits = _rot;
								/* end smallFloatBitsOf: */
								{
									memcpy(&_value, &_bits, sizeof(_value));
									_rcvr2 = _value;
									goto l59;
								}
								_rcvr2 = null;
								goto l59;
								/* end smallFloatValueOf: */
							}
							t1 = _tagBits == (smallIntegerTag());
							if (t1) {
								_shift = (64 - (numTagBits())) - (smallFloatMantissaBits());
								t2 = (((sqInt) ((sqInt) (((usqInt) _rcvr ) << _shift) ) ) >> _shift) == _rcvr;
							} else {
								t2 = t1;
							}
							if (t2) {
								_rcvr2 = ((double) (_rcvr >> 3) );
								goto l59;
							}
						} else {
							if (((longAt(_rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(_rcvr + BaseHeaderSize, _result);
								_rcvr2 = _result;
								goto l59;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						_rcvr2 = 0.0;
						l59:
						;
						/* end loadFloatOrIntFrom: */
						/* begin loadFloatOrIntFrom: */
						if (((_tagBits2 = _arg & (tagMask()))) != 0) {
							int t1;
							int t2;

							if (_tagBits2 == (smallFloatTag())) {
								/* begin smallFloatValueOf: */
								/* begin smallFloatBitsOf: */
								assert(isImmediateFloat(_arg));
								_rot2 = ((usqInt) ((usqInt) _arg ) ) >> (numTagBits());
								if (_rot2 > 1) {
									_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
								}
								/* begin rotateRight: */
								_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
								/* end rotateRight: */
								_bits2 = _rot2;
								/* end smallFloatBitsOf: */
								{
									memcpy(&_value2, &_bits2, sizeof(_value2));
									_arg2 = _value2;
									goto l62;
								}
								_arg2 = null;
								goto l62;
								/* end smallFloatValueOf: */
							}
							t1 = _tagBits2 == (smallIntegerTag());
							if (t1) {
								_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits());
								t2 = (((sqInt) ((sqInt) (((usqInt) _arg ) << _shift2) ) ) >> _shift2) == _arg;
							} else {
								t2 = t1;
							}
							if (t2) {
								_arg2 = ((double) (_arg >> 3) );
								goto l62;
							}
						} else {
							if (((longAt(_arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(_arg + BaseHeaderSize, _result2);
								_arg2 = _result2;
								goto l62;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						_arg2 = 0.0;
						l62:
						;
						/* end loadFloatOrIntFrom: */
						_aBool = _rcvr2 < _arg2;
						/* end primitiveFloatLess:thanArg: */
						if (!GIV(primFailCode)) {
							/* begin booleanCheatSistaV1: */
							if (_aBool) {
								goto booleanCheatTrueSistaV1;
							} else {
								goto booleanCheatFalseSistaV1;
							}
							/* end booleanCheatSistaV1: */
							goto l58;
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (2 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
				l58:
				;
				/* end case */
				booleanCheatTrueSistaV1:
/* booleanCheatTrueSistaV1 */
				{
					VM_LABEL(booleanCheatTrueSistaV1);
					{
						sqInt _bytecode;
						sqInt _offset;
						char *_sp;

						_bytecode = byteAtPointer(++local_instructionPointer);
						/* begin pop: */
						local_stackPointer += 2 * BytesPerWord;
						/* end pop: */
						if (_bytecode >= 192) {
							if (_bytecode <= 199) {
								/* begin fetchNextBytecode */
								/* begin fetchByte */
								currentBytecode = byteAtPointer(++local_instructionPointer);
								/* end fetchByte */
								/* end fetchNextBytecode */
								goto l514;
							}
							if (_bytecode == 239) {
								byteAtPointer(++local_instructionPointer);
								/* begin fetchNextBytecode */
								/* begin fetchByte */
								currentBytecode = byteAtPointer(++local_instructionPointer);
								/* end fetchByte */
								/* end fetchNextBytecode */
								goto l514;
							}
							if (_bytecode == 238) {
								_offset = byteAtPointer(++local_instructionPointer);
								/* begin jump: */
								local_instructionPointer = (local_instructionPointer + _offset) + 1;
								currentBytecode = byteAtPointer(local_instructionPointer);
								/* end jump: */
								goto l514;
							}
						}
						currentBytecode = _bytecode;
						/* begin push: */
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), GIV(trueObj));
						local_stackPointer = _sp;
						/* end push: */
					}
				}
				l514:
				;
				/* end case */
			}
			BREAK;
			CASE(99)
			{
				/* bytecodePrimGreaterThanSistaV1 */
				{
					VM_LABEL(bytecodePrimGreaterThanSistaV1);
					{
						sqInt _aBool;
						sqInt _arg;
						double _arg2;
						usqLong _bits;
						usqLong _bits2;
						sqInt _objOop;
						sqInt _rcvr;
						double _rcvr2;
						double _result;
						double _result2;
						usqLong _rot;
						usqLong _rot2;
						sqInt _shift;
						sqInt _shift2;
						sqInt _tagBits;
						sqInt _tagBits2;
						double _value;
						double _value2;

						_result = 0;
						_result2 = 0;
						_value = 0;
						_value2 = 0;
						_rcvr = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						_arg = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
						if ((_rcvr & _arg) & (smallIntegerTag())) {
							/* begin booleanCheatSistaV1: */
							if (_rcvr > _arg) {
								goto booleanCheatTrueSistaV1;
							} else {
								/* goto booleanCheatFalseSistaV1 */
							}
							/* end booleanCheatSistaV1: */
							goto l68;
						}
						/* begin initPrimCall */
						GIV(primFailCode) = 0;
						/* end initPrimCall */
						/* begin primitiveFloatGreater:thanArg: */
						/* begin loadFloatOrIntFrom: */
						if (((_tagBits = _rcvr & (tagMask()))) != 0) {
							int t1;
							int t2;

							if (_tagBits == (smallFloatTag())) {
								/* begin smallFloatValueOf: */
								/* begin smallFloatBitsOf: */
								assert(isImmediateFloat(_rcvr));
								_rot = ((usqInt) ((usqInt) _rcvr ) ) >> (numTagBits());
								if (_rot > 1) {
									_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
								}
								/* begin rotateRight: */
								_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
								/* end rotateRight: */
								_bits = _rot;
								/* end smallFloatBitsOf: */
								{
									memcpy(&_value, &_bits, sizeof(_value));
									_rcvr2 = _value;
									goto l69;
								}
								_rcvr2 = null;
								goto l69;
								/* end smallFloatValueOf: */
							}
							t1 = _tagBits == (smallIntegerTag());
							if (t1) {
								_shift = (64 - (numTagBits())) - (smallFloatMantissaBits());
								t2 = (((sqInt) ((sqInt) (((usqInt) _rcvr ) << _shift) ) ) >> _shift) == _rcvr;
							} else {
								t2 = t1;
							}
							if (t2) {
								_rcvr2 = ((double) (_rcvr >> 3) );
								goto l69;
							}
						} else {
							if (((longAt(_rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(_rcvr + BaseHeaderSize, _result);
								_rcvr2 = _result;
								goto l69;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						_rcvr2 = 0.0;
						l69:
						;
						/* end loadFloatOrIntFrom: */
						/* begin loadFloatOrIntFrom: */
						if (((_tagBits2 = _arg & (tagMask()))) != 0) {
							int t1;
							int t2;

							if (_tagBits2 == (smallFloatTag())) {
								/* begin smallFloatValueOf: */
								/* begin smallFloatBitsOf: */
								assert(isImmediateFloat(_arg));
								_rot2 = ((usqInt) ((usqInt) _arg ) ) >> (numTagBits());
								if (_rot2 > 1) {
									_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
								}
								/* begin rotateRight: */
								_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
								/* end rotateRight: */
								_bits2 = _rot2;
								/* end smallFloatBitsOf: */
								{
									memcpy(&_value2, &_bits2, sizeof(_value2));
									_arg2 = _value2;
									goto l72;
								}
								_arg2 = null;
								goto l72;
								/* end smallFloatValueOf: */
							}
							t1 = _tagBits2 == (smallIntegerTag());
							if (t1) {
								_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits());
								t2 = (((sqInt) ((sqInt) (((usqInt) _arg ) << _shift2) ) ) >> _shift2) == _arg;
							} else {
								t2 = t1;
							}
							if (t2) {
								_arg2 = ((double) (_arg >> 3) );
								goto l72;
							}
						} else {
							if (((longAt(_arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(_arg + BaseHeaderSize, _result2);
								_arg2 = _result2;
								goto l72;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						_arg2 = 0.0;
						l72:
						;
						/* end loadFloatOrIntFrom: */
						_aBool = _rcvr2 > _arg2;
						/* end primitiveFloatGreater:thanArg: */
						if (!GIV(primFailCode)) {
							/* begin booleanCheatSistaV1: */
							if (_aBool) {
								goto booleanCheatTrueSistaV1;
							} else {
								goto booleanCheatFalseSistaV1;
							}
							/* end booleanCheatSistaV1: */
							goto l68;
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (3 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
				l68:
				;
				/* end case */
				booleanCheatFalseSistaV1:
/* booleanCheatFalseSistaV1 */
				{
					VM_LABEL(booleanCheatFalseSistaV1);
					{
						int t5;
						int t6;
						sqInt _bytecode;
						sqInt _offset;
						char *_sp;

						_bytecode = byteAtPointer(++local_instructionPointer);
						/* begin pop: */
						local_stackPointer += 2 * BytesPerWord;
						/* end pop: */
						t5 = _bytecode < 199;
						if (t5) {
							t6 = _bytecode > 191;
						} else {
							t6 = t5;
						}
						if (t6) {
							/* begin jump: */
							local_instructionPointer = (local_instructionPointer + (_bytecode - 191)) + 1;
							currentBytecode = byteAtPointer(local_instructionPointer);
							/* end jump: */
							goto l518;
						}
						if (_bytecode == 239) {
							_offset = byteAtPointer(++local_instructionPointer);
							/* begin jump: */
							local_instructionPointer = (local_instructionPointer + _offset) + 1;
							currentBytecode = byteAtPointer(local_instructionPointer);
							/* end jump: */
							goto l518;
						}
						currentBytecode = _bytecode;
						/* begin push: */
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), GIV(falseObj));
						local_stackPointer = _sp;
						/* end push: */
					}
				}
				l518:
				;
				/* end case */
			}
			BREAK;
			CASE(100)
			{
				/* bytecodePrimLessOrEqualSistaV1 */
				{
					VM_LABEL(bytecodePrimLessOrEqualSistaV1);
					{
						sqInt _aBool;
						sqInt _arg;
						double _arg2;
						usqLong _bits;
						usqLong _bits2;
						sqInt _objOop;
						sqInt _rcvr;
						double _rcvr2;
						double _result;
						double _result2;
						usqLong _rot;
						usqLong _rot2;
						sqInt _shift;
						sqInt _shift2;
						sqInt _tagBits;
						sqInt _tagBits2;
						double _value;
						double _value2;

						_result = 0;
						_result2 = 0;
						_value = 0;
						_value2 = 0;
						_rcvr = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						_arg = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
						if ((_rcvr & _arg) & (smallIntegerTag())) {
							/* begin booleanCheatSistaV1: */
							if (_rcvr <= _arg) {
								goto booleanCheatTrueSistaV1;
							} else {
								goto booleanCheatFalseSistaV1;
							}
							/* end booleanCheatSistaV1: */
							goto l78;
						}
						/* begin initPrimCall */
						GIV(primFailCode) = 0;
						/* end initPrimCall */
						/* begin primitiveFloatLessOrEqual:toArg: */
						/* begin loadFloatOrIntFrom: */
						if (((_tagBits = _rcvr & (tagMask()))) != 0) {
							int t1;
							int t2;

							if (_tagBits == (smallFloatTag())) {
								/* begin smallFloatValueOf: */
								/* begin smallFloatBitsOf: */
								assert(isImmediateFloat(_rcvr));
								_rot = ((usqInt) ((usqInt) _rcvr ) ) >> (numTagBits());
								if (_rot > 1) {
									_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
								}
								/* begin rotateRight: */
								_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
								/* end rotateRight: */
								_bits = _rot;
								/* end smallFloatBitsOf: */
								{
									memcpy(&_value, &_bits, sizeof(_value));
									_rcvr2 = _value;
									goto l79;
								}
								_rcvr2 = null;
								goto l79;
								/* end smallFloatValueOf: */
							}
							t1 = _tagBits == (smallIntegerTag());
							if (t1) {
								_shift = (64 - (numTagBits())) - (smallFloatMantissaBits());
								t2 = (((sqInt) ((sqInt) (((usqInt) _rcvr ) << _shift) ) ) >> _shift) == _rcvr;
							} else {
								t2 = t1;
							}
							if (t2) {
								_rcvr2 = ((double) (_rcvr >> 3) );
								goto l79;
							}
						} else {
							if (((longAt(_rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(_rcvr + BaseHeaderSize, _result);
								_rcvr2 = _result;
								goto l79;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						_rcvr2 = 0.0;
						l79:
						;
						/* end loadFloatOrIntFrom: */
						/* begin loadFloatOrIntFrom: */
						if (((_tagBits2 = _arg & (tagMask()))) != 0) {
							int t1;
							int t2;

							if (_tagBits2 == (smallFloatTag())) {
								/* begin smallFloatValueOf: */
								/* begin smallFloatBitsOf: */
								assert(isImmediateFloat(_arg));
								_rot2 = ((usqInt) ((usqInt) _arg ) ) >> (numTagBits());
								if (_rot2 > 1) {
									_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
								}
								/* begin rotateRight: */
								_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
								/* end rotateRight: */
								_bits2 = _rot2;
								/* end smallFloatBitsOf: */
								{
									memcpy(&_value2, &_bits2, sizeof(_value2));
									_arg2 = _value2;
									goto l82;
								}
								_arg2 = null;
								goto l82;
								/* end smallFloatValueOf: */
							}
							t1 = _tagBits2 == (smallIntegerTag());
							if (t1) {
								_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits());
								t2 = (((sqInt) ((sqInt) (((usqInt) _arg ) << _shift2) ) ) >> _shift2) == _arg;
							} else {
								t2 = t1;
							}
							if (t2) {
								_arg2 = ((double) (_arg >> 3) );
								goto l82;
							}
						} else {
							if (((longAt(_arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(_arg + BaseHeaderSize, _result2);
								_arg2 = _result2;
								goto l82;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						_arg2 = 0.0;
						l82:
						;
						/* end loadFloatOrIntFrom: */
						_aBool = _rcvr2 <= _arg2;
						/* end primitiveFloatLessOrEqual:toArg: */
						if (!GIV(primFailCode)) {
							/* begin booleanCheatSistaV1: */
							if (_aBool) {
								goto booleanCheatTrueSistaV1;
							} else {
								goto booleanCheatFalseSistaV1;
							}
							/* end booleanCheatSistaV1: */
							goto l78;
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (4 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
				l78:
				;
				/* end case */
			}
			BREAK;
			CASE(101)
			{
				/* bytecodePrimGreaterOrEqualSistaV1 */
				{
					VM_LABEL(bytecodePrimGreaterOrEqualSistaV1);
					{
						sqInt _aBool;
						sqInt _arg;
						double _arg2;
						usqLong _bits;
						usqLong _bits2;
						sqInt _objOop;
						sqInt _rcvr;
						double _rcvr2;
						double _result;
						double _result2;
						usqLong _rot;
						usqLong _rot2;
						sqInt _shift;
						sqInt _shift2;
						sqInt _tagBits;
						sqInt _tagBits2;
						double _value;
						double _value2;

						_result = 0;
						_result2 = 0;
						_value = 0;
						_value2 = 0;
						_rcvr = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						_arg = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
						if ((_rcvr & _arg) & (smallIntegerTag())) {
							/* begin booleanCheatSistaV1: */
							if (_rcvr >= _arg) {
								goto booleanCheatTrueSistaV1;
							} else {
								goto booleanCheatFalseSistaV1;
							}
							/* end booleanCheatSistaV1: */
							goto l88;
						}
						/* begin initPrimCall */
						GIV(primFailCode) = 0;
						/* end initPrimCall */
						/* begin primitiveFloatGreaterOrEqual:toArg: */
						/* begin loadFloatOrIntFrom: */
						if (((_tagBits = _rcvr & (tagMask()))) != 0) {
							int t1;
							int t2;

							if (_tagBits == (smallFloatTag())) {
								/* begin smallFloatValueOf: */
								/* begin smallFloatBitsOf: */
								assert(isImmediateFloat(_rcvr));
								_rot = ((usqInt) ((usqInt) _rcvr ) ) >> (numTagBits());
								if (_rot > 1) {
									_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
								}
								/* begin rotateRight: */
								_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
								/* end rotateRight: */
								_bits = _rot;
								/* end smallFloatBitsOf: */
								{
									memcpy(&_value, &_bits, sizeof(_value));
									_rcvr2 = _value;
									goto l89;
								}
								_rcvr2 = null;
								goto l89;
								/* end smallFloatValueOf: */
							}
							t1 = _tagBits == (smallIntegerTag());
							if (t1) {
								_shift = (64 - (numTagBits())) - (smallFloatMantissaBits());
								t2 = (((sqInt) ((sqInt) (((usqInt) _rcvr ) << _shift) ) ) >> _shift) == _rcvr;
							} else {
								t2 = t1;
							}
							if (t2) {
								_rcvr2 = ((double) (_rcvr >> 3) );
								goto l89;
							}
						} else {
							if (((longAt(_rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(_rcvr + BaseHeaderSize, _result);
								_rcvr2 = _result;
								goto l89;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						_rcvr2 = 0.0;
						l89:
						;
						/* end loadFloatOrIntFrom: */
						/* begin loadFloatOrIntFrom: */
						if (((_tagBits2 = _arg & (tagMask()))) != 0) {
							int t1;
							int t2;

							if (_tagBits2 == (smallFloatTag())) {
								/* begin smallFloatValueOf: */
								/* begin smallFloatBitsOf: */
								assert(isImmediateFloat(_arg));
								_rot2 = ((usqInt) ((usqInt) _arg ) ) >> (numTagBits());
								if (_rot2 > 1) {
									_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
								}
								/* begin rotateRight: */
								_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
								/* end rotateRight: */
								_bits2 = _rot2;
								/* end smallFloatBitsOf: */
								{
									memcpy(&_value2, &_bits2, sizeof(_value2));
									_arg2 = _value2;
									goto l92;
								}
								_arg2 = null;
								goto l92;
								/* end smallFloatValueOf: */
							}
							t1 = _tagBits2 == (smallIntegerTag());
							if (t1) {
								_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits());
								t2 = (((sqInt) ((sqInt) (((usqInt) _arg ) << _shift2) ) ) >> _shift2) == _arg;
							} else {
								t2 = t1;
							}
							if (t2) {
								_arg2 = ((double) (_arg >> 3) );
								goto l92;
							}
						} else {
							if (((longAt(_arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(_arg + BaseHeaderSize, _result2);
								_arg2 = _result2;
								goto l92;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						_arg2 = 0.0;
						l92:
						;
						/* end loadFloatOrIntFrom: */
						_aBool = _rcvr2 >= _arg2;
						/* end primitiveFloatGreaterOrEqual:toArg: */
						if (!GIV(primFailCode)) {
							/* begin booleanCheatSistaV1: */
							if (_aBool) {
								goto booleanCheatTrueSistaV1;
							} else {
								goto booleanCheatFalseSistaV1;
							}
							/* end booleanCheatSistaV1: */
							goto l88;
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (5 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
				l88:
				;
				/* end case */
			}
			BREAK;
			CASE(102)
			{
				/* bytecodePrimEqualSistaV1 */
				{
					VM_LABEL(bytecodePrimEqualSistaV1);
					{
						sqInt _aBool;
						sqInt _arg;
						double _arg2;
						usqLong _bits;
						usqLong _bits2;
						sqInt _objOop;
						sqInt _rcvr;
						double _rcvr2;
						double _result;
						double _result2;
						usqLong _rot;
						usqLong _rot2;
						sqInt _shift;
						sqInt _shift2;
						sqInt _tagBits;
						sqInt _tagBits2;
						double _value;
						double _value2;

						_result = 0;
						_result2 = 0;
						_value = 0;
						_value2 = 0;
						_rcvr = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						_arg = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
						if ((_rcvr & _arg) & (smallIntegerTag())) {
							/* begin booleanCheatSistaV1: */
							if (_rcvr == _arg) {
								goto booleanCheatTrueSistaV1;
							} else {
								goto booleanCheatFalseSistaV1;
							}
							/* end booleanCheatSistaV1: */
							goto l98;
						}
						/* begin initPrimCall */
						GIV(primFailCode) = 0;
						/* end initPrimCall */
						/* begin primitiveFloatEqual:toArg: */
						/* begin loadFloatOrIntFrom: */
						if (((_tagBits = _rcvr & (tagMask()))) != 0) {
							int t1;
							int t2;

							if (_tagBits == (smallFloatTag())) {
								/* begin smallFloatValueOf: */
								/* begin smallFloatBitsOf: */
								assert(isImmediateFloat(_rcvr));
								_rot = ((usqInt) ((usqInt) _rcvr ) ) >> (numTagBits());
								if (_rot > 1) {
									_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
								}
								/* begin rotateRight: */
								_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
								/* end rotateRight: */
								_bits = _rot;
								/* end smallFloatBitsOf: */
								{
									memcpy(&_value, &_bits, sizeof(_value));
									_rcvr2 = _value;
									goto l99;
								}
								_rcvr2 = null;
								goto l99;
								/* end smallFloatValueOf: */
							}
							t1 = _tagBits == (smallIntegerTag());
							if (t1) {
								_shift = (64 - (numTagBits())) - (smallFloatMantissaBits());
								t2 = (((sqInt) ((sqInt) (((usqInt) _rcvr ) << _shift) ) ) >> _shift) == _rcvr;
							} else {
								t2 = t1;
							}
							if (t2) {
								_rcvr2 = ((double) (_rcvr >> 3) );
								goto l99;
							}
						} else {
							if (((longAt(_rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(_rcvr + BaseHeaderSize, _result);
								_rcvr2 = _result;
								goto l99;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						_rcvr2 = 0.0;
						l99:
						;
						/* end loadFloatOrIntFrom: */
						/* begin loadFloatOrIntFrom: */
						if (((_tagBits2 = _arg & (tagMask()))) != 0) {
							int t1;
							int t2;

							if (_tagBits2 == (smallFloatTag())) {
								/* begin smallFloatValueOf: */
								/* begin smallFloatBitsOf: */
								assert(isImmediateFloat(_arg));
								_rot2 = ((usqInt) ((usqInt) _arg ) ) >> (numTagBits());
								if (_rot2 > 1) {
									_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
								}
								/* begin rotateRight: */
								_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
								/* end rotateRight: */
								_bits2 = _rot2;
								/* end smallFloatBitsOf: */
								{
									memcpy(&_value2, &_bits2, sizeof(_value2));
									_arg2 = _value2;
									goto l102;
								}
								_arg2 = null;
								goto l102;
								/* end smallFloatValueOf: */
							}
							t1 = _tagBits2 == (smallIntegerTag());
							if (t1) {
								_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits());
								t2 = (((sqInt) ((sqInt) (((usqInt) _arg ) << _shift2) ) ) >> _shift2) == _arg;
							} else {
								t2 = t1;
							}
							if (t2) {
								_arg2 = ((double) (_arg >> 3) );
								goto l102;
							}
						} else {
							if (((longAt(_arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(_arg + BaseHeaderSize, _result2);
								_arg2 = _result2;
								goto l102;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						_arg2 = 0.0;
						l102:
						;
						/* end loadFloatOrIntFrom: */
						_aBool = _rcvr2 == _arg2;
						/* end primitiveFloatEqual:toArg: */
						if (!GIV(primFailCode)) {
							/* begin booleanCheatSistaV1: */
							if (_aBool) {
								goto booleanCheatTrueSistaV1;
							} else {
								goto booleanCheatFalseSistaV1;
							}
							/* end booleanCheatSistaV1: */
							goto l98;
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (6 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
				l98:
				;
				/* end case */
			}
			BREAK;
			CASE(103)
			{
				/* bytecodePrimNotEqualSistaV1 */
				{
					VM_LABEL(bytecodePrimNotEqualSistaV1);
					{
						sqInt _aBool;
						sqInt _arg;
						double _arg2;
						usqLong _bits;
						usqLong _bits2;
						sqInt _objOop;
						sqInt _rcvr;
						double _rcvr2;
						double _result;
						double _result2;
						usqLong _rot;
						usqLong _rot2;
						sqInt _shift;
						sqInt _shift2;
						sqInt _tagBits;
						sqInt _tagBits2;
						double _value;
						double _value2;

						_result = 0;
						_result2 = 0;
						_value = 0;
						_value2 = 0;
						_rcvr = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						_arg = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
						if ((_rcvr & _arg) & (smallIntegerTag())) {
							/* begin booleanCheatSistaV1: */
							if (_rcvr != _arg) {
								goto booleanCheatTrueSistaV1;
							} else {
								goto booleanCheatFalseSistaV1;
							}
							/* end booleanCheatSistaV1: */
							goto l108;
						}
						/* begin initPrimCall */
						GIV(primFailCode) = 0;
						/* end initPrimCall */
						/* begin primitiveFloatEqual:toArg: */
						/* begin loadFloatOrIntFrom: */
						if (((_tagBits = _rcvr & (tagMask()))) != 0) {
							int t1;
							int t2;

							if (_tagBits == (smallFloatTag())) {
								/* begin smallFloatValueOf: */
								/* begin smallFloatBitsOf: */
								assert(isImmediateFloat(_rcvr));
								_rot = ((usqInt) ((usqInt) _rcvr ) ) >> (numTagBits());
								if (_rot > 1) {
									_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
								}
								/* begin rotateRight: */
								_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
								/* end rotateRight: */
								_bits = _rot;
								/* end smallFloatBitsOf: */
								{
									memcpy(&_value, &_bits, sizeof(_value));
									_rcvr2 = _value;
									goto l109;
								}
								_rcvr2 = null;
								goto l109;
								/* end smallFloatValueOf: */
							}
							t1 = _tagBits == (smallIntegerTag());
							if (t1) {
								_shift = (64 - (numTagBits())) - (smallFloatMantissaBits());
								t2 = (((sqInt) ((sqInt) (((usqInt) _rcvr ) << _shift) ) ) >> _shift) == _rcvr;
							} else {
								t2 = t1;
							}
							if (t2) {
								_rcvr2 = ((double) (_rcvr >> 3) );
								goto l109;
							}
						} else {
							if (((longAt(_rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(_rcvr + BaseHeaderSize, _result);
								_rcvr2 = _result;
								goto l109;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						_rcvr2 = 0.0;
						l109:
						;
						/* end loadFloatOrIntFrom: */
						/* begin loadFloatOrIntFrom: */
						if (((_tagBits2 = _arg & (tagMask()))) != 0) {
							int t1;
							int t2;

							if (_tagBits2 == (smallFloatTag())) {
								/* begin smallFloatValueOf: */
								/* begin smallFloatBitsOf: */
								assert(isImmediateFloat(_arg));
								_rot2 = ((usqInt) ((usqInt) _arg ) ) >> (numTagBits());
								if (_rot2 > 1) {
									_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
								}
								/* begin rotateRight: */
								_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
								/* end rotateRight: */
								_bits2 = _rot2;
								/* end smallFloatBitsOf: */
								{
									memcpy(&_value2, &_bits2, sizeof(_value2));
									_arg2 = _value2;
									goto l112;
								}
								_arg2 = null;
								goto l112;
								/* end smallFloatValueOf: */
							}
							t1 = _tagBits2 == (smallIntegerTag());
							if (t1) {
								_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits());
								t2 = (((sqInt) ((sqInt) (((usqInt) _arg ) << _shift2) ) ) >> _shift2) == _arg;
							} else {
								t2 = t1;
							}
							if (t2) {
								_arg2 = ((double) (_arg >> 3) );
								goto l112;
							}
						} else {
							if (((longAt(_arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(_arg + BaseHeaderSize, _result2);
								_arg2 = _result2;
								goto l112;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						_arg2 = 0.0;
						l112:
						;
						/* end loadFloatOrIntFrom: */
						_aBool = _rcvr2 == _arg2;
						/* end primitiveFloatEqual:toArg: */
						if (!GIV(primFailCode)) {
							/* begin booleanCheatSistaV1: */
							if (!_aBool) {
								goto booleanCheatTrueSistaV1;
							} else {
								goto booleanCheatFalseSistaV1;
							}
							/* end booleanCheatSistaV1: */
							goto l108;
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (7 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
				l108:
				;
				/* end case */
			}
			BREAK;
			CASE(104)
			{
				/* bytecodePrimMultiply */
				{
					VM_LABEL(bytecodePrimMultiply);
					{
						sqInt _arg;
						double _arg2;
						usqLong _bits;
						usqLong _bits2;
						sqInt _objOop;
						sqInt _oop;
						sqInt _overflow;
						sqInt _rcvr;
						double _rcvr2;
						sqInt _result;
						double _result2;
						double _result3;
						usqLong _rot;
						usqLong _rot2;
						sqInt _shift;
						sqInt _shift2;
						char *_sp;
						char *_sp2;
						sqInt _tagBits;
						sqInt _tagBits2;
						double _value;
						double _value2;

						_result2 = 0;
						_result3 = 0;
						_value = 0;
						_value2 = 0;
						_rcvr = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						_arg = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
						if ((_rcvr & _arg) & (smallIntegerTag())) {
							_rcvr = _rcvr >> 3;
							_arg = _arg >> 3;
							if (_rcvr > 0) {
								int t0;

								if (_arg > 0) {
									t0 = _rcvr > (MaxSmallInteger / _arg);
								}
 else {
									t0 = _arg < (MinSmallInteger / _rcvr);
								}
								_overflow = t0;
							} else {
								if (_arg > 0) {
									_overflow = _rcvr < (MinSmallInteger / _arg);
								} else {
									int t0;
									int t1;

									t0 = _rcvr < 0;
									if (t0) {
										t1 = _arg < (MaxSmallInteger / _rcvr);
									} else {
										t1 = t0;
									}
									_overflow = t1;
								}
							}
							if (!_overflow) {
								_result = _rcvr * _arg;
								_oop = ((((usqInt) _result ) << 3) | 1);
								/* begin pop:thenPush: */
								unsignedLongAtput((_sp = local_stackPointer + ((2 - 1) * BytesPerWord)), _oop);
								local_stackPointer = _sp;
								/* end pop:thenPush: */
								/* begin fetchNextBytecode */
								/* begin fetchByte */
								currentBytecode = byteAtPointer(++local_instructionPointer);
								/* end fetchByte */
								/* end fetchNextBytecode */
								goto l118;
							}
						} else {
							/* begin initPrimCall */
							GIV(primFailCode) = 0;
							/* end initPrimCall */
							/* begin primitiveFloatMultiply:byArg: */
							/* begin loadFloatOrIntFrom: */
							if (((_tagBits = _rcvr & (tagMask()))) != 0) {
								int t1;
								int t2;

								if (_tagBits == (smallFloatTag())) {
									/* begin smallFloatValueOf: */
									/* begin smallFloatBitsOf: */
									assert(isImmediateFloat(_rcvr));
									_rot = ((usqInt) ((usqInt) _rcvr ) ) >> (numTagBits());
									if (_rot > 1) {
										_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
									}
									/* begin rotateRight: */
									_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
									/* end rotateRight: */
									_bits = _rot;
									/* end smallFloatBitsOf: */
									{
										memcpy(&_value, &_bits, sizeof(_value));
										_rcvr2 = _value;
										goto l122;
									}
									_rcvr2 = null;
									goto l122;
									/* end smallFloatValueOf: */
								}
								t1 = _tagBits == (smallIntegerTag());
								if (t1) {
									_shift = (64 - (numTagBits())) - (smallFloatMantissaBits());
									t2 = (((sqInt) ((sqInt) (((usqInt) _rcvr ) << _shift) ) ) >> _shift) == _rcvr;
								} else {
									t2 = t1;
								}
								if (t2) {
									_rcvr2 = ((double) (_rcvr >> 3) );
									goto l122;
								}
							} else {
								if (((longAt(_rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
									fetchFloatAtinto(_rcvr + BaseHeaderSize, _result3);
									_rcvr2 = _result3;
									goto l122;
								}
							}
							/* begin primitiveFail */
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
							/* end primitiveFail */
							_rcvr2 = 0.0;
							l122:
							;
							/* end loadFloatOrIntFrom: */
							/* begin loadFloatOrIntFrom: */
							if (((_tagBits2 = _arg & (tagMask()))) != 0) {
								int t1;
								int t2;

								if (_tagBits2 == (smallFloatTag())) {
									/* begin smallFloatValueOf: */
									/* begin smallFloatBitsOf: */
									assert(isImmediateFloat(_arg));
									_rot2 = ((usqInt) ((usqInt) _arg ) ) >> (numTagBits());
									if (_rot2 > 1) {
										_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
									}
									/* begin rotateRight: */
									_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
									/* end rotateRight: */
									_bits2 = _rot2;
									/* end smallFloatBitsOf: */
									{
										memcpy(&_value2, &_bits2, sizeof(_value2));
										_arg2 = _value2;
										goto l127;
									}
									_arg2 = null;
									goto l127;
									/* end smallFloatValueOf: */
								}
								t1 = _tagBits2 == (smallIntegerTag());
								if (t1) {
									_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits());
									t2 = (((sqInt) ((sqInt) (((usqInt) _arg ) << _shift2) ) ) >> _shift2) == _arg;
								} else {
									t2 = t1;
								}
								if (t2) {
									_arg2 = ((double) (_arg >> 3) );
									goto l127;
								}
							} else {
								if (((longAt(_arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
									fetchFloatAtinto(_arg + BaseHeaderSize, _result2);
									_arg2 = _result2;
									goto l127;
								}
							}
							/* begin primitiveFail */
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
							/* end primitiveFail */
							_arg2 = 0.0;
							l127:
							;
							/* end loadFloatOrIntFrom: */
							if (!GIV(primFailCode)) {
								/* begin pop:thenPushFloat: */
								unsignedLongAtput((_sp2 = local_stackPointer + ((2 - 1) * BytesPerWord)), floatObjectOf(_rcvr2 * _arg2));
								local_stackPointer = _sp2;
								/* end pop:thenPushFloat: */
							}
							/* end primitiveFloatMultiply:byArg: */
							if (!GIV(primFailCode)) {
								/* begin fetchNextBytecode */
								/* begin fetchByte */
								currentBytecode = byteAtPointer(++local_instructionPointer);
								/* end fetchByte */
								/* end fetchNextBytecode */
								goto l118;
							}
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (8 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
				l118:
				;
				/* end case */
			}
			BREAK;
			CASE(105)
			{
				/* bytecodePrimDivide */
				{
					VM_LABEL(bytecodePrimDivide);
					{
						sqInt _arg;
						double _arg2;
						usqLong _bits;
						usqLong _bits2;
						sqInt _objOop;
						sqInt _rcvr;
						double _rcvr2;
						sqInt _result;
						double _result2;
						double _result3;
						usqLong _rot;
						usqLong _rot2;
						sqInt _shift;
						sqInt _shift2;
						char *_sp;
						char *_sp2;
						sqInt _tagBits;
						sqInt _tagBits2;
						double _value;
						double _value2;

						_result2 = 0;
						_result3 = 0;
						_value = 0;
						_value2 = 0;
						_rcvr = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						_arg = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
						if ((_rcvr & _arg) & (smallIntegerTag())) {
							int t2;
							int t3;

							_rcvr = _rcvr >> 3;
							_arg = _arg >> 3;
							t2 = _arg != 0;
							if (t2) {
								t3 = (_rcvr % _arg) == 0;
							} else {
								t3 = t2;
							}
							if (t3) {
								_result = _rcvr / _arg;
								if ((((((usqInt) _result ) >> 60) + 1) & 15) <= 1) {
									/* begin pop:thenPush: */
									unsignedLongAtput((_sp = local_stackPointer + ((2 - 1) * BytesPerWord)), ((((usqInt) _result ) << 3) | 1));
									local_stackPointer = _sp;
									/* end pop:thenPush: */
									/* begin fetchNextBytecode */
									/* begin fetchByte */
									currentBytecode = byteAtPointer(++local_instructionPointer);
									/* end fetchByte */
									/* end fetchNextBytecode */
									goto l129;
								}
							}
						} else {
							/* begin initPrimCall */
							GIV(primFailCode) = 0;
							/* end initPrimCall */
							/* begin primitiveFloatDivide:byArg: */
							/* begin loadFloatOrIntFrom: */
							if (((_tagBits = _rcvr & (tagMask()))) != 0) {
								int t1;
								int t2;

								if (_tagBits == (smallFloatTag())) {
									/* begin smallFloatValueOf: */
									/* begin smallFloatBitsOf: */
									assert(isImmediateFloat(_rcvr));
									_rot = ((usqInt) ((usqInt) _rcvr ) ) >> (numTagBits());
									if (_rot > 1) {
										_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
									}
									/* begin rotateRight: */
									_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
									/* end rotateRight: */
									_bits = _rot;
									/* end smallFloatBitsOf: */
									{
										memcpy(&_value, &_bits, sizeof(_value));
										_rcvr2 = _value;
										goto l133;
									}
									_rcvr2 = null;
									goto l133;
									/* end smallFloatValueOf: */
								}
								t1 = _tagBits == (smallIntegerTag());
								if (t1) {
									_shift = (64 - (numTagBits())) - (smallFloatMantissaBits());
									t2 = (((sqInt) ((sqInt) (((usqInt) _rcvr ) << _shift) ) ) >> _shift) == _rcvr;
								} else {
									t2 = t1;
								}
								if (t2) {
									_rcvr2 = ((double) (_rcvr >> 3) );
									goto l133;
								}
							} else {
								if (((longAt(_rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
									fetchFloatAtinto(_rcvr + BaseHeaderSize, _result3);
									_rcvr2 = _result3;
									goto l133;
								}
							}
							/* begin primitiveFail */
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
							/* end primitiveFail */
							_rcvr2 = 0.0;
							l133:
							;
							/* end loadFloatOrIntFrom: */
							/* begin loadFloatOrIntFrom: */
							if (((_tagBits2 = _arg & (tagMask()))) != 0) {
								int t1;
								int t2;

								if (_tagBits2 == (smallFloatTag())) {
									/* begin smallFloatValueOf: */
									/* begin smallFloatBitsOf: */
									assert(isImmediateFloat(_arg));
									_rot2 = ((usqInt) ((usqInt) _arg ) ) >> (numTagBits());
									if (_rot2 > 1) {
										_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
									}
									/* begin rotateRight: */
									_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
									/* end rotateRight: */
									_bits2 = _rot2;
									/* end smallFloatBitsOf: */
									{
										memcpy(&_value2, &_bits2, sizeof(_value2));
										_arg2 = _value2;
										goto l138;
									}
									_arg2 = null;
									goto l138;
									/* end smallFloatValueOf: */
								}
								t1 = _tagBits2 == (smallIntegerTag());
								if (t1) {
									_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits());
									t2 = (((sqInt) ((sqInt) (((usqInt) _arg ) << _shift2) ) ) >> _shift2) == _arg;
								} else {
									t2 = t1;
								}
								if (t2) {
									_arg2 = ((double) (_arg >> 3) );
									goto l138;
								}
							} else {
								if (((longAt(_arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
									fetchFloatAtinto(_arg + BaseHeaderSize, _result2);
									_arg2 = _result2;
									goto l138;
								}
							}
							/* begin primitiveFail */
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
							/* end primitiveFail */
							_arg2 = 0.0;
							l138:
							;
							/* end loadFloatOrIntFrom: */
							/* begin success: */
							if (!(_arg2 != 0.0)) {
								if (!GIV(primFailCode)) {
									GIV(primFailCode) = 1;
								}
							}
							/* end success: */
							if (!GIV(primFailCode)) {
								/* begin pop:thenPushFloat: */
								unsignedLongAtput((_sp2 = local_stackPointer + ((2 - 1) * BytesPerWord)), floatObjectOf(_rcvr2 / _arg2));
								local_stackPointer = _sp2;
								/* end pop:thenPushFloat: */
							}
							/* end primitiveFloatDivide:byArg: */
							if (!GIV(primFailCode)) {
								/* begin fetchNextBytecode */
								/* begin fetchByte */
								currentBytecode = byteAtPointer(++local_instructionPointer);
								/* end fetchByte */
								/* end fetchNextBytecode */
								goto l129;
							}
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (9 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
				l129:
				;
				/* end case */
			}
			BREAK;
			CASE(106)
			{
				/* bytecodePrimMod */
				{
					VM_LABEL(bytecodePrimMod);
					{
						sqInt _mod;
						sqInt _objOop;
						char *_sp;

						/* begin initPrimCall */
						GIV(primFailCode) = 0;
						/* end initPrimCall */
						_mod = doPrimitiveModby(unsignedLongAt(local_stackPointer + (1 * BytesPerWord)), unsignedLongAt(local_stackPointer + (0 * BytesPerWord)));
						if (!GIV(primFailCode)) {
							/* begin pop:thenPush: */
							unsignedLongAtput((_sp = local_stackPointer + ((2 - 1) * BytesPerWord)), ((((usqInt) _mod ) << 3) | 1));
							local_stackPointer = _sp;
							/* end pop:thenPush: */
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							goto l140;
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (10 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
				l140:
				;
				/* end case */
			}
			BREAK;
			CASE(107)
			{
				/* bytecodePrimMakePoint */
				{
					VM_LABEL(bytecodePrimMakePoint);
					{
						int t2;
						int t3;
						sqInt _arg;
						sqInt _classFormat;
						sqInt _classIndex;
						sqInt _classObj;
						usqInt _newObj;
						usqInt _numBytes;
						sqInt _numSlots;
						sqInt _objFormat;
						sqInt _objOop;
						usqInt _pt;
						sqInt _rcvr;
						char *_sp;

						_rcvr = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						_arg = unsignedLongAt(local_stackPointer);
						if (_rcvr & (tagMask())) {
							t2 = !(_rcvr & (characterTag()));
						} else {
							t2 = ((longAt(_rcvr)) & (classIndexMask())) == ClassFloatCompactIndex;
						}
						if (t2) {
							if (_arg & (tagMask())) {
								t3 = !(_arg & (characterTag()));
							} else {
								t3 = ((longAt(_arg)) & (classIndexMask())) == ClassFloatCompactIndex;
							}
						} else {
							t3 = t2;
						}
						if (t3) {
							/* begin eeInstantiateSmallClass:numSlots: */
							/* begin splObj: */
							/* begin fetchPointer:ofObject: */
							_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassPoint ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							/* end splObj: */
							_numSlots = YIndex + 1;
							assert((rawHashBitsOf(_classObj)) != 0);
							/* begin eeInstantiateSmallClassIndex:format:numSlots: */
							_classIndex = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask());
							/* begin instSpecOfClassFormat: */
							_classFormat = (unsignedLongAt((_classObj + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
							_objFormat = (((usqInt) _classFormat ) >> (fixedFieldsFieldWidth())) & (formatMask());
							/* end instSpecOfClassFormat: */
							assert((_numSlots >= 0) && ((_classIndex != 0) && ((classAtIndex(_classIndex)) != GIV(nilObj))));
							assert((((_objFormat < (firstByteFormat()))
								 ? _objFormat
								 : _objFormat & (byteFormatMask()))) == (instSpecOfClass(classAtIndex(_classIndex))));
							/* begin allocateSmallNewSpaceSlots:format:classIndex: */
							assert(_numSlots < (numSlotsMask()));
							_newObj = GIV(freeStart);
							_numBytes = BaseHeaderSize + (((_numSlots < 1)
								 ? 8
								 : _numSlots * BytesPerOop));
							assert((_numBytes % (allocationUnit())) == 0);
							assert((_newObj % (allocationUnit())) == 0);
							if ((GIV(freeStart) + _numBytes) > GIV(scavengeThreshold)) {
								if (!GIV(needGCFlag)) {
									/* begin scheduleScavenge */
									GIV(needGCFlag) = 1;
									forceInterruptCheck();
									/* end scheduleScavenge */
								}
								if ((GIV(freeStart) + _numBytes) > (((eden()).limit))) {
									error("no room in eden for allocateSmallNewSpaceSlots:format:classIndex:");
									_pt = 0;
									goto l149;
								}
							}
							long64Atput(_newObj, ((((usqLong) _numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) _objFormat ) << (formatShift())) )) + _classIndex);
							GIV(freeStart) += _numBytes;
							_pt = _newObj;
							/* end allocateSmallNewSpaceSlots:format:classIndex: */
							/* end eeInstantiateSmallClassIndex:format:numSlots: */
							l149:
							;
							/* end eeInstantiateSmallClass:numSlots: */
							{
								/* begin storePointerUnchecked:ofObject:withValue: */
								assert(!(isOopForwarded(_pt)));
								longAtput((_pt + BaseHeaderSize) + ((sqInt) (((usqInt) XIndex ) << (shiftForWord())) ), _rcvr);
								/* end storePointerUnchecked:ofObject:withValue: */
								/* begin storePointerUnchecked:ofObject:withValue: */
								assert(!(isOopForwarded(_pt)));
								longAtput((_pt + BaseHeaderSize) + ((sqInt) (((usqInt) YIndex ) << (shiftForWord())) ), _arg);
								/* end storePointerUnchecked:ofObject:withValue: */
							}
							/* begin pop:thenPush: */
							unsignedLongAtput((_sp = local_stackPointer + ((2 - 1) * BytesPerWord)), _pt);
							local_stackPointer = _sp;
							/* end pop:thenPush: */
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							goto l144;
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (11 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
				l144:
				;
				/* end case */
			}
			BREAK;
			CASE(108)
			{
				/* bytecodePrimBitShift */
				{
					VM_LABEL(bytecodePrimBitShift);
					{
						sqInt _integerArgument;
						sqInt _integerReceiver;
						sqInt _objOop;
						sqInt _shifted;
						char *_sp;

						/* begin initPrimCall */
						GIV(primFailCode) = 0;
						/* end initPrimCall */
						/* begin primitiveBitShift */
						_integerArgument = unsignedLongAt(local_stackPointer);
						if (!(((_integerArgument & 7) == 1))) {
							/* begin primitiveFail */
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
							/* end primitiveFail */
							goto l156;
						}
						_integerReceiver = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						{
							_integerReceiver = signed64BitValueOf(_integerReceiver);
						}
						if (!GIV(primFailCode)) {
							if (((_integerArgument = _integerArgument >> 3)) >= 0) {
								if (!(_integerArgument <= 61)) {
									/* begin primitiveFail */
									if (!GIV(primFailCode)) {
										GIV(primFailCode) = 1;
									}
									/* end primitiveFail */
									goto l156;
								}
								_shifted = ((sqInt) (((usqInt) _integerReceiver ) << _integerArgument) );
								if (!(_integerReceiver == (((sqInt) _shifted ) >> _integerArgument))) {
									/* begin primitiveFail */
									if (!GIV(primFailCode)) {
										GIV(primFailCode) = 1;
									}
									/* end primitiveFail */
									goto l156;
								}
							} else {
								sqInt t1;

								if (!(_integerArgument >= -61)) {
									/* begin primitiveFail */
									if (!GIV(primFailCode)) {
										GIV(primFailCode) = 1;
									}
									/* end primitiveFail */
									goto l156;
								}
								{
									t1 = ((sqInt) _integerReceiver ) >> (0 - _integerArgument);
								}
								_shifted = t1;
							}
							{
								sqInt t0;

								if ((((((usqInt) _shifted ) >> 60) + 1) & 15) <= 1) {
									t0 = ((((usqInt) _shifted ) << 3) | 1);
								} else {
									t0 = signed64BitIntegerFor(_shifted);
								}
								_shifted = t0;
							}
							/* begin pop:thenPush: */
							unsignedLongAtput((_sp = local_stackPointer + ((2 - 1) * BytesPerWord)), _shifted);
							local_stackPointer = _sp;
							/* end pop:thenPush: */
						}
						l156:
						;
						/* end primitiveBitShift */
						if (!GIV(primFailCode)) {
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							goto l153;
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (12 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
				l153:
				;
				/* end case */
			}
			BREAK;
			CASE(109)
			{
				/* bytecodePrimDiv */
				{
					VM_LABEL(bytecodePrimDiv);
					{
						sqInt _objOop;
						sqInt _quotient;
						char *_sp;

						/* begin initPrimCall */
						GIV(primFailCode) = 0;
						/* end initPrimCall */
						_quotient = doPrimitiveDivby(unsignedLongAt(local_stackPointer + (1 * BytesPerWord)), unsignedLongAt(local_stackPointer + (0 * BytesPerWord)));
						if (!GIV(primFailCode)) {
							/* begin pop:thenPush: */
							unsignedLongAtput((_sp = local_stackPointer + ((2 - 1) * BytesPerWord)), ((((usqInt) _quotient ) << 3) | 1));
							local_stackPointer = _sp;
							/* end pop:thenPush: */
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							goto l159;
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (13 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
				l159:
				;
				/* end case */
			}
			BREAK;
			CASE(110)
			{
				/* bytecodePrimBitAnd */
				{
					VM_LABEL(bytecodePrimBitAnd);
					{
						sqInt t2;
						sqInt t3;
						sqInt _arg;
						sqInt _objOop;
						sqInt _rcvr;
						char *_sp;

						_arg = unsignedLongAt(local_stackPointer);
						_rcvr = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						t2 = ((_arg & 7) == 1);
						if (t2) {
							t3 = ((_rcvr & 7) == 1);
						} else {
							t3 = t2;
						}
						if (t3) {
							/* begin pop:thenPush: */
							unsignedLongAtput((_sp = local_stackPointer + ((2 - 1) * BytesPerWord)), _arg & _rcvr);
							local_stackPointer = _sp;
							/* end pop:thenPush: */
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							goto l163;
						}
						/* begin initPrimCall */
						GIV(primFailCode) = 0;
						/* end initPrimCall */
						{
							GIV(stackPointer) = local_stackPointer;
							primitiveBitAnd();
							local_stackPointer = GIV(stackPointer);
						}
						if (!GIV(primFailCode)) {
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							goto l163;
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (14 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
				l163:
				;
				/* end case */
			}
			BREAK;
			CASE(111)
			{
				/* bytecodePrimBitOr */
				{
					VM_LABEL(bytecodePrimBitOr);
					{
						sqInt t2;
						sqInt t3;
						sqInt _arg;
						sqInt _objOop;
						sqInt _rcvr;
						char *_sp;

						_arg = unsignedLongAt(local_stackPointer);
						_rcvr = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						t2 = ((_arg & 7) == 1);
						if (t2) {
							t3 = ((_rcvr & 7) == 1);
						} else {
							t3 = t2;
						}
						if (t3) {
							/* begin pop:thenPush: */
							unsignedLongAtput((_sp = local_stackPointer + ((2 - 1) * BytesPerWord)), _arg | _rcvr);
							local_stackPointer = _sp;
							/* end pop:thenPush: */
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							goto l168;
						}
						/* begin initPrimCall */
						GIV(primFailCode) = 0;
						/* end initPrimCall */
						{
							GIV(stackPointer) = local_stackPointer;
							primitiveBitOr();
							local_stackPointer = GIV(stackPointer);
						}
						if (!GIV(primFailCode)) {
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							goto l168;
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (15 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
				l168:
				;
				/* end case */
			}
			BREAK;
			CASE(112)
			{
				/* bytecodePrimAt */
				{
					VM_LABEL(bytecodePrimAt);
					{
						sqInt _objOop;

						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (16 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
			}
			BREAK;
			CASE(113)
			{
				/* bytecodePrimAtPut */
				{
					VM_LABEL(bytecodePrimAtPut);
					{
						sqInt _objOop;

						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (17 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 2;
						goto normalSend;
					}
				}
			}
			BREAK;
			CASE(114)
			{
				/* bytecodePrimSize */
				{
					VM_LABEL(bytecodePrimSize);
					{
						sqInt _ccIndex;
						sqInt _ccIndex2;
						sqInt _classOop;
						sqInt _classOop2;
						sqInt _fmt;
						sqInt _fmt2;
						sqInt _isArray;
						sqInt _isString;
						usqInt _numSlots;
						usqInt _numSlots2;
						usqInt _numSlots22;
						usqInt _numSlots3;
						sqInt _objOop;
						sqInt _rcvr;
						sqInt _sz;

						/* begin initPrimCall */
						GIV(primFailCode) = 0;
						/* end initPrimCall */
						_rcvr = unsignedLongAt(local_stackPointer);
						/* begin is:instanceOf:compactClassIndex: */
						_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteString ) << (shiftForWord())) ));
						if (_rcvr & (tagMask())) {
							_isString = 0;
							goto l189;
						}
						/* begin isClassOfNonImm:equalTo:compactClassIndex: */
						assert(!(isImmediate(_rcvr)));
						/* begin classIndexOf: */
						_ccIndex = (longAt(_rcvr)) & (classIndexMask());
						/* end classIndexOf: */
						{
							_isString = ClassByteStringCompactIndex == _ccIndex;
							goto l189;
						}
						/* end isClassOfNonImm:equalTo:compactClassIndex: */
						l189:
						;
						/* end is:instanceOf:compactClassIndex: */
						if (_isString) {
							usqInt t4;

							/* begin lengthOf:format: */
							_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
							/* begin numSlotsOfAny: */
							_numSlots2 = byteAt(_rcvr + 7);
							if (_numSlots2 == (numSlotsMask())) {
								t4 = ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8;
							} else {
								t4 = _numSlots2;
							}
							_numSlots = t4;
							/* end numSlotsOfAny: */
							if (_fmt <= 5) {
								_sz = _numSlots;
								goto l187;
							}
							if (_fmt >= (firstByteFormat())) {
								_sz = (_numSlots << (shiftForWord())) - (_fmt & 7);
								goto l187;
							}
							if (_fmt >= (firstShortFormat())) {
								_sz = (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
								goto l187;
							}
							if (_fmt >= (firstLongFormat())) {
								_sz = (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
								goto l187;
							}
							if (_fmt == (sixtyFourBitIndexableFormat())) {
								_sz = _numSlots;
								goto l187;
							}
							_sz = 0;
							l187:
							;
							/* end lengthOf:format: */
							unsignedLongAtput(local_stackPointer, ((((usqInt) _sz ) << 3) | 1));
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							goto l177;
						}
						/* begin is:instanceOf:compactClassIndex: */
						_classOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ));
						if (_rcvr & (tagMask())) {
							_isArray = 0;
							goto l186;
						}
						/* begin isClassOfNonImm:equalTo:compactClassIndex: */
						assert(!(isImmediate(_rcvr)));
						/* begin classIndexOf: */
						_ccIndex2 = (longAt(_rcvr)) & (classIndexMask());
						/* end classIndexOf: */
						{
							_isArray = ClassArrayCompactIndex == _ccIndex2;
							goto l186;
						}
						/* end isClassOfNonImm:equalTo:compactClassIndex: */
						l186:
						;
						/* end is:instanceOf:compactClassIndex: */
						if (_isArray) {
							usqInt t4;

							/* begin lengthOf:format: */
							_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
							/* begin numSlotsOfAny: */
							_numSlots22 = byteAt(_rcvr + 7);
							if (_numSlots22 == (numSlotsMask())) {
								t4 = ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8;
							} else {
								t4 = _numSlots22;
							}
							_numSlots3 = t4;
							/* end numSlotsOfAny: */
							if (_fmt2 <= 5) {
								_sz = _numSlots3;
								goto l188;
							}
							if (_fmt2 >= (firstByteFormat())) {
								_sz = (_numSlots3 << (shiftForWord())) - (_fmt2 & 7);
								goto l188;
							}
							if (_fmt2 >= (firstShortFormat())) {
								_sz = (_numSlots3 << ((shiftForWord()) - 1)) - (_fmt2 & 3);
								goto l188;
							}
							if (_fmt2 >= (firstLongFormat())) {
								_sz = (_numSlots3 << ((shiftForWord()) - 2)) - (_fmt2 & 1);
								goto l188;
							}
							if (_fmt2 == (sixtyFourBitIndexableFormat())) {
								_sz = _numSlots3;
								goto l188;
							}
							_sz = 0;
							l188:
							;
							/* end lengthOf:format: */
							unsignedLongAtput(local_stackPointer, ((((usqInt) _sz ) << 3) | 1));
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							goto l177;
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (18 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 0;
						goto normalSend;
					}
				}
				l177:
				;
				/* end case */
			}
			BREAK;
			CASE(115)
			{
				/* bytecodePrimNext */
				{
					VM_LABEL(bytecodePrimNext);
					{
						sqInt _objOop;

						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (19 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = (fetchPointerofObject((19 * 2) + 1, splObj(SpecialSelectors))) >> 3;
						goto normalSend;
					}
				}
			}
			BREAK;
			CASE(116)
			{
				/* bytecodePrimNextPut */
				{
					VM_LABEL(bytecodePrimNextPut);
					{
						sqInt _objOop;

						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (20 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = (fetchPointerofObject((20 * 2) + 1, splObj(SpecialSelectors))) >> 3;
						goto normalSend;
					}
				}
			}
			BREAK;
			CASE(117)
			{
				/* bytecodePrimAtEnd */
				{
					VM_LABEL(bytecodePrimAtEnd);
					{
						sqInt _objOop;

						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (21 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = (fetchPointerofObject((21 * 2) + 1, splObj(SpecialSelectors))) >> 3;
						goto normalSend;
					}
				}
			}
			BREAK;
			CASE(118)
			{
				/* bytecodePrimIdenticalSistaV1 */
				{
					VM_LABEL(bytecodePrimIdenticalSistaV1);
					{
						int t2;
						int t3;
						int t5;
						int t6;
						sqInt _arg;
						sqInt _rcvr;

						_rcvr = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						_arg = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
						t2 = (_rcvr & (tagMask())) == 0;
						if (t2) {
							t3 = ((long64At(_rcvr)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
						} else {
							t3 = t2;
						}
						if (t3) {
							_rcvr = handleSpecialSelectorSendFaultForfpsp(_rcvr, local_framePointer, local_stackPointer);
						}
						t5 = (_arg & (tagMask())) == 0;
						if (t5) {
							t6 = ((long64At(_arg)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
						} else {
							t6 = t5;
						}
						if (t6) {
							_arg = handleSpecialSelectorSendFaultForfpsp(_arg, local_framePointer, local_stackPointer);
						}
						/* begin booleanCheatSistaV1: */
						if (_rcvr == _arg) {
							goto booleanCheatTrueSistaV1;
						} else {
							goto booleanCheatFalseSistaV1;
						}
						/* end booleanCheatSistaV1: */
					}
				}
			}
			BREAK;
			CASE(119)
			{
				/* bytecodePrimClass */
				{
					VM_LABEL(bytecodePrimClass);
					{
						int t1;
						int t2;
						sqInt t5;
						sqInt _aValue;
						sqInt _rcvr;
						sqInt _tagBits;

						_rcvr = unsignedLongAt(local_stackPointer);
						t1 = (_rcvr & (tagMask())) == 0;
						if (t1) {
							t2 = ((long64At(_rcvr)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
						} else {
							t2 = t1;
						}
						if (t2) {
							_rcvr = handleSpecialSelectorSendFaultForfpsp(_rcvr, local_framePointer, local_stackPointer);
						}
						/* begin stackTopPut: */
						if (((_tagBits = _rcvr & (tagMask()))) != 0) {
							t5 = unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) ));
						}
 else {
							t5 = fetchClassOfNonImm(_rcvr);
						}
						_aValue = t5;
						unsignedLongAtput(local_stackPointer, _aValue);
						/* end stackTopPut: */
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
					}
				}
			}
			BREAK;
			CASE(120)
			{
				/* bytecodePrimNotIdenticalSistaV1 */
				{
					VM_LABEL(bytecodePrimNotIdenticalSistaV1);
					{
						int t2;
						int t3;
						int t5;
						int t6;
						sqInt _arg;
						sqInt _rcvr;

						_rcvr = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						_arg = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
						t2 = (_rcvr & (tagMask())) == 0;
						if (t2) {
							t3 = ((long64At(_rcvr)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
						} else {
							t3 = t2;
						}
						if (t3) {
							_rcvr = handleSpecialSelectorSendFaultForfpsp(_rcvr, local_framePointer, local_stackPointer);
						}
						t5 = (_arg & (tagMask())) == 0;
						if (t5) {
							t6 = ((long64At(_arg)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
						} else {
							t6 = t5;
						}
						if (t6) {
							_arg = handleSpecialSelectorSendFaultForfpsp(_arg, local_framePointer, local_stackPointer);
						}
						/* begin booleanCheatSistaV1: */
						if (_rcvr != _arg) {
							goto booleanCheatTrueSistaV1;
						} else {
							goto booleanCheatFalseSistaV1;
						}
						/* end booleanCheatSistaV1: */
					}
				}
			}
			BREAK;
			CASE(121)
			{
				/* bytecodePrimValue */
				{
					VM_LABEL(bytecodePrimValue);
					{
						sqInt _ccIndex;
						sqInt _isBlock;
						sqInt _objOop;
						sqInt _rcvr;

						_rcvr = unsignedLongAt(local_stackPointer);
						GIV(argumentCount) = 0;
						/* begin is:instanceOf:compactClassIndex: */
						if (_rcvr & (tagMask())) {
							_isBlock = 0;
							goto l199;
						}
						/* begin isClassOfNonImm:equalTo:compactClassIndex: */
						assert(!(isImmediate(_rcvr)));
						/* begin classIndexOf: */
						_ccIndex = (longAt(_rcvr)) & (classIndexMask());
						/* end classIndexOf: */
						{
							_isBlock = ClassFullBlockClosureCompactIndex == _ccIndex;
							goto l199;
						}
						/* end isClassOfNonImm:equalTo:compactClassIndex: */
						l199:
						;
						/* end is:instanceOf:compactClassIndex: */
						if (_isBlock) {
							/* begin initPrimCall */
							GIV(primFailCode) = 0;
							/* end initPrimCall */
							{
								GIV(framePointer) = local_framePointer;
								GIV(instructionPointer) = local_instructionPointer;
								GIV(stackPointer) = local_stackPointer;
								primitiveFullClosureValue();
								local_framePointer = GIV(framePointer);
								local_instructionPointer = GIV(instructionPointer);
								local_stackPointer = GIV(stackPointer);
							}
							if (!GIV(primFailCode)) {
								/* begin fetchNextBytecode */
								/* begin fetchByte */
								currentBytecode = byteAtPointer(++local_instructionPointer);
								/* end fetchByte */
								/* end fetchNextBytecode */
								goto l198;
							}
							GIV(primFailCode) = 0;
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (25 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						goto normalSend;
					}
				}
				l198:
				;
				/* end case */
			}
			BREAK;
			CASE(122)
			{
				/* bytecodePrimValueWithArg */
				{
					VM_LABEL(bytecodePrimValueWithArg);
					{
						sqInt _ccIndex;
						sqInt _isBlock;
						sqInt _objOop;
						sqInt _rcvr;

						_rcvr = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						GIV(argumentCount) = 1;
						/* begin is:instanceOf:compactClassIndex: */
						if (_rcvr & (tagMask())) {
							_isBlock = 0;
							goto l205;
						}
						/* begin isClassOfNonImm:equalTo:compactClassIndex: */
						assert(!(isImmediate(_rcvr)));
						/* begin classIndexOf: */
						_ccIndex = (longAt(_rcvr)) & (classIndexMask());
						/* end classIndexOf: */
						{
							_isBlock = ClassFullBlockClosureCompactIndex == _ccIndex;
							goto l205;
						}
						/* end isClassOfNonImm:equalTo:compactClassIndex: */
						l205:
						;
						/* end is:instanceOf:compactClassIndex: */
						if (_isBlock) {
							/* begin initPrimCall */
							GIV(primFailCode) = 0;
							/* end initPrimCall */
							{
								GIV(framePointer) = local_framePointer;
								GIV(instructionPointer) = local_instructionPointer;
								GIV(stackPointer) = local_stackPointer;
								primitiveFullClosureValue();
								local_framePointer = GIV(framePointer);
								local_instructionPointer = GIV(instructionPointer);
								local_stackPointer = GIV(stackPointer);
							}
							if (!GIV(primFailCode)) {
								/* begin fetchNextBytecode */
								/* begin fetchByte */
								currentBytecode = byteAtPointer(++local_instructionPointer);
								/* end fetchByte */
								/* end fetchNextBytecode */
								goto l204;
							}
							GIV(primFailCode) = 0;
						}
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (26 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						goto normalSend;
					}
				}
				l204:
				;
				/* end case */
			}
			BREAK;
			CASE(123)
			{
				/* bytecodePrimDo */
				{
					VM_LABEL(bytecodePrimDo);
					{
						sqInt _objOop;

						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (27 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = (fetchPointerofObject((27 * 2) + 1, splObj(SpecialSelectors))) >> 3;
						goto normalSend;
					}
				}
			}
			BREAK;
			CASE(124)
			{
				/* bytecodePrimNew */
				{
					VM_LABEL(bytecodePrimNew);
					{
						sqInt _objOop;

						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (28 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 0;
						goto normalSend;
					}
				}
			}
			BREAK;
			CASE(125)
			{
				/* bytecodePrimNewWithArg */
				{
					VM_LABEL(bytecodePrimNewWithArg);
					{
						sqInt _objOop;

						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (29 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 1;
						goto normalSend;
					}
				}
			}
			BREAK;
			CASE(126)
			{
				/* bytecodePrimPointX */
				{
					VM_LABEL(bytecodePrimPointX);
					{
						sqInt _aValue;
						sqInt _classOop;
						sqInt _objOop;
						sqInt _ok;
						sqInt _rcvr;

						/* begin initPrimCall */
						GIV(primFailCode) = 0;
						/* end initPrimCall */
						_rcvr = unsignedLongAt(local_stackPointer);
						/* begin assertClassOf:is: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassPoint ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						/* begin isNonImmediate: */
						_ok = (_rcvr & (tagMask())) == 0;
						/* end isNonImmediate: */
						if (_ok) {
							/* begin isClassOfNonImm:equalTo: */
							assert(isNonImmediate(_rcvr));
							_ok = ((longAt(_rcvr)) & (classIndexMask())) == ((uint32AtPointer(_classOop + 4)) & (identityHashHalfWordMask()));
							/* end isClassOfNonImm:equalTo: */
						}
						/* begin success: */
						if (!_ok) {
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
						}
						/* end success: */
						/* end assertClassOf:is: */
						if (!GIV(primFailCode)) {
							/* begin stackTopPut: */
							_aValue = unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) XIndex ) << (shiftForWord())) ));
							unsignedLongAtput(local_stackPointer, _aValue);
							/* end stackTopPut: */
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							goto l216;
						}
						GIV(primFailCode) = 0;
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (30 * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 0;
						goto normalSend;
					}
				}
				l216:
				;
				/* end case */
			}
			BREAK;
			CASE(127)
			{
				/* bytecodePrimPointY */
				{
					VM_LABEL(bytecodePrimPointY);
					{
						sqInt _aValue;
						sqInt _classOop;
						sqInt _objOop;
						sqInt _ok;
						sqInt _rcvr;

						/* begin initPrimCall */
						GIV(primFailCode) = 0;
						/* end initPrimCall */
						_rcvr = unsignedLongAt(local_stackPointer);
						/* begin assertClassOf:is: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassPoint ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						/* begin isNonImmediate: */
						_ok = (_rcvr & (tagMask())) == 0;
						/* end isNonImmediate: */
						if (_ok) {
							/* begin isClassOfNonImm:equalTo: */
							assert(isNonImmediate(_rcvr));
							_ok = ((longAt(_rcvr)) & (classIndexMask())) == ((uint32AtPointer(_classOop + 4)) & (identityHashHalfWordMask()));
							/* end isClassOfNonImm:equalTo: */
						}
						/* begin success: */
						if (!_ok) {
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
						}
						/* end success: */
						/* end assertClassOf:is: */
						if (!GIV(primFailCode)) {
							/* begin stackTopPut: */
							_aValue = unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) YIndex ) << (shiftForWord())) ));
							unsignedLongAtput(local_stackPointer, _aValue);
							/* end stackTopPut: */
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							goto l224;
						}
						GIV(primFailCode) = 0;
						/* begin fetchPointer:ofObject: */
						/* begin splObj: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end splObj: */
						GIV(messageSelector) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (0x1F * 2) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						GIV(argumentCount) = 0;
						goto normalSend;
					}
				}
				l224:
				;
				/* end case */
			}
			BREAK;
			CASE(128)
			CASE(129)
			CASE(130)
			CASE(131)
			CASE(132)
			CASE(133)
			CASE(134)
			CASE(135)
			CASE(136)
			CASE(137)
			CASE(138)
			CASE(139)
			CASE(140)
			CASE(141)
			CASE(142)
			CASE(143)
			{
				/* sendLiteralSelector0ArgsBytecode */
				{
					VM_LABEL(sendLiteralSelector0ArgsBytecode);
					{
						sqInt t3;
						sqInt _rcvr;
						sqInt _tagBits;

						{
							assert(GIV(method) == (iframeMethod(local_framePointer)));
							/* begin fetchPointer:ofObject: */
							GIV(messageSelector) = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) ((currentBytecode & 15) + LiteralStart) ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
						}
						GIV(argumentCount) = 0;
						_rcvr = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
						if (((_tagBits = _rcvr & (tagMask()))) != 0) {
							t3 = _tagBits;
						} else {
							t3 = (longAt(_rcvr)) & (classIndexMask());
						}
						lkupClassTag = t3;
						assert(lkupClassTag != (nilObject()));
						goto commonSendOrdinary;
					}
				}
			}
			BREAK;
			CASE(144)
			CASE(145)
			CASE(146)
			CASE(147)
			CASE(148)
			CASE(149)
			CASE(150)
			CASE(151)
			CASE(152)
			CASE(153)
			CASE(154)
			CASE(155)
			CASE(156)
			CASE(157)
			CASE(158)
			CASE(159)
			{
				/* sendLiteralSelector1ArgBytecode */
				{
					VM_LABEL(sendLiteralSelector1ArgBytecode);
					{
						sqInt t3;
						sqInt _rcvr;
						sqInt _tagBits;

						{
							assert(GIV(method) == (iframeMethod(local_framePointer)));
							/* begin fetchPointer:ofObject: */
							GIV(messageSelector) = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) ((currentBytecode & 15) + LiteralStart) ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
						}
						GIV(argumentCount) = 1;
						_rcvr = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
						if (((_tagBits = _rcvr & (tagMask()))) != 0) {
							t3 = _tagBits;
						} else {
							t3 = (longAt(_rcvr)) & (classIndexMask());
						}
						lkupClassTag = t3;
						assert(lkupClassTag != (nilObject()));
						goto commonSendOrdinary;
					}
				}
			}
			BREAK;
			CASE(160)
			CASE(161)
			CASE(162)
			CASE(163)
			CASE(164)
			CASE(165)
			CASE(166)
			CASE(167)
			CASE(168)
			CASE(169)
			CASE(170)
			CASE(171)
			CASE(172)
			CASE(173)
			CASE(174)
			CASE(175)
			{
				/* sendLiteralSelector2ArgsBytecode */
				{
					VM_LABEL(sendLiteralSelector2ArgsBytecode);
					{
						sqInt t3;
						sqInt _rcvr;
						sqInt _tagBits;

						{
							assert(GIV(method) == (iframeMethod(local_framePointer)));
							/* begin fetchPointer:ofObject: */
							GIV(messageSelector) = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) ((currentBytecode & 15) + LiteralStart) ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
						}
						GIV(argumentCount) = 2;
						_rcvr = unsignedLongAt(local_stackPointer + (2 * BytesPerWord));
						if (((_tagBits = _rcvr & (tagMask()))) != 0) {
							t3 = _tagBits;
						} else {
							t3 = (longAt(_rcvr)) & (classIndexMask());
						}
						lkupClassTag = t3;
						assert(lkupClassTag != (nilObject()));
						goto commonSendOrdinary;
					}
				}
			}
			BREAK;
			CASE(176)
			{
				/* shortUnconditionalJump */
				{
					VM_LABEL(shortUnconditionalJump);
					{
						sqInt _offset;

						/* begin jump: */
						_offset = 1;
						local_instructionPointer = (local_instructionPointer + _offset) + 1;
						currentBytecode = byteAtPointer(local_instructionPointer);
						/* end jump: */
					}
				}
			}
			BREAK;
			CASE(177)
			{
				/* shortUnconditionalJump */
				{
					VM_LABEL(shortUnconditionalJump1);
					{
						sqInt _offset;

						/* begin jump: */
						_offset = 2;
						local_instructionPointer = (local_instructionPointer + _offset) + 1;
						currentBytecode = byteAtPointer(local_instructionPointer);
						/* end jump: */
					}
				}
			}
			BREAK;
			CASE(178)
			{
				/* shortUnconditionalJump */
				{
					VM_LABEL(shortUnconditionalJump2);
					{
						sqInt _offset;

						/* begin jump: */
						_offset = 3;
						local_instructionPointer = (local_instructionPointer + _offset) + 1;
						currentBytecode = byteAtPointer(local_instructionPointer);
						/* end jump: */
					}
				}
			}
			BREAK;
			CASE(179)
			{
				/* shortUnconditionalJump */
				{
					VM_LABEL(shortUnconditionalJump3);
					{
						sqInt _offset;

						/* begin jump: */
						_offset = 4;
						local_instructionPointer = (local_instructionPointer + _offset) + 1;
						currentBytecode = byteAtPointer(local_instructionPointer);
						/* end jump: */
					}
				}
			}
			BREAK;
			CASE(180)
			{
				/* shortUnconditionalJump */
				{
					VM_LABEL(shortUnconditionalJump4);
					{
						sqInt _offset;

						/* begin jump: */
						_offset = 5;
						local_instructionPointer = (local_instructionPointer + _offset) + 1;
						currentBytecode = byteAtPointer(local_instructionPointer);
						/* end jump: */
					}
				}
			}
			BREAK;
			CASE(181)
			{
				/* shortUnconditionalJump */
				{
					VM_LABEL(shortUnconditionalJump5);
					{
						sqInt _offset;

						/* begin jump: */
						_offset = 6;
						local_instructionPointer = (local_instructionPointer + _offset) + 1;
						currentBytecode = byteAtPointer(local_instructionPointer);
						/* end jump: */
					}
				}
			}
			BREAK;
			CASE(182)
			{
				/* shortUnconditionalJump */
				{
					VM_LABEL(shortUnconditionalJump6);
					{
						sqInt _offset;

						/* begin jump: */
						_offset = 7;
						local_instructionPointer = (local_instructionPointer + _offset) + 1;
						currentBytecode = byteAtPointer(local_instructionPointer);
						/* end jump: */
					}
				}
			}
			BREAK;
			CASE(183)
			{
				/* shortUnconditionalJump */
				{
					VM_LABEL(shortUnconditionalJump7);
					{
						sqInt _offset;

						/* begin jump: */
						_offset = 8;
						local_instructionPointer = (local_instructionPointer + _offset) + 1;
						currentBytecode = byteAtPointer(local_instructionPointer);
						/* end jump: */
					}
				}
			}
			BREAK;
			CASE(184)
			CASE(185)
			CASE(186)
			CASE(187)
			CASE(188)
			CASE(189)
			CASE(190)
			CASE(191)
			{
				/* shortConditionalJumpTrue */
				{
					VM_LABEL(shortConditionalJumpTrue);
					{
						sqInt _boolean;
						sqInt _offset;

						/* begin jumplfTrueBy: */
						_offset = (currentBytecode & 7) + 1;
						_boolean = unsignedLongAt(local_stackPointer);
						if (_boolean == GIV(trueObj)) {
							/* begin jump: */
							local_instructionPointer = (local_instructionPointer + _offset) + 1;
							currentBytecode = byteAtPointer(local_instructionPointer);
							/* end jump: */
						} else {
							if (!(_boolean == GIV(falseObj))) {
								/* begin internalMustBeBoolean */
								/* begin splObj: */
								/* begin fetchPointer:ofObject: */
								GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorMustBeBoolean ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								/* end splObj: */
								GIV(argumentCount) = 0;
								goto normalSend;
								/* end internalMustBeBoolean */
								goto l237;
							}
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
						}
						/* begin pop: */
						local_stackPointer += 1 * BytesPerWord;
						/* end pop: */
						l237:
						;
						/* end jumplfTrueBy: */
					}
				}
			}
			BREAK;
			CASE(192)
			CASE(193)
			CASE(194)
			CASE(195)
			CASE(196)
			CASE(197)
			CASE(198)
			CASE(199)
			{
				/* shortConditionalJumpFalse */
				{
					VM_LABEL(shortConditionalJumpFalse);
					{
						sqInt _boolean;
						sqInt _offset;

						/* begin jumplfFalseBy: */
						_offset = (currentBytecode & 7) + 1;
						_boolean = unsignedLongAt(local_stackPointer);
						if (_boolean == GIV(falseObj)) {
							/* begin jump: */
							local_instructionPointer = (local_instructionPointer + _offset) + 1;
							currentBytecode = byteAtPointer(local_instructionPointer);
							/* end jump: */
						} else {
							if (!(_boolean == GIV(trueObj))) {
								/* begin internalMustBeBoolean */
								/* begin splObj: */
								/* begin fetchPointer:ofObject: */
								GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorMustBeBoolean ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								/* end splObj: */
								GIV(argumentCount) = 0;
								goto normalSend;
								/* end internalMustBeBoolean */
								goto l241;
							}
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
						}
						/* begin pop: */
						local_stackPointer += 1 * BytesPerWord;
						/* end pop: */
						l241:
						;
						/* end jumplfFalseBy: */
					}
				}
			}
			BREAK;
			CASE(200)
			CASE(201)
			CASE(202)
			CASE(203)
			CASE(204)
			CASE(205)
			CASE(206)
			CASE(207)
			{
				/* storeAndPopReceiverVariableBytecode */
				{
					VM_LABEL(storeAndPopReceiverVariableBytecode);
					{
						int t15;
						int t16;
						int t23;
						int t24;
						sqInt _instVarIndex;
						sqInt _rcvr;
						char *_sp;
						char *_sp2;
						char *_sp3;
						sqInt _top;

						/* begin receiver */
						_rcvr = unsignedLongAt(local_framePointer + FoxIFReceiver);
						/* end receiver */
						/* begin stackTop */
						_top = unsignedLongAt(local_stackPointer);
						/* end stackTop */
						_instVarIndex = currentBytecode & 7;
						/* begin pop: */
						local_stackPointer += 1 * BytesPerWord;
						/* end pop: */
						/* begin storePointerImmutabilityCheck:ofObject:withValue: */
						
#            if IMMUTABILITY
						{
							assert(!(isImmediate(_rcvr)));
							if (((((usqInt) (longAt(_rcvr)) ) >> (immutableBitShift())) & 1) != 0) {
								/* begin cannotAssign:to:withIndex: */
								/* begin push: */
								unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _rcvr);
								local_stackPointer = _sp;
								/* end push: */
								/* begin push: */
								unsignedLongAtput((_sp2 = local_stackPointer - BytesPerWord), _top);
								local_stackPointer = _sp2;
								/* end push: */
								/* begin push: */
								unsignedLongAtput((_sp3 = local_stackPointer - BytesPerWord), ((((usqInt) (_instVarIndex + 1) ) << 3) | 1));
								local_stackPointer = _sp3;
								/* end push: */
								/* begin splObj: */
								/* begin fetchPointer:ofObject: */
								GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorAttemptToAssign ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								/* end splObj: */
								GIV(argumentCount) = 2;
								goto normalSend;
								goto l251;
								l251:
								;
								/* end cannotAssign:to:withIndex: */
								goto l249;
							}
						}
#            endif /* IMMUTABILITY */
						/* begin storePointer:ofObject:withValue: */
						assert(!(isForwarded(_rcvr)));
						t15 = (_rcvr & (tagMask())) == 0;
						if (t15) {
							t16 = (_rcvr & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask));
						} else {
							t16 = t15;
						}
						if (t16) {
							int t0;
							int t1;

							t0 = (_top & (tagMask())) == 0;
							if (t0) {
								int t0;

								t0 = (_top & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask));
								if (t0) {
									t1 = _top >= ((GIV(memoryMap)->newSpaceStart));
								} else {
									t1 = t0;
								}
							} else {
								t1 = t0;
							}
							if (t1) {
								/* begin possibleOldObjectStoreInto: */
								if (!(((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0)) {
									remember(GIV(fromOldSpaceRememberedSet), _rcvr);
								}
								/* end possibleOldObjectStoreInto: */
							}
						}
						/* begin possiblePermObjectStoreInto:value: */
						if (((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0) {
							goto l246;
						}
						if (_top & (tagMask())) {
							goto l246;
						}
						if (!(_rcvr >= 0x20000000000LL)) {
							goto l246;
						}
						if (_top >= 0x20000000000LL) {
							goto l246;
						}
						t23 = _top >= GIV(nilObj);
						if (t23) {
							t24 = _top <= GIV(trueObj);
						} else {
							t24 = t23;
						}
						if (t24) {
							goto l246;
						}
						if (!(_top >= (startOfObjectMemory(GIV(memoryMap))))) {
							goto l246;
						}
						remember(getFromPermToNewSpaceRememberedSet(), _rcvr);
						l246:
						;
						/* end possiblePermObjectStoreInto:value: */
						unsignedLongAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _instVarIndex ) << (shiftForWord())) ), _top);
						/* end storePointer:ofObject:withValue: */
						l249:
						;
						/* end storePointerImmutabilityCheck:ofObject:withValue: */
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
					}
				}
			}
			BREAK;
			CASE(208)
			{
				/* storeAndPopTemporaryVariableBytecode */
				{
					VM_LABEL(storeAndPopTemporaryVariableBytecode);
					{
						sqInt _frameNumArgs;
						sqInt _valueOop;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin itemporary:in:put: */
							_valueOop = unsignedLongAt(local_stackPointer);
							if (0 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								unsignedLongAtput((local_framePointer + FoxCallerSavedIP) + (_frameNumArgs * BytesPerWord), _valueOop);
							}
 else {
								unsignedLongAtput(((local_framePointer + FoxIFReceiver) - BytesPerWord) + (_frameNumArgs * BytesPerWord), _valueOop);
							}
							/* end itemporary:in:put: */
							/* begin pop: */
							local_stackPointer += 1 * BytesPerWord;
							/* end pop: */
						}
					}
				}
			}
			BREAK;
			CASE(209)
			{
				/* storeAndPopTemporaryVariableBytecode */
				{
					VM_LABEL(storeAndPopTemporaryVariableBytecode1);
					{
						sqInt _frameNumArgs;
						sqInt _valueOop;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin itemporary:in:put: */
							_valueOop = unsignedLongAt(local_stackPointer);
							if (1 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								unsignedLongAtput((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 1) * BytesPerWord), _valueOop);
							}
 else {
								unsignedLongAtput(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 1) * BytesPerWord), _valueOop);
							}
							/* end itemporary:in:put: */
							/* begin pop: */
							local_stackPointer += 1 * BytesPerWord;
							/* end pop: */
						}
					}
				}
			}
			BREAK;
			CASE(210)
			{
				/* storeAndPopTemporaryVariableBytecode */
				{
					VM_LABEL(storeAndPopTemporaryVariableBytecode2);
					{
						sqInt _frameNumArgs;
						sqInt _valueOop;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin itemporary:in:put: */
							_valueOop = unsignedLongAt(local_stackPointer);
							if (2 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								unsignedLongAtput((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 2) * BytesPerWord), _valueOop);
							}
 else {
								unsignedLongAtput(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 2) * BytesPerWord), _valueOop);
							}
							/* end itemporary:in:put: */
							/* begin pop: */
							local_stackPointer += 1 * BytesPerWord;
							/* end pop: */
						}
					}
				}
			}
			BREAK;
			CASE(211)
			{
				/* storeAndPopTemporaryVariableBytecode */
				{
					VM_LABEL(storeAndPopTemporaryVariableBytecode3);
					{
						sqInt _frameNumArgs;
						sqInt _valueOop;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin itemporary:in:put: */
							_valueOop = unsignedLongAt(local_stackPointer);
							if (3 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								unsignedLongAtput((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 3) * BytesPerWord), _valueOop);
							}
 else {
								unsignedLongAtput(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 3) * BytesPerWord), _valueOop);
							}
							/* end itemporary:in:put: */
							/* begin pop: */
							local_stackPointer += 1 * BytesPerWord;
							/* end pop: */
						}
					}
				}
			}
			BREAK;
			CASE(212)
			{
				/* storeAndPopTemporaryVariableBytecode */
				{
					VM_LABEL(storeAndPopTemporaryVariableBytecode4);
					{
						sqInt _frameNumArgs;
						sqInt _valueOop;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin itemporary:in:put: */
							_valueOop = unsignedLongAt(local_stackPointer);
							if (4 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								unsignedLongAtput((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 4) * BytesPerWord), _valueOop);
							}
 else {
								unsignedLongAtput(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 4) * BytesPerWord), _valueOop);
							}
							/* end itemporary:in:put: */
							/* begin pop: */
							local_stackPointer += 1 * BytesPerWord;
							/* end pop: */
						}
					}
				}
			}
			BREAK;
			CASE(213)
			{
				/* storeAndPopTemporaryVariableBytecode */
				{
					VM_LABEL(storeAndPopTemporaryVariableBytecode5);
					{
						sqInt _frameNumArgs;
						sqInt _valueOop;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin itemporary:in:put: */
							_valueOop = unsignedLongAt(local_stackPointer);
							if (5 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								unsignedLongAtput((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 5) * BytesPerWord), _valueOop);
							}
 else {
								unsignedLongAtput(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 5) * BytesPerWord), _valueOop);
							}
							/* end itemporary:in:put: */
							/* begin pop: */
							local_stackPointer += 1 * BytesPerWord;
							/* end pop: */
						}
					}
				}
			}
			BREAK;
			CASE(214)
			{
				/* storeAndPopTemporaryVariableBytecode */
				{
					VM_LABEL(storeAndPopTemporaryVariableBytecode6);
					{
						sqInt _frameNumArgs;
						sqInt _valueOop;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin itemporary:in:put: */
							_valueOop = unsignedLongAt(local_stackPointer);
							if (6 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								unsignedLongAtput((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 6) * BytesPerWord), _valueOop);
							}
 else {
								unsignedLongAtput(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 6) * BytesPerWord), _valueOop);
							}
							/* end itemporary:in:put: */
							/* begin pop: */
							local_stackPointer += 1 * BytesPerWord;
							/* end pop: */
						}
					}
				}
			}
			BREAK;
			CASE(215)
			{
				/* storeAndPopTemporaryVariableBytecode */
				{
					VM_LABEL(storeAndPopTemporaryVariableBytecode7);
					{
						sqInt _frameNumArgs;
						sqInt _valueOop;

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin itemporary:in:put: */
							_valueOop = unsignedLongAt(local_stackPointer);
							if (7 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
								unsignedLongAtput((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - 7) * BytesPerWord), _valueOop);
							}
 else {
								unsignedLongAtput(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - 7) * BytesPerWord), _valueOop);
							}
							/* end itemporary:in:put: */
							/* begin pop: */
							local_stackPointer += 1 * BytesPerWord;
							/* end pop: */
						}
					}
				}
			}
			BREAK;
			CASE(216)
			{
				/* popStackBytecode */
				{
					VM_LABEL(popStackBytecode);
					{
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin pop: */
						local_stackPointer += 1 * BytesPerWord;
						/* end pop: */
					}
				}
			}
			BREAK;
			CASE(217)
			{
				/* unconditionnalTrapBytecode */
				{
					VM_LABEL(unconditionnalTrapBytecode);
					{
						{
							goto respondToUnknownBytecode;
							goto l257;
						}
					}
				}
				l257:
				;
				/* end case */
			}
			BREAK;
			CASE(218)
			CASE(219)
			CASE(220)
			CASE(221)
			CASE(222)
			CASE(223)
			CASE(230)
			CASE(246)
			CASE(247)
			CASE(250)
			CASE(254)
			CASE(255)
			{
				/* unknownBytecode */
				{
					VM_LABEL(unknownBytecode1);
					{
						goto respondToUnknownBytecode;
					}
				}
			}
			BREAK;
			CASE(224)
			{
				/* extABytecode */
				{
					VM_LABEL(extABytecode);
					{
						extA = (((usqInt) extA ) << 8) + (byteAtPointer(++local_instructionPointer));
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
					}
				}
			}
			BREAK;
			CASE(225)
			{
				/* extBBytecode */
				{
					VM_LABEL(extBBytecode);
					{
						int t6;
						int t7;
						sqInt t8;
						sqInt _byte;

						_byte = byteAtPointer(++local_instructionPointer);
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						t6 = numExtB == 0;
						if (t6) {
							t7 = _byte > 0x7F;
						} else {
							t7 = t6;
						}
						if (t7) {
							t8 = _byte - 256;
						}
 else {
							t8 = (((usqInt) extB ) << 8) + _byte;
						}
						extB = t8;
						numExtB += 1;
					}
				}
			}
			BREAK;
			CASE(226)
			{
				/* extPushReceiverVariableBytecode */
				{
					VM_LABEL(extPushReceiverVariableBytecode);
					{
						int t10;
						int t11;
						sqInt _index2;
						sqInt _obj;
						sqInt _object;
						sqInt _object2;
						char *_sp;
						char *_sp2;

						_index2 = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) extA ) << 8) );
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						extA = 0;
						/* begin pushMaybeContextReceiverVariable: */
						/* begin pushMaybeContext:receiverVariable: */
						_obj = unsignedLongAt(local_framePointer + FoxIFReceiver);
						t10 = _index2 <= StackPointerIndex;
						if (t10) {
							t11 = ((longAt(_obj)) & (classIndexMask())) == ClassMethodContextCompactIndex;
						} else {
							t11 = t10;
						}
						if (t11) {
							sqInt t1;

							/* begin push: */
							{
								GIV(framePointer) = local_framePointer;
								GIV(instructionPointer) = local_instructionPointer;
								GIV(stackPointer) = local_stackPointer;
								t1 = instVarofContext(_index2, _obj);
								local_framePointer = GIV(framePointer);
								local_instructionPointer = GIV(instructionPointer);
								local_stackPointer = GIV(stackPointer);
							}
							_object = t1;
							unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
							local_stackPointer = _sp;
							/* end push: */
						} else {
							/* begin push: */
							_object2 = unsignedLongAt((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) _index2 ) << (shiftForWord())) ));
							unsignedLongAtput((_sp2 = local_stackPointer - BytesPerWord), _object2);
							local_stackPointer = _sp2;
							/* end push: */
						}
						/* end pushMaybeContext:receiverVariable: */
						/* end pushMaybeContextReceiverVariable: */
					}
				}
			}
			BREAK;
			CASE(227)
			{
				/* extPushLiteralVariableBytecode */
				{
					VM_LABEL(extPushLiteralVariableBytecode);
					{
						sqInt _index2;
						sqInt _litVar;
						sqInt _object;
						char *_sp;

						_index2 = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) extA ) << 8) );
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						extA = 0;
						/* begin pushLiteralVariable: */
						{
							assert(GIV(method) == (iframeMethod(local_framePointer)));
							/* begin fetchPointer:ofObject: */
							_litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_index2 + LiteralStart) ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
						}
						if (((long64At(_litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
							_litVar = unfollowatIndex(_litVar, _index2);
						}
						/* begin push: */
						_object = unsignedLongAt((_litVar + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
						local_stackPointer = _sp;
						/* end push: */
						/* end pushLiteralVariable: */
					}
				}
			}
			BREAK;
			CASE(228)
			{
				/* extPushLiteralBytecode */
				{
					VM_LABEL(extPushLiteralBytecode);
					{
						sqInt _index2;
						char *_sp;

						_index2 = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) extA ) << 8) );
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						extA = 0;
						/* begin pushLiteralConstant: */
						/* begin push: */
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), (assert(GIV(method) == (iframeMethod(local_framePointer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_index2 + LiteralStart) ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */));
						local_stackPointer = _sp;
						/* end push: */
						/* end pushLiteralConstant: */
					}
				}
			}
			BREAK;
			CASE(229)
			{
				/* longPushTemporaryVariableBytecode */
				{
					VM_LABEL(longPushTemporaryVariableBytecode);
					{
						sqInt t9;
						sqInt _frameNumArgs;
						sqInt _index2;
						sqInt _object;
						char *_sp;

						/* begin fetchByte */
						_index2 = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin push: */
						if (_index2 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
							t9 = unsignedLongAt((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - _index2) * BytesPerWord));
						}
 else {
							t9 = unsignedLongAt(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - _index2) * BytesPerWord));
						}
						_object = t9;
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
						local_stackPointer = _sp;
						/* end push: */
					}
				}
			}
			BREAK;
			CASE(231)
			{
				/* pushNewArrayBytecode */
				{
					VM_LABEL(pushNewArrayBytecode);
					{
						usqInt _array;
						sqInt _i;
						usqInt _newObj;
						usqInt _numBytes;
						int _popValues;
						sqInt _size;
						char *_sp;
						sqInt _valuePointer;
						sqInt _valuePointer2;

						/* begin fetchByte */
						_size = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						_popValues = _size > 0x7F;
						_size = _size & 0x7F;
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin eeInstantiateSmallClassIndex:format:numSlots: */
						assert((_size >= 0) && ((classAtIndex(ClassArrayCompactIndex)) != GIV(nilObj)));
						assert(2 == (instSpecOfClass(classAtIndex(ClassArrayCompactIndex))));
						/* begin allocateSmallNewSpaceSlots:format:classIndex: */
						assert(_size < (numSlotsMask()));
						_newObj = GIV(freeStart);
						_numBytes = BaseHeaderSize + (((_size < 1)
							 ? 8
							 : _size * BytesPerOop));
						assert((_numBytes % (allocationUnit())) == 0);
						assert((_newObj % (allocationUnit())) == 0);
						if ((GIV(freeStart) + _numBytes) > GIV(scavengeThreshold)) {
							if (!GIV(needGCFlag)) {
								/* begin scheduleScavenge */
								GIV(needGCFlag) = 1;
								forceInterruptCheck();
								/* end scheduleScavenge */
							}
							if ((GIV(freeStart) + _numBytes) > (((eden()).limit))) {
								error("no room in eden for allocateSmallNewSpaceSlots:format:classIndex:");
								_array = 0;
								goto l269;
							}
						}
						long64Atput(_newObj, ((((usqLong) _size ) << (numSlotsFullShift())) + (2U << (formatShift()))) + ClassArrayCompactIndex);
						GIV(freeStart) += _numBytes;
						_array = _newObj;
						/* end allocateSmallNewSpaceSlots:format:classIndex: */
						l269:
						;
						/* end eeInstantiateSmallClassIndex:format:numSlots: */
						if (_popValues) {
							for (_i = 0; _i < _size; _i += 1) {
								/* begin storePointerUnchecked:ofObject:withValue: */
								_valuePointer = unsignedLongAt(local_stackPointer + (((_size - _i) - 1) * BytesPerWord));
								assert(!(isOopForwarded(_array)));
								longAtput((_array + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _valuePointer);
								/* end storePointerUnchecked:ofObject:withValue: */
							}
							/* begin pop: */
							local_stackPointer += _size * BytesPerWord;
							/* end pop: */
						} else {
							for (_i = 0; _i < _size; _i += 1) {
								/* begin storePointerUnchecked:ofObject:withValue: */
								_valuePointer2 = GIV(nilObj);
								assert(!(isOopForwarded(_array)));
								longAtput((_array + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _valuePointer2);
								/* end storePointerUnchecked:ofObject:withValue: */
							}
						}
						/* begin push: */
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _array);
						local_stackPointer = _sp;
						/* end push: */
					}
				}
			}
			BREAK;
			CASE(232)
			{
				/* extPushIntegerBytecode */
				{
					VM_LABEL(extPushIntegerBytecode);
					{
						char *_sp;
						sqInt _value;

						_value = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) extB ) << 8) );
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						extB = 0;
						numExtB = 0;
						/* begin push: */
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), ((((usqInt) _value ) << 3) | 1));
						local_stackPointer = _sp;
						/* end push: */
					}
				}
			}
			BREAK;
			CASE(233)
			{
				/* extPushCharacterBytecode */
				{
					VM_LABEL(extPushCharacterBytecode);
					{
						sqInt _object;
						char *_sp;
						sqInt _value;

						_value = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) extB ) << 8) );
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin push: */
						_object = ((sqInt) (((usqInt) _value ) << (numTagBits())) ) + (characterTag());
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
						local_stackPointer = _sp;
						/* end push: */
						numExtB = (extB = 0);
					}
				}
			}
			BREAK;
			CASE(234)
			{
				/* extSendBytecode */
				{
					VM_LABEL(extSendBytecode);
					{
						sqInt _byte;

						_byte = byteAtPointer(++local_instructionPointer);
						{
							assert(GIV(method) == (iframeMethod(local_framePointer)));
							/* begin literal:ofMethod: */
							/* begin fetchPointer:ofObject: */
							GIV(messageSelector) = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (((((usqInt) _byte ) >> 3) + ((sqInt) (((usqInt) extA ) << 5) )) + LiteralStart) ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							/* end literal:ofMethod: */
						}
						extA = 0;
						GIV(argumentCount) = (_byte & 7) + ((sqInt) (((usqInt) extB ) << 3) );
						extB = 0;
						numExtB = 0;
						/* goto normalSend */
					}
				}
				normalSend:
/* normalSend */
				{
					VM_LABEL(normalSend);
					{
						sqInt t1;
						sqInt _rcvr;
						sqInt _tagBits;

						_rcvr = unsignedLongAt(local_stackPointer + (GIV(argumentCount) * BytesPerWord));
						if (((_tagBits = _rcvr & (tagMask()))) != 0) {
							t1 = _tagBits;
						} else {
							t1 = (longAt(_rcvr)) & (classIndexMask());
						}
						lkupClassTag = t1;
						assert(lkupClassTag != (nilObject()));
						commonSendOrdinary:
/* commonSendOrdinary */
						{
							VM_LABEL(commonSendOrdinary);
							{
								sqInt _classOrInteger;
								sqInt _classTablePage;
								sqInt _classTablePage2;
								sqInt _classTag2;
								CogMethod *_cogMethod;
								CogMethod *_cogMethod2;
								sqInt _fieldIndex;
								sqInt _fieldIndex2;
								sqInt _fieldIndex22;
								sqInt _fieldIndex3;
								sqInt _inInterpreter;
								sqInt _methodHeader;
								sqInt _methodHeader2;
								sqInt _nArgs;
								sqInt _rcvr;
								sqInt _referent;
								char *_savedFramePointer;
								char *_savedStackPointer;
								sqInt _selector;
								sqInt _selector2;
								sqInt _succeeded;

								/* begin sendBreakpoint:receiver: */
								_rcvr = unsignedLongAt(local_stackPointer + (GIV(argumentCount) * BytesPerWord));
								_nArgs = 0;
								_savedFramePointer = ((char *) 0 );
								_savedStackPointer = ((char *) 0 );
								sendBreakpointreceiver(firstFixedFieldOfMaybeImmediate(GIV(messageSelector)), lengthOfMaybeImmediate(GIV(messageSelector)), _rcvr);
								/* end sendBreakpoint:receiver: */
								/* begin doRecordSendTrace */
								if (recordSendTrace()) {
									/* begin recordTrace:thing:source: */
									/* begin classAtIndex: */
									assert((lkupClassTag >= 0) && ((lkupClassTag <= (tagMask())) || ((lkupClassTag >= (arrayClassIndexPun())) && (lkupClassTag <= (classIndexMask())))));
									/* begin fetchPointer:ofObject: */
									_fieldIndex2 = ((usqInt) lkupClassTag ) >> (classTableMajorIndexShift());
									_classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									if (_classTablePage == GIV(nilObj)) {
										_classOrInteger = null;
									} else {
										/* begin fetchPointer:ofObject: */
										_fieldIndex = lkupClassTag & ((1U << (classTableMajorIndexShift())) - 1);
										_classOrInteger = unsignedLongAt((_classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
										/* end fetchPointer:ofObject: */
									}
									/* end classAtIndex: */
									GIV(traceLog)[GIV(traceLogIndex)] = _classOrInteger;
									GIV(traceLog)[GIV(traceLogIndex) + 1] = GIV(messageSelector);
									GIV(traceLog)[GIV(traceLogIndex) + 2] = TraceIsFromInterpreter;
									GIV(traceLogIndex) = (GIV(traceLogIndex) + 3) % TraceBufferSize;
									/* end recordTrace:thing:source: */
									{
										if (printOnTrace()) {
											{
												printActivationNameForSelectorstartClass(GIV(messageSelector), classAtIndex(lkupClassTag));
												/* begin cr */
												print("\n");
												/* end cr */
											}
										}
									}
								}
								/* end doRecordSendTrace */
								/* begin findNewMethodOrdinaryIfFound: */
								/* begin findNewMethodInClassTag:ifFound: */
								_classTag2 = lkupClassTag;
								if (inlineLookupInMethodCacheSelclassTag(GIV(messageSelector), _classTag2)) {
									{
										/* begin ifAppropriateCompileToNativeCode:selector: */
										_selector2 = GIV(messageSelector);
										/* begin fetchPointer:ofObject: */
										_methodHeader2 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
										/* end fetchPointer:ofObject: */
										if ((assert((((_methodHeader2 & 7) == 1)) || ((((usqInt) _methodHeader2 ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader2 ) >= (minCogMethodAddress())))), (_methodHeader2 & (smallIntegerTag())) == 0)) {
											_cogMethod2 = ((CogMethod *) _methodHeader2 );
											if (((_cogMethod2->selector)) == GIV(nilObj)) {
												setSelectorOfto(_cogMethod2, _selector2);
											}
										} else {
											if (((assert(((_methodHeader2 & 7) == 1)), (_methodHeader2 >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
												cogselector(GIV(newMethod), _selector2);
											}
 else {
												maybeFlagMethodAsInterpreted(GIV(newMethod));
											}
										}
										/* end ifAppropriateCompileToNativeCode:selector: */
									}
								} else {
									int t0;
									int t1;
									int t12;
									int t13;
									int t2;

									t0 = (GIV(messageSelector) & (tagMask())) == 0;
									if (t0) {
										t1 = ((long64At(GIV(messageSelector))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
									} else {
										t1 = t0;
									}
									if (t1) {
										t2 = t1;
									} else {
										t2 = _classTag2 == (isForwardedObjectClassIndexPun());
									}
									if (t2) {
										int t0;
										int t1;

										t0 = (GIV(messageSelector) & (tagMask())) == 0;
										if (t0) {
											t1 = ((long64At(GIV(messageSelector))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
										} else {
											t1 = t0;
										}
										if (t1) {
											sqInt t0;

											{
												GIV(framePointer) = local_framePointer;
												t0 = handleForwardedSelectorFaultFor(GIV(messageSelector));
												local_framePointer = GIV(framePointer);
											}
											GIV(messageSelector) = t0;
										}
										if (_classTag2 == (isForwardedObjectClassIndexPun())) {
											sqInt t0;

											{
												GIV(framePointer) = local_framePointer;
												GIV(stackPointer) = local_stackPointer;
												t0 = handleForwardedSendFaultForTag(_classTag2);
												local_framePointer = GIV(framePointer);
												local_stackPointer = GIV(stackPointer);
											}
											_classTag2 = t0;
										}
										if (lookupInMethodCacheSelclassTag(GIV(messageSelector), _classTag2)) {
											{
												/* begin ifAppropriateCompileToNativeCode:selector: */
												_selector = GIV(messageSelector);
												/* begin fetchPointer:ofObject: */
												_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
												/* end fetchPointer:ofObject: */
												if ((assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0)) {
													_cogMethod = ((CogMethod *) _methodHeader );
													if (((_cogMethod->selector)) == GIV(nilObj)) {
														setSelectorOfto(_cogMethod, _selector);
													}
												} else {
													if (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
														cogselector(GIV(newMethod), _selector);
													}
 else {
														maybeFlagMethodAsInterpreted(GIV(newMethod));
													}
												}
												/* end ifAppropriateCompileToNativeCode:selector: */
											}
											goto l534;
										}
									}
									/* begin classAtIndex: */
									assert((_classTag2 >= 0) && ((_classTag2 <= (tagMask())) || ((_classTag2 >= (arrayClassIndexPun())) && (_classTag2 <= (classIndexMask())))));
									/* begin fetchPointer:ofObject: */
									_fieldIndex22 = ((usqInt) _classTag2 ) >> (classTableMajorIndexShift());
									_classTablePage2 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex22 ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									if (_classTablePage2 == GIV(nilObj)) {
										GIV(lkupClass) = null;
									} else {
										/* begin fetchPointer:ofObject: */
										_fieldIndex3 = _classTag2 & ((1U << (classTableMajorIndexShift())) - 1);
										GIV(lkupClass) = unsignedLongAt((_classTablePage2 + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex3 ) << (shiftForWord())) ));
										/* end fetchPointer:ofObject: */
									}
									/* end classAtIndex: */
									t12 = (GIV(lkupClass) & (tagMask())) == 0;
									if (t12) {
										t13 = ((long64At(GIV(lkupClass))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
									} else {
										t13 = t12;
									}
									if (t13) {
										/* begin followForwarded: */
										assert(isUnambiguouslyForwarder(GIV(lkupClass)));
										/* begin fetchPointer:ofMaybeForwardedObject: */
										_referent = unsignedLongAt((GIV(lkupClass) + BaseHeaderSize) + (0U << (shiftForWord())));
										/* end fetchPointer:ofMaybeForwardedObject: */
										while (1) {
											int t0;

											t0 = (_referent & (tagMask())) == 0;
											if (!(((t0)
												 ? ((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0
												 : 0))) 
												break;
											/* begin fetchPointer:ofMaybeForwardedObject: */
											_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
											/* end fetchPointer:ofMaybeForwardedObject: */
										}
										GIV(lkupClass) = _referent;
										/* end followForwarded: */
									}
									{
										GIV(stackPointer) = local_stackPointer;
										lookupMethodInClass(GIV(lkupClass));
										local_stackPointer = GIV(stackPointer);
									}
									addNewMethodToCache(GIV(lkupClass));
								}
								/* end findNewMethodInClassTag:ifFound: */
								l534:
								;
								/* end findNewMethodOrdinaryIfFound: */
								/* begin executeNewMethod: */
								_inInterpreter = !(((usqInt) ((usqInt) local_instructionPointer ) ) < (startOfObjectMemory(getMemoryMap())));
								/* begin executePrimitiveFromInterpreter:ifFail: */
								if (primitiveFunctionPointer != 0) {
									int t18;

									if (((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex) {
										sqInt t2;

										{
											GIV(stackPointer) = local_stackPointer;
											executeQuickPrimitive();
											local_stackPointer = GIV(stackPointer);
										}
										/* begin returnToExecutive: */
										{
											GIV(stackPointer) = local_stackPointer;
											t2 = popStack();
											local_stackPointer = GIV(stackPointer);
										}
										{
											GIV(framePointer) = local_framePointer;
											GIV(instructionPointer) = local_instructionPointer;
											GIV(stackPointer) = local_stackPointer;
											returntoExecutive(t2, _inInterpreter);
											local_framePointer = GIV(framePointer);
											local_instructionPointer = GIV(instructionPointer);
											local_stackPointer = GIV(stackPointer);
										}
										/* end returnToExecutive: */
										goto l531;
									}
									/* begin slowPrimitiveResponse */
									if (recordPrimTrace()) {
										/* begin fastLogPrim: */
										GIV(primTraceLog)[GIV(primTraceLogIndex)] = GIV(messageSelector);
										primTraceLogIndex(GIV(primTraceLogIndex) + 1);
										/* end fastLogPrim: */
									}
									assert((remapBufferCount()) == 0);
									{
										_nArgs = GIV(argumentCount);
										_savedStackPointer = local_stackPointer;
										_savedFramePointer = local_framePointer;
									}
									/* begin initPrimCall */
									GIV(primFailCode) = 0;
									/* end initPrimCall */
									/* begin dispatchFunctionPointer: */
									{
										GIV(framePointer) = local_framePointer;
										GIV(instructionPointer) = local_instructionPointer;
										GIV(stackPointer) = local_stackPointer;
										primitiveFunctionPointer();
										local_framePointer = GIV(framePointer);
										local_instructionPointer = GIV(instructionPointer);
										local_stackPointer = GIV(stackPointer);
									}
									/* end dispatchFunctionPointer: */
									assert(maybeLeakCheckExternalPrimCall(GIV(newMethod)));
									/* begin maybeRetryPrimitiveOnFailure */
									if (GIV(primFailCode)) {
										{
											GIV(framePointer) = local_framePointer;
											GIV(instructionPointer) = local_instructionPointer;
											GIV(stackPointer) = local_stackPointer;
											retryPrimitiveOnFailure();
											local_framePointer = GIV(framePointer);
											local_instructionPointer = GIV(instructionPointer);
											local_stackPointer = GIV(stackPointer);
										}
									}
									/* end maybeRetryPrimitiveOnFailure */
									/* begin maybeFailForLastObjectOverwrite */
									if (checkAllocFiller) {
										int t0;
										int t1;

										t0 = (freeStart0()) < GIV(scavengeThreshold);
										if (t0) {
											t1 = (unsignedLongAt(freeStart0())) != (freeStart0());
										} else {
											t1 = t0;
										}
										if (t1) {
											/* begin primitiveFailFor: */
											GIV(primFailCode) = PrimErrWritePastObject;
											/* end primitiveFailFor: */
										}
									}
									/* end maybeFailForLastObjectOverwrite */
									{
										int t0;

										t0 = !GIV(primFailCode);
										if (t0) {
											int t0;

											t0 = local_framePointer == _savedFramePointer;
											if (t0) {
												t18 = !(isMachineCodeIP(((usqInt) (unsignedLongAt(local_framePointer + FoxMethod)) )));
											} else {
												t18 = t0;
											}
										} else {
											t18 = t0;
										}
									}
									if (t18) {
										if (local_stackPointer != (_savedStackPointer + (_nArgs * BytesPerWord))) {
											flag("Would be nice to make this a message send of e.g. unbalancedPrimitive to the current process or context");
											failUnbalancedPrimitive();
											local_stackPointer = _savedStackPointer;
										}
									}
									if (GIV(nextProfileTick) > 0) {
										checkProfileTick(GIV(newMethod));
									}
									_succeeded = !GIV(primFailCode);
									goto l533;
									l533:
									;
									/* end slowPrimitiveResponse */
									if (_succeeded) {
										sqInt t1;

										/* begin returnToExecutive: */
										{
											GIV(stackPointer) = local_stackPointer;
											t1 = popStack();
											local_stackPointer = GIV(stackPointer);
										}
										{
											GIV(framePointer) = local_framePointer;
											GIV(instructionPointer) = local_instructionPointer;
											GIV(stackPointer) = local_stackPointer;
											returntoExecutive(t1, _inInterpreter);
											local_framePointer = GIV(framePointer);
											local_instructionPointer = GIV(instructionPointer);
											local_stackPointer = GIV(stackPointer);
										}
										/* end returnToExecutive: */
										goto l531;
									}
								}
								{
									{
										GIV(framePointer) = local_framePointer;
										GIV(instructionPointer) = local_instructionPointer;
										GIV(stackPointer) = local_stackPointer;
										activateNewMethod();
										local_framePointer = GIV(framePointer);
										local_instructionPointer = GIV(instructionPointer);
										local_stackPointer = GIV(stackPointer);
									}
								}
								l531:
								;
								/* end executePrimitiveFromInterpreter:ifFail: */
								/* end executeNewMethod: */
								/* begin fetchNextBytecode */
								/* begin fetchByte */
								currentBytecode = byteAtPointer(++local_instructionPointer);
								/* end fetchByte */
								/* end fetchNextBytecode */
							}
						}
					}
				}
			}
			BREAK;
			CASE(235)
			{
				/* extSendSuperBytecode */
				{
					VM_LABEL(extSendSuperBytecode);
					{
						int t17;
						int t18;
						int t23;
						int t24;
						int t31;
						int t32;
						sqInt _byte;
						sqInt _class;
						sqInt _classPointer;
						sqInt _err;
						sqInt _err2;
						sqInt _hash;
						sqInt _hash2;
						sqInt _literal;
						usqInt _methodPointer;
						sqInt _objOop;
						sqInt _objOop2;
						sqInt _objOop22;
						sqInt _objOop23;
						sqInt _objOop3;
						sqInt _objOop4;
						sqInt _offset;
						sqInt _oop;
						sqInt _oop2;
						sqInt _referent;
						sqInt _referent2;
						sqInt _referent3;
						sqInt _superclass;
						sqInt _superclass2;
						sqInt _top;

						_byte = byteAtPointer(++local_instructionPointer);
						{
							assert(GIV(method) == (iframeMethod(local_framePointer)));
							/* begin literal:ofMethod: */
							/* begin fetchPointer:ofObject: */
							GIV(messageSelector) = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (((((usqInt) _byte ) >> 3) + ((sqInt) (((usqInt) extA ) << 5) )) + LiteralStart) ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							/* end literal:ofMethod: */
						}
						extA = 0;
						{
							if (extB >= 64) {
								int t14;
								int t15;

								GIV(argumentCount) = (_byte & 7) + ((sqInt) (((usqInt) (extB - 64) ) << 3) );
								extB = 0;
								numExtB = 0;
								/* begin directedSuperclassSend */
								/* begin popStack */
								_top = unsignedLongAt(local_stackPointer);
								local_stackPointer += BytesPerWord;
								_class = _top;
								/* end popStack */
								if (((long64At(_class)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
									/* begin followForwarded: */
									assert(isUnambiguouslyForwarder(_class));
									/* begin fetchPointer:ofMaybeForwardedObject: */
									_referent = unsignedLongAt((_class + BaseHeaderSize) + (0U << (shiftForWord())));
									/* end fetchPointer:ofMaybeForwardedObject: */
									while (1) {
										int t0;

										t0 = (_referent & (tagMask())) == 0;
										if (!(((t0)
											 ? ((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0
											 : 0))) 
											break;
										/* begin fetchPointer:ofMaybeForwardedObject: */
										_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
										/* end fetchPointer:ofMaybeForwardedObject: */
									}
									_class = _referent;
									/* end followForwarded: */
								}
								/* begin followField:ofObject: */
								/* begin fetchPointer:ofObject: */
								_objOop = unsignedLongAt((_class + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								t14 = (_objOop & (tagMask())) == 0;
								if (t14) {
									t15 = ((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
								} else {
									t15 = t14;
								}
								if (t15) {
									_objOop = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _class, _objOop);
								}
								_superclass = _objOop;
								/* end followField:ofObject: */
								{
									assert(addressCouldBeClassObj(_superclass));
									lkupClassTag = ((((_hash = (uint32AtPointer(_superclass + 4)) & (identityHashHalfWordMask()))) != 0)
										 ? _hash
										 : ((objCouldBeClassObj(_superclass))
											 ? ((((_err = enterIntoClassTable(_superclass))) != 0)
												 ? -_err
												 : (/* begin rawHashBitsOf: */ (uint32AtPointer(_superclass + 4)) & (identityHashHalfWordMask()) /* end rawHashBitsOf: */))
											 : -PrimErrBadReceiver));
								}
								/* begin ensureReceiverUnforwarded */
								if (isOopForwarded(unsignedLongAt(local_stackPointer + (GIV(argumentCount) * BytesPerWord)))) {
									/* begin stackValue:put: */
									/* begin followForwarded: */
									_objOop2 = unsignedLongAt(local_stackPointer + (GIV(argumentCount) * BytesPerWord));
									assert(isUnambiguouslyForwarder(_objOop2));
									/* begin fetchPointer:ofMaybeForwardedObject: */
									_referent2 = unsignedLongAt((_objOop2 + BaseHeaderSize) + (0U << (shiftForWord())));
									/* end fetchPointer:ofMaybeForwardedObject: */
									while (1) {
										int t0;

										t0 = (_referent2 & (tagMask())) == 0;
										if (!(((t0)
											 ? ((long64At(_referent2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0
											 : 0))) 
											break;
										/* begin fetchPointer:ofMaybeForwardedObject: */
										_referent2 = unsignedLongAt((_referent2 + BaseHeaderSize) + (0U << (shiftForWord())));
										/* end fetchPointer:ofMaybeForwardedObject: */
									}
									_oop = _referent2;
									/* end followForwarded: */
									unsignedLongAtput(local_stackPointer + (GIV(argumentCount) * BytesPerWord), _oop);
									/* end stackValue:put: */
								}
								/* end ensureReceiverUnforwarded */
								assert(lkupClassTag != (nilObject()));
								goto commonSendOrdinary;
								/* end directedSuperclassSend */
								goto l276;
							}
						}
						GIV(argumentCount) = (_byte & 7) + ((sqInt) (((usqInt) extB ) << 3) );
						extB = 0;
						numExtB = 0;
						/* begin superclassSend */
						/* begin superclassOf: */
						/* begin methodClassOf: */
						_methodPointer = GIV(method);
						/* begin followLiteral:ofMethod: */
						_offset = (literalCountOfMethodHeader(methodHeaderOf(_methodPointer))) - 1;
						/* begin followField:ofObject: */
						/* begin fetchPointer:ofObject: */
						_objOop22 = unsignedLongAt((_methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset + LiteralStart) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						t17 = (_objOop22 & (tagMask())) == 0;
						if (t17) {
							t18 = ((long64At(_objOop22)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
						} else {
							t18 = t17;
						}
						if (t18) {
							_objOop22 = fixFollowedFieldofObjectwithInitialValue(_offset + LiteralStart, _methodPointer, _objOop22);
						}
						_literal = _objOop22;
						/* end followField:ofObject: */
						/* end followLiteral:ofMethod: */
						t23 = _literal != GIV(nilObj);
						if (t23) {
							int t0;

							t0 = (_literal & (tagMask())) == 0;
							if (t0) {
								t24 = ((((usqInt) (longAt(_literal)) ) >> (formatShift())) & (formatMask())) <= 5;
							} else {
								t24 = t0;
							}
						} else {
							t24 = t23;
						}
						if (t24) {
							int t5;
							int t6;

							assert((numSlotsOf(_literal)) > ValueIndex);
							/* begin followField:ofObject: */
							/* begin fetchPointer:ofObject: */
							_objOop3 = unsignedLongAt((_literal + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							t5 = (_objOop3 & (tagMask())) == 0;
							if (t5) {
								t6 = ((long64At(_objOop3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
							} else {
								t6 = t5;
							}
							if (t6) {
								_objOop3 = fixFollowedFieldofObjectwithInitialValue(ValueIndex, _literal, _objOop3);
							}
							_classPointer = _objOop3;
							/* end followField:ofObject: */
						} else {
							/* begin nilObject */
							_classPointer = GIV(nilObj);
							/* end nilObject */
						}
						/* end methodClassOf: */
						/* begin followField:ofObject: */
						/* begin fetchPointer:ofObject: */
						_objOop4 = unsignedLongAt((_classPointer + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						t31 = (_objOop4 & (tagMask())) == 0;
						if (t31) {
							t32 = ((long64At(_objOop4)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
						} else {
							t32 = t31;
						}
						if (t32) {
							_objOop4 = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _classPointer, _objOop4);
						}
						_superclass2 = _objOop4;
						/* end followField:ofObject: */
						/* end superclassOf: */
						{
							assert(addressCouldBeClassObj(_superclass2));
							lkupClassTag = ((((_hash2 = (uint32AtPointer(_superclass2 + 4)) & (identityHashHalfWordMask()))) != 0)
								 ? _hash2
								 : ((objCouldBeClassObj(_superclass2))
									 ? ((((_err2 = enterIntoClassTable(_superclass2))) != 0)
										 ? -_err2
										 : (/* begin rawHashBitsOf: */ (uint32AtPointer(_superclass2 + 4)) & (identityHashHalfWordMask()) /* end rawHashBitsOf: */))
									 : -PrimErrBadReceiver));
						}
						/* begin ensureReceiverUnforwarded */
						if (isOopForwarded(unsignedLongAt(local_stackPointer + (GIV(argumentCount) * BytesPerWord)))) {
							/* begin stackValue:put: */
							/* begin followForwarded: */
							_objOop23 = unsignedLongAt(local_stackPointer + (GIV(argumentCount) * BytesPerWord));
							assert(isUnambiguouslyForwarder(_objOop23));
							/* begin fetchPointer:ofMaybeForwardedObject: */
							_referent3 = unsignedLongAt((_objOop23 + BaseHeaderSize) + (0U << (shiftForWord())));
							/* end fetchPointer:ofMaybeForwardedObject: */
							while (1) {
								int t0;

								t0 = (_referent3 & (tagMask())) == 0;
								if (!(((t0)
									 ? ((long64At(_referent3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0
									 : 0))) 
									break;
								/* begin fetchPointer:ofMaybeForwardedObject: */
								_referent3 = unsignedLongAt((_referent3 + BaseHeaderSize) + (0U << (shiftForWord())));
								/* end fetchPointer:ofMaybeForwardedObject: */
							}
							_oop2 = _referent3;
							/* end followForwarded: */
							unsignedLongAtput(local_stackPointer + (GIV(argumentCount) * BytesPerWord), _oop2);
							/* end stackValue:put: */
						}
						/* end ensureReceiverUnforwarded */
						assert(lkupClassTag != (nilObject()));
						goto commonSendOrdinary;
						/* end superclassSend */
					}
				}
				l276:
				;
				/* end case */
			}
			BREAK;
			CASE(236)
			{
				/* callMappedInlinedPrimitive */
				{
					VM_LABEL(callMappedInlinedPrimitive);
					{
						sqInt _arg;
						sqInt _arg2;
						sqInt _arg3;
						sqInt _array;
						sqInt _array2;
						sqInt _array3;
						sqInt _array4;
						sqInt _classFormat;
						sqInt _classFormat2;
						sqInt _classFormat3;
						sqInt _classFormat4;
						sqInt _classFormat5;
						sqInt _classIndex;
						sqInt _classIndex2;
						sqInt _classIndex3;
						sqInt _classIndex4;
						sqInt _classIndex5;
						sqInt _classObj;
						sqInt _classObj2;
						sqInt _classObj3;
						sqInt _classObj4;
						sqInt _classObj5;
						sqInt _index2;
						sqInt _index3;
						sqInt _index4;
						sqInt _index5;
						usqInt _newObj;
						usqInt _newObj2;
						usqInt _newObj3;
						usqInt _newObj4;
						usqInt _newObj5;
						usqInt _numBytes;
						usqInt _numBytes2;
						usqInt _numBytes3;
						usqInt _numBytes4;
						usqInt _numBytes5;
						sqInt _numSlots;
						sqInt _numSlots2;
						sqInt _numSlots3;
						sqInt _numSlots4;
						sqInt _numSlots5;
						sqInt _objFormat;
						sqInt _objFormat2;
						sqInt _objFormat3;
						sqInt _objFormat4;
						sqInt _objFormat5;
						sqInt _primIndex;
						sqInt _rcv;
						sqInt _rcv2;
						sqInt _rcv3;
						usqInt _reg;
						sqInt _reg2;
						usqInt _reg3;
						sqInt _reg4;
						usqInt _res;
						usqInt _res2;
						usqInt _res3;
						char *_sp;
						char *_sp2;
						char *_sp3;
						char *_sp4;
						char *_sp5;
						char *_sp6;
						char *_sp7;
						double _tmp;
						float _tmp2;
						double _tmp3;
						double _value;
						double _value2;
						double _value22;
						float _value23;
						float _value24;
						double _value3;
						float _value32;
						float _value33;
						float _value4;
						float _value42;
						float _value5;
						float _value6;

						_primIndex = byteAtPointer(++local_instructionPointer);
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						{
							/* begin mappedInlinePrimitive: */
							switch (_primIndex) {
								case 0:
								{
									/* begin addFloat64VectorBytecode */
									_arg = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
									_rcv = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
									/* begin eeInstantiateSmallClass:numSlots: */
									/* begin splObj: */
									/* begin fetchPointer:ofObject: */
									_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassFloat64Register ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									/* end splObj: */
									_numSlots = 16 / BytesPerWord;
									assert((rawHashBitsOf(_classObj)) != 0);
									/* begin eeInstantiateSmallClassIndex:format:numSlots: */
									_classIndex = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask());
									/* begin instSpecOfClassFormat: */
									_classFormat = (unsignedLongAt((_classObj + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
									_objFormat = (((usqInt) _classFormat ) >> (fixedFieldsFieldWidth())) & (formatMask());
									/* end instSpecOfClassFormat: */
									assert((_numSlots >= 0) && ((_classIndex != 0) && ((classAtIndex(_classIndex)) != GIV(nilObj))));
									assert((((_objFormat < (firstByteFormat()))
										 ? _objFormat
										 : _objFormat & (byteFormatMask()))) == (instSpecOfClass(classAtIndex(_classIndex))));
									/* begin allocateSmallNewSpaceSlots:format:classIndex: */
									assert(_numSlots < (numSlotsMask()));
									_newObj = GIV(freeStart);
									_numBytes = BaseHeaderSize + (((_numSlots < 1)
										 ? 8
										 : _numSlots * BytesPerOop));
									assert((_numBytes % (allocationUnit())) == 0);
									assert((_newObj % (allocationUnit())) == 0);
									if ((GIV(freeStart) + _numBytes) > GIV(scavengeThreshold)) {
										if (!GIV(needGCFlag)) {
											/* begin scheduleScavenge */
											GIV(needGCFlag) = 1;
											forceInterruptCheck();
											/* end scheduleScavenge */
										}
										if ((GIV(freeStart) + _numBytes) > (((eden()).limit))) {
											error("no room in eden for allocateSmallNewSpaceSlots:format:classIndex:");
											_res = 0;
											goto l305;
										}
									}
									long64Atput(_newObj, ((((usqLong) _numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) _objFormat ) << (formatShift())) )) + _classIndex);
									GIV(freeStart) += _numBytes;
									_res = _newObj;
									/* end allocateSmallNewSpaceSlots:format:classIndex: */
									/* end eeInstantiateSmallClassIndex:format:numSlots: */
									l305:
									;
									/* end eeInstantiateSmallClass:numSlots: */
									_tmp = (fetchFloat64ofObject(0, _arg)) + (fetchFloat64ofObject(0, _rcv));
									/* begin storeFloat64:ofObject:withValue: */
									float64Atput((_res + BaseHeaderSize) + (0U << 3), _tmp);
									/* end storeFloat64:ofObject:withValue: */
									_tmp = (fetchFloat64ofObject(1, _arg)) + (fetchFloat64ofObject(1, _rcv));
									/* begin storeFloat64:ofObject:withValue: */
									float64Atput((_res + BaseHeaderSize) + (1U << 3), _tmp);
									/* end storeFloat64:ofObject:withValue: */
									/* begin pop:thenPush: */
									unsignedLongAtput((_sp = local_stackPointer + ((2 - 1) * BytesPerWord)), _res);
									local_stackPointer = _sp;
									/* end pop:thenPush: */
									/* end addFloat64VectorBytecode */
								}
								break;
								case 1:
								{
									/* begin pushFloat64ArrayToRegisterBytecode */
									_array = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
									_index5 = (unsignedLongAt(local_stackPointer + (1 * BytesPerWord))) >> 3;
									/* begin eeInstantiateSmallClass:numSlots: */
									/* begin splObj: */
									/* begin fetchPointer:ofObject: */
									_classObj3 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassFloat64Register ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									/* end splObj: */
									_numSlots3 = 16 / BytesPerWord;
									assert((rawHashBitsOf(_classObj3)) != 0);
									/* begin eeInstantiateSmallClassIndex:format:numSlots: */
									_classIndex3 = (uint32AtPointer(_classObj3 + 4)) & (identityHashHalfWordMask());
									/* begin instSpecOfClassFormat: */
									_classFormat3 = (unsignedLongAt((_classObj3 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
									_objFormat3 = (((usqInt) _classFormat3 ) >> (fixedFieldsFieldWidth())) & (formatMask());
									/* end instSpecOfClassFormat: */
									assert((_numSlots3 >= 0) && ((_classIndex3 != 0) && ((classAtIndex(_classIndex3)) != GIV(nilObj))));
									assert((((_objFormat3 < (firstByteFormat()))
										 ? _objFormat3
										 : _objFormat3 & (byteFormatMask()))) == (instSpecOfClass(classAtIndex(_classIndex3))));
									/* begin allocateSmallNewSpaceSlots:format:classIndex: */
									assert(_numSlots3 < (numSlotsMask()));
									_newObj3 = GIV(freeStart);
									_numBytes3 = BaseHeaderSize + (((_numSlots3 < 1)
										 ? 8
										 : _numSlots3 * BytesPerOop));
									assert((_numBytes3 % (allocationUnit())) == 0);
									assert((_newObj3 % (allocationUnit())) == 0);
									if ((GIV(freeStart) + _numBytes3) > GIV(scavengeThreshold)) {
										if (!GIV(needGCFlag)) {
											/* begin scheduleScavenge */
											GIV(needGCFlag) = 1;
											forceInterruptCheck();
											/* end scheduleScavenge */
										}
										if ((GIV(freeStart) + _numBytes3) > (((eden()).limit))) {
											error("no room in eden for allocateSmallNewSpaceSlots:format:classIndex:");
											_reg = 0;
											goto l344;
										}
									}
									long64Atput(_newObj3, ((((usqLong) _numSlots3 ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) _objFormat3 ) << (formatShift())) )) + _classIndex3);
									GIV(freeStart) += _numBytes3;
									_reg = _newObj3;
									/* end allocateSmallNewSpaceSlots:format:classIndex: */
									/* end eeInstantiateSmallClassIndex:format:numSlots: */
									l344:
									;
									/* end eeInstantiateSmallClass:numSlots: */
									/* begin storeFloat64:ofObject:withValue: */
									/* begin fetchFloat64:ofObject: */
									_value = float64At((_array + BaseHeaderSize) + ((sqInt) (((usqInt) _index5 ) << 3) ));
									/* end fetchFloat64:ofObject: */
									float64Atput((_reg + BaseHeaderSize) + (0U << 3), _value);
									/* end storeFloat64:ofObject:withValue: */
									/* begin storeFloat64:ofObject:withValue: */
									/* begin fetchFloat64:ofObject: */
									_value2 = float64At((_array + BaseHeaderSize) + ((sqInt) (((usqInt) (_index5 + 1) ) << 3) ));
									/* end fetchFloat64:ofObject: */
									float64Atput((_reg + BaseHeaderSize) + (1U << 3), _value2);
									/* end storeFloat64:ofObject:withValue: */
									/* begin pop:thenPush: */
									unsignedLongAtput((_sp3 = local_stackPointer + ((2 - 1) * BytesPerWord)), _reg);
									local_stackPointer = _sp3;
									/* end pop:thenPush: */
									/* end pushFloat64ArrayToRegisterBytecode */
								}
								break;
								case 2:
								{
									/* begin storeFloat64RegisterIntoArrayBytecode */
									/* begin stackValue: */
									_array2 = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
									/* end stackValue: */
									_index2 = (unsignedLongAt(local_stackPointer + (1 * BytesPerWord))) >> 3;
									/* begin stackValue: */
									_reg2 = unsignedLongAt(local_stackPointer + (2 * BytesPerWord));
									/* end stackValue: */
									/* begin storeFloat64:ofObject:withValue: */
									/* begin fetchFloat64:ofObject: */
									_value3 = float64At((_reg2 + BaseHeaderSize) + (0U << 3));
									/* end fetchFloat64:ofObject: */
									float64Atput((_array2 + BaseHeaderSize) + ((sqInt) (((usqInt) _index2 ) << 3) ), _value3);
									/* end storeFloat64:ofObject:withValue: */
									/* begin storeFloat64:ofObject:withValue: */
									/* begin fetchFloat64:ofObject: */
									_value22 = float64At((_reg2 + BaseHeaderSize) + (1U << 3));
									/* end fetchFloat64:ofObject: */
									float64Atput((_array2 + BaseHeaderSize) + ((sqInt) (((usqInt) (_index2 + 1) ) << 3) ), _value22);
									/* end storeFloat64:ofObject:withValue: */
									/* begin pop:thenPush: */
									unsignedLongAtput((_sp4 = local_stackPointer + ((3 - 1) * BytesPerWord)), _array2);
									local_stackPointer = _sp4;
									/* end pop:thenPush: */
									/* end storeFloat64RegisterIntoArrayBytecode */
								}
								break;
								case 3:
								{
									/* begin addFloat32VectorBytecode */
									_arg2 = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
									_rcv2 = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
									/* begin eeInstantiateSmallClass:numSlots: */
									/* begin splObj: */
									/* begin fetchPointer:ofObject: */
									_classObj2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassFloat32Register ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									/* end splObj: */
									_numSlots2 = 32 / BytesPerWord;
									assert((rawHashBitsOf(_classObj2)) != 0);
									/* begin eeInstantiateSmallClassIndex:format:numSlots: */
									_classIndex2 = (uint32AtPointer(_classObj2 + 4)) & (identityHashHalfWordMask());
									/* begin instSpecOfClassFormat: */
									_classFormat2 = (unsignedLongAt((_classObj2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
									_objFormat2 = (((usqInt) _classFormat2 ) >> (fixedFieldsFieldWidth())) & (formatMask());
									/* end instSpecOfClassFormat: */
									assert((_numSlots2 >= 0) && ((_classIndex2 != 0) && ((classAtIndex(_classIndex2)) != GIV(nilObj))));
									assert((((_objFormat2 < (firstByteFormat()))
										 ? _objFormat2
										 : _objFormat2 & (byteFormatMask()))) == (instSpecOfClass(classAtIndex(_classIndex2))));
									/* begin allocateSmallNewSpaceSlots:format:classIndex: */
									assert(_numSlots2 < (numSlotsMask()));
									_newObj2 = GIV(freeStart);
									_numBytes2 = BaseHeaderSize + (((_numSlots2 < 1)
										 ? 8
										 : _numSlots2 * BytesPerOop));
									assert((_numBytes2 % (allocationUnit())) == 0);
									assert((_newObj2 % (allocationUnit())) == 0);
									if ((GIV(freeStart) + _numBytes2) > GIV(scavengeThreshold)) {
										if (!GIV(needGCFlag)) {
											/* begin scheduleScavenge */
											GIV(needGCFlag) = 1;
											forceInterruptCheck();
											/* end scheduleScavenge */
										}
										if ((GIV(freeStart) + _numBytes2) > (((eden()).limit))) {
											error("no room in eden for allocateSmallNewSpaceSlots:format:classIndex:");
											_res2 = 0;
											goto l310;
										}
									}
									long64Atput(_newObj2, ((((usqLong) _numSlots2 ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) _objFormat2 ) << (formatShift())) )) + _classIndex2);
									GIV(freeStart) += _numBytes2;
									_res2 = _newObj2;
									/* end allocateSmallNewSpaceSlots:format:classIndex: */
									/* end eeInstantiateSmallClassIndex:format:numSlots: */
									l310:
									;
									/* end eeInstantiateSmallClass:numSlots: */
									_tmp2 = (fetchFloat32ofObject(0, _arg2)) + (fetchFloat32ofObject(0, _rcv2));
									/* begin storeFloat32:ofObject:withValue: */
									float32Atput((_res2 + BaseHeaderSize) + (0U << 2), _tmp2);
									/* end storeFloat32:ofObject:withValue: */
									_tmp2 = (fetchFloat32ofObject(1, _arg2)) + (fetchFloat32ofObject(1, _rcv2));
									/* begin storeFloat32:ofObject:withValue: */
									float32Atput((_res2 + BaseHeaderSize) + (1U << 2), _tmp2);
									/* end storeFloat32:ofObject:withValue: */
									_tmp2 = (fetchFloat32ofObject(2, _arg2)) + (fetchFloat32ofObject(2, _rcv2));
									/* begin storeFloat32:ofObject:withValue: */
									float32Atput((_res2 + BaseHeaderSize) + (2U << 2), _tmp2);
									/* end storeFloat32:ofObject:withValue: */
									_tmp2 = (fetchFloat32ofObject(3, _arg2)) + (fetchFloat32ofObject(3, _rcv2));
									/* begin storeFloat32:ofObject:withValue: */
									float32Atput((_res2 + BaseHeaderSize) + (3U << 2), _tmp2);
									/* end storeFloat32:ofObject:withValue: */
									/* begin pop:thenPush: */
									unsignedLongAtput((_sp2 = local_stackPointer + ((2 - 1) * BytesPerWord)), _res2);
									local_stackPointer = _sp2;
									/* end pop:thenPush: */
									/* end addFloat32VectorBytecode */
								}
								break;
								case 4:
								{
									/* begin pushFloat32ArrayToRegisterBytecode */
									_array3 = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
									_index3 = (unsignedLongAt(local_stackPointer + (1 * BytesPerWord))) >> 3;
									/* begin eeInstantiateSmallClass:numSlots: */
									/* begin splObj: */
									/* begin fetchPointer:ofObject: */
									_classObj4 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassFloat32Register ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									/* end splObj: */
									_numSlots4 = 32 / BytesPerWord;
									assert((rawHashBitsOf(_classObj4)) != 0);
									/* begin eeInstantiateSmallClassIndex:format:numSlots: */
									_classIndex4 = (uint32AtPointer(_classObj4 + 4)) & (identityHashHalfWordMask());
									/* begin instSpecOfClassFormat: */
									_classFormat4 = (unsignedLongAt((_classObj4 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
									_objFormat4 = (((usqInt) _classFormat4 ) >> (fixedFieldsFieldWidth())) & (formatMask());
									/* end instSpecOfClassFormat: */
									assert((_numSlots4 >= 0) && ((_classIndex4 != 0) && ((classAtIndex(_classIndex4)) != GIV(nilObj))));
									assert((((_objFormat4 < (firstByteFormat()))
										 ? _objFormat4
										 : _objFormat4 & (byteFormatMask()))) == (instSpecOfClass(classAtIndex(_classIndex4))));
									/* begin allocateSmallNewSpaceSlots:format:classIndex: */
									assert(_numSlots4 < (numSlotsMask()));
									_newObj4 = GIV(freeStart);
									_numBytes4 = BaseHeaderSize + (((_numSlots4 < 1)
										 ? 8
										 : _numSlots4 * BytesPerOop));
									assert((_numBytes4 % (allocationUnit())) == 0);
									assert((_newObj4 % (allocationUnit())) == 0);
									if ((GIV(freeStart) + _numBytes4) > GIV(scavengeThreshold)) {
										if (!GIV(needGCFlag)) {
											/* begin scheduleScavenge */
											GIV(needGCFlag) = 1;
											forceInterruptCheck();
											/* end scheduleScavenge */
										}
										if ((GIV(freeStart) + _numBytes4) > (((eden()).limit))) {
											error("no room in eden for allocateSmallNewSpaceSlots:format:classIndex:");
											_reg3 = 0;
											goto l325;
										}
									}
									long64Atput(_newObj4, ((((usqLong) _numSlots4 ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) _objFormat4 ) << (formatShift())) )) + _classIndex4);
									GIV(freeStart) += _numBytes4;
									_reg3 = _newObj4;
									/* end allocateSmallNewSpaceSlots:format:classIndex: */
									/* end eeInstantiateSmallClassIndex:format:numSlots: */
									l325:
									;
									/* end eeInstantiateSmallClass:numSlots: */
									/* begin storeFloat32:ofObject:withValue: */
									/* begin fetchFloat32:ofObject: */
									_value5 = float32At((_array3 + BaseHeaderSize) + ((sqInt) (((usqInt) _index3 ) << 2) ));
									/* end fetchFloat32:ofObject: */
									float32Atput((_reg3 + BaseHeaderSize) + (0U << 2), _value5);
									/* end storeFloat32:ofObject:withValue: */
									/* begin storeFloat32:ofObject:withValue: */
									/* begin fetchFloat32:ofObject: */
									_value23 = float32At((_array3 + BaseHeaderSize) + ((sqInt) (((usqInt) (_index3 + 1) ) << 2) ));
									/* end fetchFloat32:ofObject: */
									float32Atput((_reg3 + BaseHeaderSize) + (1U << 2), _value23);
									/* end storeFloat32:ofObject:withValue: */
									/* begin storeFloat32:ofObject:withValue: */
									/* begin fetchFloat32:ofObject: */
									_value32 = float32At((_array3 + BaseHeaderSize) + ((sqInt) (((usqInt) (_index3 + 2) ) << 2) ));
									/* end fetchFloat32:ofObject: */
									float32Atput((_reg3 + BaseHeaderSize) + (2U << 2), _value32);
									/* end storeFloat32:ofObject:withValue: */
									/* begin storeFloat32:ofObject:withValue: */
									/* begin fetchFloat32:ofObject: */
									_value4 = float32At((_array3 + BaseHeaderSize) + ((sqInt) (((usqInt) (_index3 + 3) ) << 2) ));
									/* end fetchFloat32:ofObject: */
									float32Atput((_reg3 + BaseHeaderSize) + (3U << 2), _value4);
									/* end storeFloat32:ofObject:withValue: */
									/* begin pop:thenPush: */
									unsignedLongAtput((_sp5 = local_stackPointer + ((2 - 1) * BytesPerWord)), _reg3);
									local_stackPointer = _sp5;
									/* end pop:thenPush: */
									/* end pushFloat32ArrayToRegisterBytecode */
								}
								break;
								case 5:
								{
									/* begin storeFloat32RegisterIntoArrayBytecode */
									/* begin stackValue: */
									_array4 = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
									/* end stackValue: */
									_index4 = (unsignedLongAt(local_stackPointer + (1 * BytesPerWord))) >> 3;
									/* begin stackValue: */
									_reg4 = unsignedLongAt(local_stackPointer + (2 * BytesPerWord));
									/* end stackValue: */
									/* begin storeFloat32:ofObject:withValue: */
									/* begin fetchFloat32:ofObject: */
									_value6 = float32At((_reg4 + BaseHeaderSize) + (0U << 2));
									/* end fetchFloat32:ofObject: */
									float32Atput((_array4 + BaseHeaderSize) + ((sqInt) (((usqInt) _index4 ) << 2) ), _value6);
									/* end storeFloat32:ofObject:withValue: */
									/* begin storeFloat32:ofObject:withValue: */
									/* begin fetchFloat32:ofObject: */
									_value24 = float32At((_reg4 + BaseHeaderSize) + (1U << 2));
									/* end fetchFloat32:ofObject: */
									float32Atput((_array4 + BaseHeaderSize) + ((sqInt) (((usqInt) (_index4 + 1) ) << 2) ), _value24);
									/* end storeFloat32:ofObject:withValue: */
									/* begin storeFloat32:ofObject:withValue: */
									/* begin fetchFloat32:ofObject: */
									_value33 = float32At((_reg4 + BaseHeaderSize) + (2U << 2));
									/* end fetchFloat32:ofObject: */
									float32Atput((_array4 + BaseHeaderSize) + ((sqInt) (((usqInt) (_index4 + 2) ) << 2) ), _value33);
									/* end storeFloat32:ofObject:withValue: */
									/* begin storeFloat32:ofObject:withValue: */
									/* begin fetchFloat32:ofObject: */
									_value42 = float32At((_reg4 + BaseHeaderSize) + (3U << 2));
									/* end fetchFloat32:ofObject: */
									float32Atput((_array4 + BaseHeaderSize) + ((sqInt) (((usqInt) (_index4 + 3) ) << 2) ), _value42);
									/* end storeFloat32:ofObject:withValue: */
									/* begin pop:thenPush: */
									unsignedLongAtput((_sp6 = local_stackPointer + ((3 - 1) * BytesPerWord)), _array4);
									local_stackPointer = _sp6;
									/* end pop:thenPush: */
									/* end storeFloat32RegisterIntoArrayBytecode */
								}
								break;
								case 6:
								{
									/* begin subFloat64VectorBytecode */
									/* begin stackValue: */
									_arg3 = unsignedLongAt(local_stackPointer + (0 * BytesPerWord));
									/* end stackValue: */
									/* begin stackValue: */
									_rcv3 = unsignedLongAt(local_stackPointer + (1 * BytesPerWord));
									/* end stackValue: */
									/* begin eeInstantiateSmallClass:numSlots: */
									/* begin splObj: */
									/* begin fetchPointer:ofObject: */
									_classObj5 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassFloat64Register ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									/* end splObj: */
									_numSlots5 = 16 / BytesPerWord;
									assert((rawHashBitsOf(_classObj5)) != 0);
									/* begin eeInstantiateSmallClassIndex:format:numSlots: */
									_classIndex5 = (uint32AtPointer(_classObj5 + 4)) & (identityHashHalfWordMask());
									/* begin instSpecOfClassFormat: */
									_classFormat5 = (unsignedLongAt((_classObj5 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
									_objFormat5 = (((usqInt) _classFormat5 ) >> (fixedFieldsFieldWidth())) & (formatMask());
									/* end instSpecOfClassFormat: */
									assert((_numSlots5 >= 0) && ((_classIndex5 != 0) && ((classAtIndex(_classIndex5)) != GIV(nilObj))));
									assert((((_objFormat5 < (firstByteFormat()))
										 ? _objFormat5
										 : _objFormat5 & (byteFormatMask()))) == (instSpecOfClass(classAtIndex(_classIndex5))));
									/* begin allocateSmallNewSpaceSlots:format:classIndex: */
									assert(_numSlots5 < (numSlotsMask()));
									_newObj5 = GIV(freeStart);
									_numBytes5 = BaseHeaderSize + (((_numSlots5 < 1)
										 ? 8
										 : _numSlots5 * BytesPerOop));
									assert((_numBytes5 % (allocationUnit())) == 0);
									assert((_newObj5 % (allocationUnit())) == 0);
									if ((GIV(freeStart) + _numBytes5) > GIV(scavengeThreshold)) {
										if (!GIV(needGCFlag)) {
											/* begin scheduleScavenge */
											GIV(needGCFlag) = 1;
											forceInterruptCheck();
											/* end scheduleScavenge */
										}
										if ((GIV(freeStart) + _numBytes5) > (((eden()).limit))) {
											error("no room in eden for allocateSmallNewSpaceSlots:format:classIndex:");
											_res3 = 0;
											goto l330;
										}
									}
									long64Atput(_newObj5, ((((usqLong) _numSlots5 ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) _objFormat5 ) << (formatShift())) )) + _classIndex5);
									GIV(freeStart) += _numBytes5;
									_res3 = _newObj5;
									/* end allocateSmallNewSpaceSlots:format:classIndex: */
									/* end eeInstantiateSmallClassIndex:format:numSlots: */
									l330:
									;
									/* end eeInstantiateSmallClass:numSlots: */
									_tmp3 = (fetchFloat64ofObject(0, _rcv3)) - (fetchFloat64ofObject(0, _arg3));
									/* begin storeFloat64:ofObject:withValue: */
									float64Atput((_res3 + BaseHeaderSize) + (0U << 3), _tmp3);
									/* end storeFloat64:ofObject:withValue: */
									_tmp3 = (fetchFloat64ofObject(1, _rcv3)) - (fetchFloat64ofObject(1, _arg3));
									/* begin storeFloat64:ofObject:withValue: */
									float64Atput((_res3 + BaseHeaderSize) + (1U << 3), _tmp3);
									/* end storeFloat64:ofObject:withValue: */
									/* begin pop:thenPush: */
									unsignedLongAtput((_sp7 = local_stackPointer + ((2 - 1) * BytesPerWord)), _res3);
									local_stackPointer = _sp7;
									/* end pop:thenPush: */
									/* end subFloat64VectorBytecode */
								}
								break;
								default:
								{
									/* begin unknownInlinePrimitive */
									local_instructionPointer -= 3;
									goto respondToUnknownBytecode;
									/* end unknownInlinePrimitive */
								}
							}
							/* end mappedInlinePrimitive: */
						}
					}
				}
			}
			BREAK;
			CASE(237)
			{
				/* extUnconditionalJump */
				{
					VM_LABEL(extUnconditionalJump);
					{
						sqInt t2;
						sqInt _backwardJumpCountByte;
						sqInt _bcpcDelta;
						sqInt _byte;
						sqInt _offset;
						sqInt _switched;

						_byte = byteAtPointer(++local_instructionPointer);
						_offset = _byte + ((sqInt) (((usqInt) extB ) << 8) );
						if (_offset < 0) {
							t2 = numExtB * 2;
						} else {
							t2 = 0;
						}
						_bcpcDelta = t2;
						extB = 0;
						numExtB = 0;
						local_instructionPointer += _offset;
						/* begin ifBackwardsCheckForEvents: */
						if ((_offset + _bcpcDelta) >= 0) {
							goto l354;
						}
						if (local_stackPointer < GIV(stackLimit)) {
							sqInt t0;

							{
								GIV(framePointer) = local_framePointer;
								GIV(instructionPointer) = local_instructionPointer;
								GIV(stackPointer) = local_stackPointer;
								t0 = checkForEventsMayContextSwitch(1);
								local_framePointer = GIV(framePointer);
								local_instructionPointer = GIV(instructionPointer);
								local_stackPointer = GIV(stackPointer);
							}
							_switched = t0;
							{
								GIV(framePointer) = local_framePointer;
								GIV(instructionPointer) = local_instructionPointer;
								GIV(stackPointer) = local_stackPointer;
								returnToExecutivepostContextSwitch(1, _switched);
								local_framePointer = GIV(framePointer);
								local_instructionPointer = GIV(instructionPointer);
								local_stackPointer = GIV(stackPointer);
							}
							if (_switched) {
								goto l354;
							}
						}
						_backwardJumpCountByte = byteAt(local_framePointer + (((VMBIGENDIAN)
							 ? (FoxIFrameFlags + BytesPerWord) - 1
							 : FoxIFrameFlags)));
						if (((_backwardJumpCountByte -= 2)) == 1) {
							if (methodWithHeaderShouldBeCogged(methodHeaderOf(GIV(method)))) {
								sqInt t0;

								t0 = ((((oopForPointer(local_instructionPointer)) - (_offset + _bcpcDelta)) - GIV(method)) - BaseHeaderSize) - 1;
								{
									GIV(framePointer) = local_framePointer;
									GIV(stackPointer) = local_stackPointer;
									attemptToSwitchToMachineCode(t0);
									local_framePointer = GIV(framePointer);
									local_stackPointer = GIV(stackPointer);
								}
							}
							_backwardJumpCountByte = 0x7F;
						} else {
							if (_backwardJumpCountByte == -1) {
								assert(minBackwardJumpCountForCompile <= 128);
								_backwardJumpCountByte = ((sqInt) (((usqInt) (minBackwardJumpCountForCompile - 1) ) << 1) ) + 1;
							}
						}
						/* begin iframeBackwardBranchByte:put: */
						byteAtput(local_framePointer + (((VMBIGENDIAN)
							 ? (FoxIFrameFlags + BytesPerWord) - 1
							 : FoxIFrameFlags)), _backwardJumpCountByte);
						/* end iframeBackwardBranchByte:put: */
						l354:
						;
						/* end ifBackwardsCheckForEvents: */
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
					}
				}
			}
			BREAK;
			CASE(238)
			{
				/* extJumpIfTrue */
				{
					VM_LABEL(extJumpIfTrue);
					{
						sqInt _boolean;
						sqInt _byte;
						sqInt _offset;

						_byte = byteAtPointer(++local_instructionPointer);
						_offset = _byte + ((sqInt) (((usqInt) extB ) << 8) );
						numExtB = (extB = (extA = 0));
						/* begin jumplfTrueBy: */
						_boolean = unsignedLongAt(local_stackPointer);
						if (_boolean == GIV(trueObj)) {
							/* begin jump: */
							local_instructionPointer = (local_instructionPointer + _offset) + 1;
							currentBytecode = byteAtPointer(local_instructionPointer);
							/* end jump: */
						} else {
							if (!(_boolean == GIV(falseObj))) {
								/* begin internalMustBeBoolean */
								/* begin splObj: */
								/* begin fetchPointer:ofObject: */
								GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorMustBeBoolean ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								/* end splObj: */
								GIV(argumentCount) = 0;
								goto normalSend;
								/* end internalMustBeBoolean */
								goto l358;
							}
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
						}
						/* begin pop: */
						local_stackPointer += 1 * BytesPerWord;
						/* end pop: */
						l358:
						;
						/* end jumplfTrueBy: */
					}
				}
			}
			BREAK;
			CASE(239)
			{
				/* extJumpIfFalse */
				{
					VM_LABEL(extJumpIfFalse);
					{
						sqInt _boolean;
						sqInt _byte;
						sqInt _offset;

						_byte = byteAtPointer(++local_instructionPointer);
						_offset = _byte + ((sqInt) (((usqInt) extB ) << 8) );
						numExtB = (extB = (extA = 0));
						/* begin jumplfFalseBy: */
						_boolean = unsignedLongAt(local_stackPointer);
						if (_boolean == GIV(falseObj)) {
							/* begin jump: */
							local_instructionPointer = (local_instructionPointer + _offset) + 1;
							currentBytecode = byteAtPointer(local_instructionPointer);
							/* end jump: */
						} else {
							if (!(_boolean == GIV(trueObj))) {
								/* begin internalMustBeBoolean */
								/* begin splObj: */
								/* begin fetchPointer:ofObject: */
								GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorMustBeBoolean ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								/* end splObj: */
								GIV(argumentCount) = 0;
								goto normalSend;
								/* end internalMustBeBoolean */
								goto l362;
							}
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
						}
						/* begin pop: */
						local_stackPointer += 1 * BytesPerWord;
						/* end pop: */
						l362:
						;
						/* end jumplfFalseBy: */
					}
				}
			}
			BREAK;
			CASE(240)
			{
				/* extStoreAndPopReceiverVariableBytecode */
				{
					VM_LABEL(extStoreAndPopReceiverVariableBytecode);
					{
						int t10;
						sqInt t11;
						sqInt _obj;
						int _onCurrentPage;
						sqInt _senderOop;
						char *_sp;
						char *_sp2;
						char *_sp3;
						char * _theFP;
						StackPage * _thePage;
						StackPage *_thePage2;
						sqInt _thePC;
						sqInt _thePC2;
						char *_theSP;
						sqInt _value;
						sqInt _variableIndex;

						_variableIndex = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) extA ) << 8) );
						extA = 0;
						_value = unsignedLongAt(local_stackPointer);
						/* begin pop: */
						local_stackPointer += 1 * BytesPerWord;
						/* end pop: */
						/* begin storeMaybeContextReceiverVariable:withValue: */
						/* begin storeMaybeContext:receiverVariable:withValue: */
						_obj = unsignedLongAt(local_framePointer + FoxIFReceiver);
						t10 = _variableIndex <= ReceiverIndex;
						if (t10) {
							int t0;

							t0 = ((longAt(_obj)) & (classIndexMask())) == ClassMethodContextCompactIndex;
							if (t0) {
								sqInt t0;

								t0 = (((unsignedLongAt((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1);
								if (t0) {
									t11 = t0;
								} else {
									int t0;

									t0 = _variableIndex == MethodIndex;
									if (t0) {
										int t0;

										t0 = ((int) ((_thePC = unsignedLongAt((_value + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )))) ) < 0;
										if (t0) {
											t11 = ((_thePC & 7) == 1);
										} else {
											t11 = t0;
										}
									} else {
										t11 = t0;
									}
								}
							} else {
								t11 = t0;
							}
						} else {
							t11 = t10;
						}
						if (t11) {
							sqInt t15;
							int t16;
							int t26;
							sqInt t27;
							int t31;
							int t32;
							int t39;
							int t40;

							/* begin instVar:ofContext:put: */
							assert(!(isObjImmutable(_obj)));
							/* begin writeBackHeadFramePointers */
							assert((local_framePointer - local_stackPointer) < (LargeContextSlots * BytesPerOop));
							assert(GIV(stackPage) == (mostRecentlyUsedPage()));
							assert(!(isFree(GIV(stackPage))));
							/* begin setHeadFP:andSP:inPage: */
							_theSP = local_stackPointer;
							assert(_theSP < local_framePointer);
							assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
							assert((local_framePointer < ((GIV(stackPage)->baseAddress))) && (local_framePointer > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
							{
								(GIV(stackPage)->headFP = local_framePointer);
								(GIV(stackPage)->headSP = _theSP);
							}
							/* end setHeadFP:andSP:inPage: */
							assert(pageListIsWellFormed());
							/* end writeBackHeadFramePointers */
							t15 = (((unsignedLongAt((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1);
							if (t15) {
								t16 = !(isWidowedContext(_obj));
							} else {
								t16 = t15;
							}
							if (!t16) {
								int t10;
								int t11;
								int t2;
								int t3;

								/* begin storePointer:ofObject:withValue: */
								assert(!(isForwarded(_obj)));
								t2 = (_obj & (tagMask())) == 0;
								if (t2) {
									t3 = (_obj & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask));
								} else {
									t3 = t2;
								}
								if (t3) {
									int t0;
									int t1;

									t0 = (_value & (tagMask())) == 0;
									if (t0) {
										int t0;

										t0 = (_value & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask));
										if (t0) {
											t1 = _value >= ((GIV(memoryMap)->newSpaceStart));
										} else {
											t1 = t0;
										}
									} else {
										t1 = t0;
									}
									if (t1) {
										/* begin possibleOldObjectStoreInto: */
										if (!(((((usqInt) (long64At(_obj)) ) >> (rememberedBitShift())) & 1) != 0)) {
											remember(GIV(fromOldSpaceRememberedSet), _obj);
										}
										/* end possibleOldObjectStoreInto: */
									}
								}
								/* begin possiblePermObjectStoreInto:value: */
								if (((((usqInt) (long64At(_obj)) ) >> (rememberedBitShift())) & 1) != 0) {
									goto l364;
								}
								if (_value & (tagMask())) {
									goto l364;
								}
								if (!(_obj >= 0x20000000000LL)) {
									goto l364;
								}
								if (_value >= 0x20000000000LL) {
									goto l364;
								}
								t10 = _value >= GIV(nilObj);
								if (t10) {
									t11 = _value <= GIV(trueObj);
								} else {
									t11 = t10;
								}
								if (t11) {
									goto l364;
								}
								if (!(_value >= (startOfObjectMemory(GIV(memoryMap))))) {
									goto l364;
								}
								remember(getFromPermToNewSpaceRememberedSet(), _obj);
								l364:
								;
								/* end possiblePermObjectStoreInto:value: */
								unsignedLongAtput((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) _variableIndex ) << (shiftForWord())) ), _value);
								/* end storePointer:ofObject:withValue: */
								if (_variableIndex == StackPointerIndex) {
									{
										GIV(instructionPointer) = local_instructionPointer;
										GIV(stackPointer) = local_stackPointer;
										ensureContextIsExecutionSafeAfterAssignToStackPointer(_obj);
										local_instructionPointer = GIV(instructionPointer);
										local_stackPointer = GIV(stackPointer);
									}
								}
								goto l374;
							}
							/* begin frameOfMarriedContext: */
							/* begin fetchPointer:ofObject: */
							_senderOop = unsignedLongAt((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							{
								assert(((_senderOop & 7) == 1));
								_theFP = pointerForOop(_senderOop - 1);
							}
							/* end frameOfMarriedContext: */
							if (_variableIndex == SenderIndex) {
								/* begin stackPageFor: */
								/* begin stackPageAt: */
								_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
								/* end stackPageAt: */
								/* end stackPageFor: */
								assert(GIV(stackPage) == (mostRecentlyUsedPage()));
								_onCurrentPage = _thePage == GIV(stackPage);
								storeSenderOfFramewithValue(_theFP, _value);
								if (_onCurrentPage) {
									/* begin setStackPointersFromPage: */
									_thePage2 = GIV(stackPage);
									local_stackPointer = (_thePage2->headSP);
									local_framePointer = (_thePage2->headFP);
									/* end setStackPointersFromPage: */
								} else {
									markStackPageMostRecentlyUsed(GIV(stackPage));
								}
								goto l374;
							}
							{
								GIV(framePointer) = local_framePointer;
								GIV(stackPointer) = local_stackPointer;
								divorceFrameandContext(_theFP, _obj);
								local_framePointer = GIV(framePointer);
								local_stackPointer = GIV(stackPointer);
							}
							t26 = _variableIndex == MethodIndex;
							if (t26) {
								int t0;

								t0 = ((int) ((_thePC2 = unsignedLongAt((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )))) ) < 0;
								if (t0) {
									t27 = ((_thePC2 & 7) == 1);
								} else {
									t27 = t0;
								}
							} else {
								t27 = t26;
							}
							if (t27) {
								{
									GIV(instructionPointer) = local_instructionPointer;
									GIV(stackPointer) = local_stackPointer;
									ensureContextHasBytecodePC(_obj);
									local_instructionPointer = GIV(instructionPointer);
									local_stackPointer = GIV(stackPointer);
								}
							}
							/* begin storePointer:ofObject:withValue: */
							assert(!(isForwarded(_obj)));
							t31 = (_obj & (tagMask())) == 0;
							if (t31) {
								t32 = (_obj & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask));
							} else {
								t32 = t31;
							}
							if (t32) {
								int t0;
								int t1;

								t0 = (_value & (tagMask())) == 0;
								if (t0) {
									int t0;

									t0 = (_value & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask));
									if (t0) {
										t1 = _value >= ((GIV(memoryMap)->newSpaceStart));
									} else {
										t1 = t0;
									}
								} else {
									t1 = t0;
								}
								if (t1) {
									/* begin possibleOldObjectStoreInto: */
									if (!(((((usqInt) (long64At(_obj)) ) >> (rememberedBitShift())) & 1) != 0)) {
										remember(GIV(fromOldSpaceRememberedSet), _obj);
									}
									/* end possibleOldObjectStoreInto: */
								}
							}
							/* begin possiblePermObjectStoreInto:value: */
							if (((((usqInt) (long64At(_obj)) ) >> (rememberedBitShift())) & 1) != 0) {
								goto l378;
							}
							if (_value & (tagMask())) {
								goto l378;
							}
							if (!(_obj >= 0x20000000000LL)) {
								goto l378;
							}
							if (_value >= 0x20000000000LL) {
								goto l378;
							}
							t39 = _value >= GIV(nilObj);
							if (t39) {
								t40 = _value <= GIV(trueObj);
							} else {
								t40 = t39;
							}
							if (t40) {
								goto l378;
							}
							if (!(_value >= (startOfObjectMemory(GIV(memoryMap))))) {
								goto l378;
							}
							remember(getFromPermToNewSpaceRememberedSet(), _obj);
							l378:
							;
							/* end possiblePermObjectStoreInto:value: */
							unsignedLongAtput((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) _variableIndex ) << (shiftForWord())) ), _value);
							/* end storePointer:ofObject:withValue: */
							if (_variableIndex == StackPointerIndex) {
								{
									GIV(instructionPointer) = local_instructionPointer;
									GIV(stackPointer) = local_stackPointer;
									ensureContextIsExecutionSafeAfterAssignToStackPointer(_obj);
									local_instructionPointer = GIV(instructionPointer);
									local_stackPointer = GIV(stackPointer);
								}
							}
							markStackPageMostRecentlyUsed(GIV(stackPage));
							l374:
							;
							/* end instVar:ofContext:put: */
						} else {
							int t12;
							int t13;
							int t4;
							int t5;

							/* begin storePointerImmutabilityCheck:ofObject:withValue: */
							
#              if IMMUTABILITY
							{
								assert(!(isImmediate(_obj)));
								if (((((usqInt) (longAt(_obj)) ) >> (immutableBitShift())) & 1) != 0) {
									/* begin cannotAssign:to:withIndex: */
									/* begin push: */
									unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _obj);
									local_stackPointer = _sp;
									/* end push: */
									/* begin push: */
									unsignedLongAtput((_sp2 = local_stackPointer - BytesPerWord), _value);
									local_stackPointer = _sp2;
									/* end push: */
									/* begin push: */
									unsignedLongAtput((_sp3 = local_stackPointer - BytesPerWord), ((((usqInt) (_variableIndex + 1) ) << 3) | 1));
									local_stackPointer = _sp3;
									/* end push: */
									/* begin splObj: */
									/* begin fetchPointer:ofObject: */
									GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorAttemptToAssign ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									/* end splObj: */
									GIV(argumentCount) = 2;
									goto normalSend;
									goto l373;
									l373:
									;
									/* end cannotAssign:to:withIndex: */
									goto l367;
								}
							}
#              endif /* IMMUTABILITY */
							/* begin storePointer:ofObject:withValue: */
							assert(!(isForwarded(_obj)));
							t4 = (_obj & (tagMask())) == 0;
							if (t4) {
								t5 = (_obj & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask));
							} else {
								t5 = t4;
							}
							if (t5) {
								int t0;
								int t1;

								t0 = (_value & (tagMask())) == 0;
								if (t0) {
									int t0;

									t0 = (_value & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask));
									if (t0) {
										t1 = _value >= ((GIV(memoryMap)->newSpaceStart));
									} else {
										t1 = t0;
									}
								} else {
									t1 = t0;
								}
								if (t1) {
									/* begin possibleOldObjectStoreInto: */
									if (!(((((usqInt) (long64At(_obj)) ) >> (rememberedBitShift())) & 1) != 0)) {
										remember(GIV(fromOldSpaceRememberedSet), _obj);
									}
									/* end possibleOldObjectStoreInto: */
								}
							}
							/* begin possiblePermObjectStoreInto:value: */
							if (((((usqInt) (long64At(_obj)) ) >> (rememberedBitShift())) & 1) != 0) {
								goto l377;
							}
							if (_value & (tagMask())) {
								goto l377;
							}
							if (!(_obj >= 0x20000000000LL)) {
								goto l377;
							}
							if (_value >= 0x20000000000LL) {
								goto l377;
							}
							t12 = _value >= GIV(nilObj);
							if (t12) {
								t13 = _value <= GIV(trueObj);
							} else {
								t13 = t12;
							}
							if (t13) {
								goto l377;
							}
							if (!(_value >= (startOfObjectMemory(GIV(memoryMap))))) {
								goto l377;
							}
							remember(getFromPermToNewSpaceRememberedSet(), _obj);
							l377:
							;
							/* end possiblePermObjectStoreInto:value: */
							unsignedLongAtput((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) _variableIndex ) << (shiftForWord())) ), _value);
							/* end storePointer:ofObject:withValue: */
							l367:
							;
							/* end storePointerImmutabilityCheck:ofObject:withValue: */
						}
						/* end storeMaybeContext:receiverVariable:withValue: */
						/* end storeMaybeContextReceiverVariable:withValue: */
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
					}
				}
			}
			BREAK;
			CASE(241)
			{
				/* extStoreAndPopLiteralVariableBytecode */
				{
					VM_LABEL(extStoreAndPopLiteralVariableBytecode);
					{
						int t17;
						int t18;
						int t25;
						int t26;
						sqInt _literal;
						sqInt _litVar;
						char *_sp;
						char *_sp2;
						char *_sp3;
						sqInt _value;
						sqInt _variableIndex;

						_variableIndex = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) extA ) << 8) );
						_value = unsignedLongAt(local_stackPointer);
						/* begin pop: */
						local_stackPointer += 1 * BytesPerWord;
						/* end pop: */
						extA = 0;
						/* begin storeLiteralVariable:withValue: */
						/* begin literalMaybeForwarder: */
						{
							assert(GIV(method) == (iframeMethod(local_framePointer)));
							/* begin literal:ofMethod: */
							/* begin fetchPointer:ofObject: */
							_literal = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_variableIndex + LiteralStart) ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							/* end literal:ofMethod: */
						}
						if (((long64At(_literal)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
							_literal = unfollowatIndex(_literal, _variableIndex);
						}
						_litVar = _literal;
						/* end literalMaybeForwarder: */
						/* begin storePointerImmutabilityCheck:ofObject:withValue: */
						
#            if IMMUTABILITY
						{
							assert(!(isImmediate(_litVar)));
							if (((((usqInt) (longAt(_litVar)) ) >> (immutableBitShift())) & 1) != 0) {
								/* begin cannotAssign:to:withIndex: */
								/* begin push: */
								unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _litVar);
								local_stackPointer = _sp;
								/* end push: */
								/* begin push: */
								unsignedLongAtput((_sp2 = local_stackPointer - BytesPerWord), _value);
								local_stackPointer = _sp2;
								/* end push: */
								/* begin push: */
								unsignedLongAtput((_sp3 = local_stackPointer - BytesPerWord), ((((usqInt) (ValueIndex + 1) ) << 3) | 1));
								local_stackPointer = _sp3;
								/* end push: */
								/* begin splObj: */
								/* begin fetchPointer:ofObject: */
								GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorAttemptToAssign ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								/* end splObj: */
								GIV(argumentCount) = 2;
								goto normalSend;
								goto l387;
								l387:
								;
								/* end cannotAssign:to:withIndex: */
								goto l386;
							}
						}
#            endif /* IMMUTABILITY */
						/* begin storePointer:ofObject:withValue: */
						assert(!(isForwarded(_litVar)));
						t17 = (_litVar & (tagMask())) == 0;
						if (t17) {
							t18 = (_litVar & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask));
						} else {
							t18 = t17;
						}
						if (t18) {
							int t0;
							int t1;

							t0 = (_value & (tagMask())) == 0;
							if (t0) {
								int t0;

								t0 = (_value & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask));
								if (t0) {
									t1 = _value >= ((GIV(memoryMap)->newSpaceStart));
								} else {
									t1 = t0;
								}
							} else {
								t1 = t0;
							}
							if (t1) {
								/* begin possibleOldObjectStoreInto: */
								if (!(((((usqInt) (long64At(_litVar)) ) >> (rememberedBitShift())) & 1) != 0)) {
									remember(GIV(fromOldSpaceRememberedSet), _litVar);
								}
								/* end possibleOldObjectStoreInto: */
							}
						}
						/* begin possiblePermObjectStoreInto:value: */
						if (((((usqInt) (long64At(_litVar)) ) >> (rememberedBitShift())) & 1) != 0) {
							goto l379;
						}
						if (_value & (tagMask())) {
							goto l379;
						}
						if (!(_litVar >= 0x20000000000LL)) {
							goto l379;
						}
						if (_value >= 0x20000000000LL) {
							goto l379;
						}
						t25 = _value >= GIV(nilObj);
						if (t25) {
							t26 = _value <= GIV(trueObj);
						} else {
							t26 = t25;
						}
						if (t26) {
							goto l379;
						}
						if (!(_value >= (startOfObjectMemory(GIV(memoryMap))))) {
							goto l379;
						}
						remember(getFromPermToNewSpaceRememberedSet(), _litVar);
						l379:
						;
						/* end possiblePermObjectStoreInto:value: */
						unsignedLongAtput((_litVar + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ), _value);
						/* end storePointer:ofObject:withValue: */
						l386:
						;
						/* end storePointerImmutabilityCheck:ofObject:withValue: */
						/* end storeLiteralVariable:withValue: */
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
					}
				}
			}
			BREAK;
			CASE(242)
			{
				/* longStoreAndPopTemporaryVariableBytecode */
				{
					VM_LABEL(longStoreAndPopTemporaryVariableBytecode);
					{
						sqInt _frameNumArgs;
						sqInt _index2;
						sqInt _valueOop;

						/* begin longStoreTemporaryVariableBytecode */
						/* begin fetchByte */
						_index2 = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin itemporary:in:put: */
						_valueOop = unsignedLongAt(local_stackPointer);
						if (_index2 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
							unsignedLongAtput((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - _index2) * BytesPerWord), _valueOop);
						}
 else {
							unsignedLongAtput(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - _index2) * BytesPerWord), _valueOop);
						}
						/* end itemporary:in:put: */
						/* end longStoreTemporaryVariableBytecode */
						/* begin pop: */
						local_stackPointer += 1 * BytesPerWord;
						/* end pop: */
					}
				}
			}
			BREAK;
			CASE(243)
			{
				/* extStoreReceiverVariableBytecode */
				{
					VM_LABEL(extStoreReceiverVariableBytecode);
					{
						int t6;
						sqInt t7;
						sqInt _anObject;
						sqInt _obj;
						int _onCurrentPage;
						sqInt _senderOop;
						char *_sp;
						char *_sp2;
						char *_sp3;
						char * _theFP;
						StackPage * _thePage;
						StackPage *_thePage2;
						sqInt _thePC;
						sqInt _thePC2;
						char *_theSP;
						sqInt _variableIndex;

						_variableIndex = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) extA ) << 8) );
						extA = 0;
						/* begin storeMaybeContextReceiverVariable:withValue: */
						_anObject = unsignedLongAt(local_stackPointer);
						/* begin storeMaybeContext:receiverVariable:withValue: */
						_obj = unsignedLongAt(local_framePointer + FoxIFReceiver);
						t6 = _variableIndex <= ReceiverIndex;
						if (t6) {
							int t0;

							t0 = ((longAt(_obj)) & (classIndexMask())) == ClassMethodContextCompactIndex;
							if (t0) {
								sqInt t0;

								t0 = (((unsignedLongAt((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1);
								if (t0) {
									t7 = t0;
								} else {
									int t0;

									t0 = _variableIndex == MethodIndex;
									if (t0) {
										int t0;

										t0 = ((int) ((_thePC = unsignedLongAt((_anObject + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )))) ) < 0;
										if (t0) {
											t7 = ((_thePC & 7) == 1);
										} else {
											t7 = t0;
										}
									} else {
										t7 = t0;
									}
								}
							} else {
								t7 = t0;
							}
						} else {
							t7 = t6;
						}
						if (t7) {
							sqInt t15;
							int t16;
							int t26;
							sqInt t27;
							int t31;
							int t32;
							int t39;
							int t40;

							/* begin instVar:ofContext:put: */
							assert(!(isObjImmutable(_obj)));
							/* begin writeBackHeadFramePointers */
							assert((local_framePointer - local_stackPointer) < (LargeContextSlots * BytesPerOop));
							assert(GIV(stackPage) == (mostRecentlyUsedPage()));
							assert(!(isFree(GIV(stackPage))));
							/* begin setHeadFP:andSP:inPage: */
							_theSP = local_stackPointer;
							assert(_theSP < local_framePointer);
							assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
							assert((local_framePointer < ((GIV(stackPage)->baseAddress))) && (local_framePointer > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
							{
								(GIV(stackPage)->headFP = local_framePointer);
								(GIV(stackPage)->headSP = _theSP);
							}
							/* end setHeadFP:andSP:inPage: */
							assert(pageListIsWellFormed());
							/* end writeBackHeadFramePointers */
							t15 = (((unsignedLongAt((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1);
							if (t15) {
								t16 = !(isWidowedContext(_obj));
							} else {
								t16 = t15;
							}
							if (!t16) {
								int t10;
								int t11;
								int t2;
								int t3;

								/* begin storePointer:ofObject:withValue: */
								assert(!(isForwarded(_obj)));
								t2 = (_obj & (tagMask())) == 0;
								if (t2) {
									t3 = (_obj & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask));
								} else {
									t3 = t2;
								}
								if (t3) {
									int t0;
									int t1;

									t0 = (_anObject & (tagMask())) == 0;
									if (t0) {
										int t0;

										t0 = (_anObject & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask));
										if (t0) {
											t1 = _anObject >= ((GIV(memoryMap)->newSpaceStart));
										} else {
											t1 = t0;
										}
									} else {
										t1 = t0;
									}
									if (t1) {
										/* begin possibleOldObjectStoreInto: */
										if (!(((((usqInt) (long64At(_obj)) ) >> (rememberedBitShift())) & 1) != 0)) {
											remember(GIV(fromOldSpaceRememberedSet), _obj);
										}
										/* end possibleOldObjectStoreInto: */
									}
								}
								/* begin possiblePermObjectStoreInto:value: */
								if (((((usqInt) (long64At(_obj)) ) >> (rememberedBitShift())) & 1) != 0) {
									goto l392;
								}
								if (_anObject & (tagMask())) {
									goto l392;
								}
								if (!(_obj >= 0x20000000000LL)) {
									goto l392;
								}
								if (_anObject >= 0x20000000000LL) {
									goto l392;
								}
								t10 = _anObject >= GIV(nilObj);
								if (t10) {
									t11 = _anObject <= GIV(trueObj);
								} else {
									t11 = t10;
								}
								if (t11) {
									goto l392;
								}
								if (!(_anObject >= (startOfObjectMemory(GIV(memoryMap))))) {
									goto l392;
								}
								remember(getFromPermToNewSpaceRememberedSet(), _obj);
								l392:
								;
								/* end possiblePermObjectStoreInto:value: */
								unsignedLongAtput((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) _variableIndex ) << (shiftForWord())) ), _anObject);
								/* end storePointer:ofObject:withValue: */
								if (_variableIndex == StackPointerIndex) {
									{
										GIV(instructionPointer) = local_instructionPointer;
										GIV(stackPointer) = local_stackPointer;
										ensureContextIsExecutionSafeAfterAssignToStackPointer(_obj);
										local_instructionPointer = GIV(instructionPointer);
										local_stackPointer = GIV(stackPointer);
									}
								}
								goto l401;
							}
							/* begin frameOfMarriedContext: */
							/* begin fetchPointer:ofObject: */
							_senderOop = unsignedLongAt((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							{
								assert(((_senderOop & 7) == 1));
								_theFP = pointerForOop(_senderOop - 1);
							}
							/* end frameOfMarriedContext: */
							if (_variableIndex == SenderIndex) {
								/* begin stackPageFor: */
								/* begin stackPageAt: */
								_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
								/* end stackPageAt: */
								/* end stackPageFor: */
								assert(GIV(stackPage) == (mostRecentlyUsedPage()));
								_onCurrentPage = _thePage == GIV(stackPage);
								storeSenderOfFramewithValue(_theFP, _anObject);
								if (_onCurrentPage) {
									/* begin setStackPointersFromPage: */
									_thePage2 = GIV(stackPage);
									local_stackPointer = (_thePage2->headSP);
									local_framePointer = (_thePage2->headFP);
									/* end setStackPointersFromPage: */
								} else {
									markStackPageMostRecentlyUsed(GIV(stackPage));
								}
								goto l401;
							}
							{
								GIV(framePointer) = local_framePointer;
								GIV(stackPointer) = local_stackPointer;
								divorceFrameandContext(_theFP, _obj);
								local_framePointer = GIV(framePointer);
								local_stackPointer = GIV(stackPointer);
							}
							t26 = _variableIndex == MethodIndex;
							if (t26) {
								int t0;

								t0 = ((int) ((_thePC2 = unsignedLongAt((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )))) ) < 0;
								if (t0) {
									t27 = ((_thePC2 & 7) == 1);
								} else {
									t27 = t0;
								}
							} else {
								t27 = t26;
							}
							if (t27) {
								{
									GIV(instructionPointer) = local_instructionPointer;
									GIV(stackPointer) = local_stackPointer;
									ensureContextHasBytecodePC(_obj);
									local_instructionPointer = GIV(instructionPointer);
									local_stackPointer = GIV(stackPointer);
								}
							}
							/* begin storePointer:ofObject:withValue: */
							assert(!(isForwarded(_obj)));
							t31 = (_obj & (tagMask())) == 0;
							if (t31) {
								t32 = (_obj & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask));
							} else {
								t32 = t31;
							}
							if (t32) {
								int t0;
								int t1;

								t0 = (_anObject & (tagMask())) == 0;
								if (t0) {
									int t0;

									t0 = (_anObject & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask));
									if (t0) {
										t1 = _anObject >= ((GIV(memoryMap)->newSpaceStart));
									} else {
										t1 = t0;
									}
								} else {
									t1 = t0;
								}
								if (t1) {
									/* begin possibleOldObjectStoreInto: */
									if (!(((((usqInt) (long64At(_obj)) ) >> (rememberedBitShift())) & 1) != 0)) {
										remember(GIV(fromOldSpaceRememberedSet), _obj);
									}
									/* end possibleOldObjectStoreInto: */
								}
							}
							/* begin possiblePermObjectStoreInto:value: */
							if (((((usqInt) (long64At(_obj)) ) >> (rememberedBitShift())) & 1) != 0) {
								goto l405;
							}
							if (_anObject & (tagMask())) {
								goto l405;
							}
							if (!(_obj >= 0x20000000000LL)) {
								goto l405;
							}
							if (_anObject >= 0x20000000000LL) {
								goto l405;
							}
							t39 = _anObject >= GIV(nilObj);
							if (t39) {
								t40 = _anObject <= GIV(trueObj);
							} else {
								t40 = t39;
							}
							if (t40) {
								goto l405;
							}
							if (!(_anObject >= (startOfObjectMemory(GIV(memoryMap))))) {
								goto l405;
							}
							remember(getFromPermToNewSpaceRememberedSet(), _obj);
							l405:
							;
							/* end possiblePermObjectStoreInto:value: */
							unsignedLongAtput((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) _variableIndex ) << (shiftForWord())) ), _anObject);
							/* end storePointer:ofObject:withValue: */
							if (_variableIndex == StackPointerIndex) {
								{
									GIV(instructionPointer) = local_instructionPointer;
									GIV(stackPointer) = local_stackPointer;
									ensureContextIsExecutionSafeAfterAssignToStackPointer(_obj);
									local_instructionPointer = GIV(instructionPointer);
									local_stackPointer = GIV(stackPointer);
								}
							}
							markStackPageMostRecentlyUsed(GIV(stackPage));
							l401:
							;
							/* end instVar:ofContext:put: */
						} else {
							int t12;
							int t13;
							int t4;
							int t5;

							/* begin storePointerImmutabilityCheck:ofObject:withValue: */
							
#              if IMMUTABILITY
							{
								assert(!(isImmediate(_obj)));
								if (((((usqInt) (longAt(_obj)) ) >> (immutableBitShift())) & 1) != 0) {
									/* begin cannotAssign:to:withIndex: */
									/* begin push: */
									unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _obj);
									local_stackPointer = _sp;
									/* end push: */
									/* begin push: */
									unsignedLongAtput((_sp2 = local_stackPointer - BytesPerWord), _anObject);
									local_stackPointer = _sp2;
									/* end push: */
									/* begin push: */
									unsignedLongAtput((_sp3 = local_stackPointer - BytesPerWord), ((((usqInt) (_variableIndex + 1) ) << 3) | 1));
									local_stackPointer = _sp3;
									/* end push: */
									/* begin splObj: */
									/* begin fetchPointer:ofObject: */
									GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorAttemptToAssign ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									/* end splObj: */
									GIV(argumentCount) = 2;
									goto normalSend;
									goto l393;
									l393:
									;
									/* end cannotAssign:to:withIndex: */
									goto l395;
								}
							}
#              endif /* IMMUTABILITY */
							/* begin storePointer:ofObject:withValue: */
							assert(!(isForwarded(_obj)));
							t4 = (_obj & (tagMask())) == 0;
							if (t4) {
								t5 = (_obj & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask));
							} else {
								t5 = t4;
							}
							if (t5) {
								int t0;
								int t1;

								t0 = (_anObject & (tagMask())) == 0;
								if (t0) {
									int t0;

									t0 = (_anObject & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask));
									if (t0) {
										t1 = _anObject >= ((GIV(memoryMap)->newSpaceStart));
									} else {
										t1 = t0;
									}
								} else {
									t1 = t0;
								}
								if (t1) {
									/* begin possibleOldObjectStoreInto: */
									if (!(((((usqInt) (long64At(_obj)) ) >> (rememberedBitShift())) & 1) != 0)) {
										remember(GIV(fromOldSpaceRememberedSet), _obj);
									}
									/* end possibleOldObjectStoreInto: */
								}
							}
							/* begin possiblePermObjectStoreInto:value: */
							if (((((usqInt) (long64At(_obj)) ) >> (rememberedBitShift())) & 1) != 0) {
								goto l404;
							}
							if (_anObject & (tagMask())) {
								goto l404;
							}
							if (!(_obj >= 0x20000000000LL)) {
								goto l404;
							}
							if (_anObject >= 0x20000000000LL) {
								goto l404;
							}
							t12 = _anObject >= GIV(nilObj);
							if (t12) {
								t13 = _anObject <= GIV(trueObj);
							} else {
								t13 = t12;
							}
							if (t13) {
								goto l404;
							}
							if (!(_anObject >= (startOfObjectMemory(GIV(memoryMap))))) {
								goto l404;
							}
							remember(getFromPermToNewSpaceRememberedSet(), _obj);
							l404:
							;
							/* end possiblePermObjectStoreInto:value: */
							unsignedLongAtput((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) _variableIndex ) << (shiftForWord())) ), _anObject);
							/* end storePointer:ofObject:withValue: */
							l395:
							;
							/* end storePointerImmutabilityCheck:ofObject:withValue: */
						}
						/* end storeMaybeContext:receiverVariable:withValue: */
						/* end storeMaybeContextReceiverVariable:withValue: */
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
					}
				}
			}
			BREAK;
			CASE(244)
			{
				/* extStoreLiteralVariableBytecode */
				{
					VM_LABEL(extStoreLiteralVariableBytecode);
					{
						int t13;
						int t14;
						int t21;
						int t22;
						sqInt _anObject;
						sqInt _literal;
						sqInt _litVar;
						char *_sp;
						char *_sp2;
						char *_sp3;
						sqInt _variableIndex;

						_variableIndex = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) extA ) << 8) );
						extA = 0;
						/* begin storeLiteralVariable:withValue: */
						_anObject = unsignedLongAt(local_stackPointer);
						/* begin literalMaybeForwarder: */
						{
							assert(GIV(method) == (iframeMethod(local_framePointer)));
							/* begin literal:ofMethod: */
							/* begin fetchPointer:ofObject: */
							_literal = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_variableIndex + LiteralStart) ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							/* end literal:ofMethod: */
						}
						if (((long64At(_literal)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
							_literal = unfollowatIndex(_literal, _variableIndex);
						}
						_litVar = _literal;
						/* end literalMaybeForwarder: */
						/* begin storePointerImmutabilityCheck:ofObject:withValue: */
						
#            if IMMUTABILITY
						{
							assert(!(isImmediate(_litVar)));
							if (((((usqInt) (longAt(_litVar)) ) >> (immutableBitShift())) & 1) != 0) {
								/* begin cannotAssign:to:withIndex: */
								/* begin push: */
								unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _litVar);
								local_stackPointer = _sp;
								/* end push: */
								/* begin push: */
								unsignedLongAtput((_sp2 = local_stackPointer - BytesPerWord), _anObject);
								local_stackPointer = _sp2;
								/* end push: */
								/* begin push: */
								unsignedLongAtput((_sp3 = local_stackPointer - BytesPerWord), ((((usqInt) (ValueIndex + 1) ) << 3) | 1));
								local_stackPointer = _sp3;
								/* end push: */
								/* begin splObj: */
								/* begin fetchPointer:ofObject: */
								GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorAttemptToAssign ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								/* end splObj: */
								GIV(argumentCount) = 2;
								goto normalSend;
								goto l413;
								l413:
								;
								/* end cannotAssign:to:withIndex: */
								goto l412;
							}
						}
#            endif /* IMMUTABILITY */
						/* begin storePointer:ofObject:withValue: */
						assert(!(isForwarded(_litVar)));
						t13 = (_litVar & (tagMask())) == 0;
						if (t13) {
							t14 = (_litVar & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask));
						} else {
							t14 = t13;
						}
						if (t14) {
							int t0;
							int t1;

							t0 = (_anObject & (tagMask())) == 0;
							if (t0) {
								int t0;

								t0 = (_anObject & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask));
								if (t0) {
									t1 = _anObject >= ((GIV(memoryMap)->newSpaceStart));
								} else {
									t1 = t0;
								}
							} else {
								t1 = t0;
							}
							if (t1) {
								/* begin possibleOldObjectStoreInto: */
								if (!(((((usqInt) (long64At(_litVar)) ) >> (rememberedBitShift())) & 1) != 0)) {
									remember(GIV(fromOldSpaceRememberedSet), _litVar);
								}
								/* end possibleOldObjectStoreInto: */
							}
						}
						/* begin possiblePermObjectStoreInto:value: */
						if (((((usqInt) (long64At(_litVar)) ) >> (rememberedBitShift())) & 1) != 0) {
							goto l406;
						}
						if (_anObject & (tagMask())) {
							goto l406;
						}
						if (!(_litVar >= 0x20000000000LL)) {
							goto l406;
						}
						if (_anObject >= 0x20000000000LL) {
							goto l406;
						}
						t21 = _anObject >= GIV(nilObj);
						if (t21) {
							t22 = _anObject <= GIV(trueObj);
						} else {
							t22 = t21;
						}
						if (t22) {
							goto l406;
						}
						if (!(_anObject >= (startOfObjectMemory(GIV(memoryMap))))) {
							goto l406;
						}
						remember(getFromPermToNewSpaceRememberedSet(), _litVar);
						l406:
						;
						/* end possiblePermObjectStoreInto:value: */
						unsignedLongAtput((_litVar + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ), _anObject);
						/* end storePointer:ofObject:withValue: */
						l412:
						;
						/* end storePointerImmutabilityCheck:ofObject:withValue: */
						/* end storeLiteralVariable:withValue: */
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
					}
				}
			}
			BREAK;
			CASE(245)
			{
				/* longStoreTemporaryVariableBytecode */
				{
					VM_LABEL(longStoreTemporaryVariableBytecode);
					{
						sqInt _frameNumArgs;
						sqInt _index2;
						sqInt _valueOop;

						/* begin fetchByte */
						_index2 = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin itemporary:in:put: */
						_valueOop = unsignedLongAt(local_stackPointer);
						if (_index2 < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
							unsignedLongAtput((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - _index2) * BytesPerWord), _valueOop);
						}
 else {
							unsignedLongAtput(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - _index2) * BytesPerWord), _valueOop);
						}
						/* end itemporary:in:put: */
					}
				}
			}
			BREAK;
			CASE(248)
			{
				/* callPrimitiveBytecode */
				{
					VM_LABEL(callPrimitiveBytecode);
					{
						sqInt _header;
						sqInt _header3;

						{
							int t7;
							int t8;

							/* begin methodHeaderOf: */
							assert(isCompiledMethod(GIV(method)));
							/* begin fetchPointer:ofObject: */
							_header3 = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							if (((_header3 & 7) == 1)) {
								_header = _header3;
							} else {
								assert(((usqInt) _header3 ) < ((GIV(memoryMap)->newSpaceStart)));
								assert((((((CogMethod *) _header3 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
								_header = ((((CogMethod *) _header3 ))->methodHeader);
							}
							/* end methodHeaderOf: */
							t7 = _header & AlternateHeaderHasPrimFlag;
							if (t7) {
								t8 = ((sqInt) local_instructionPointer ) == ((GIV(method) + ((LiteralStart + ((assert(((_header & 7) == 1)), (_header >> 3) & AlternateHeaderNumLiteralsMask))) * BytesPerOop)) + BaseHeaderSize);
							} else {
								t8 = t7;
							}
							if (t8) {
								local_instructionPointer = (local_instructionPointer + 3) - 1;
								/* begin fetchNextBytecode */
								/* begin fetchByte */
								currentBytecode = byteAtPointer(++local_instructionPointer);
								/* end fetchByte */
								/* end fetchNextBytecode */
								goto l417;
							} else {
								goto respondToUnknownBytecode;
								goto l417;
							}
						}
					}
				}
				l417:
				;
				/* end case */
			}
			BREAK;
			CASE(249)
			{
				/* extPushFullClosureBytecode */
				{
					VM_LABEL(extPushFullClosureBytecode);
					{
						sqInt _byte;
						sqInt _compiledBlock;
						sqInt _compiledBlockLiteralIndex;
						sqInt _context;
						sqInt _header;
						sqInt _header2;
						sqInt _i;
						int _ignoreContext;
						sqInt _literal;
						usqInt _newClosure;
						usqInt _newClosure2;
						usqInt _newObj;
						sqInt _numArgs;
						usqInt _numBytes;
						sqInt _numCopied;
						sqInt _numCopied2;
						sqInt _numSlots;
						sqInt _objFormat;
						int _receiverIsOnStack;
						char *_sp;
						sqInt _startIndex;
						char *_theFP;
						char *_theSP;
						sqInt _valuePointer;
						sqInt _valuePointer2;

						_compiledBlockLiteralIndex = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) extA ) << 8) );
						extA = 0;
						/* begin literalMaybeForwarder: */
						{
							assert(GIV(method) == (iframeMethod(local_framePointer)));
							/* begin literal:ofMethod: */
							/* begin fetchPointer:ofObject: */
							_literal = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_compiledBlockLiteralIndex + LiteralStart) ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							/* end literal:ofMethod: */
						}
						if (((long64At(_literal)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
							_literal = unfollowatIndex(_literal, _compiledBlockLiteralIndex);
						}
						_compiledBlock = _literal;
						/* end literalMaybeForwarder: */
						assert(isOopCompiledMethod(_compiledBlock));
						/* begin argumentCountOf: */
						/* begin argumentCountOfMethodHeader: */
						/* begin methodHeaderOf: */
						assert(isCompiledMethod(_compiledBlock));
						/* begin fetchPointer:ofObject: */
						_header2 = unsignedLongAt((_compiledBlock + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						if (((_header2 & 7) == 1)) {
							_header = _header2;
						} else {
							assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
							assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
							_header = ((((CogMethod *) _header2 ))->methodHeader);
						}
						/* end methodHeaderOf: */
						_numArgs = (((usqInt) _header ) >> MethodHeaderArgCountShift) & 15;
						/* end argumentCountOfMethodHeader: */
						/* end argumentCountOf: */
						_byte = byteAtPointer(++local_instructionPointer);
						_numCopied = _byte & ((1U << 6) - 1);
						_receiverIsOnStack = _byte & (1U << 7);
						_ignoreContext = _byte & (1U << 6);
						/* begin pushFullClosureNumArgs:copiedValues:compiledBlock:receiverIsOnStack:ignoreContext: */
						if (_ignoreContext) {
							/* begin nilObject */
							_context = GIV(nilObj);
							/* end nilObject */
						} else {
							/* begin ensureFrameIsMarried:SP: */
							_theFP = local_framePointer;
							_theSP = local_stackPointer + (_numCopied * BytesPerOop);
							if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
								 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
								 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0)) {
								assert(isContext(frameContext(_theFP)));
								_context = unsignedLongAt(_theFP + FoxThisContext);
								goto l429;
							}
							_context = marryFrameSP(_theFP, _theSP);
							l429:
							;
							/* end ensureFrameIsMarried:SP: */
						}
						/* begin fullClosureIn:numArgs:numCopiedValues:compiledBlock: */
						{
							/* begin eeInstantiateSmallClassIndex:format:numSlots: */
							_objFormat = indexablePointersFormat();
							_numSlots = FullClosureFirstCopiedValueIndex + _numCopied;
							assert((_numSlots >= 0) && ((classAtIndex(ClassFullBlockClosureCompactIndex)) != GIV(nilObj)));
							assert((((_objFormat < (firstByteFormat()))
								 ? _objFormat
								 : _objFormat & (byteFormatMask()))) == (instSpecOfClass(classAtIndex(ClassFullBlockClosureCompactIndex))));
							/* begin allocateSmallNewSpaceSlots:format:classIndex: */
							assert(_numSlots < (numSlotsMask()));
							_newObj = GIV(freeStart);
							_numBytes = BaseHeaderSize + (((_numSlots < 1)
								 ? 8
								 : _numSlots * BytesPerOop));
							assert((_numBytes % (allocationUnit())) == 0);
							assert((_newObj % (allocationUnit())) == 0);
							if ((GIV(freeStart) + _numBytes) > GIV(scavengeThreshold)) {
								if (!GIV(needGCFlag)) {
									/* begin scheduleScavenge */
									GIV(needGCFlag) = 1;
									forceInterruptCheck();
									/* end scheduleScavenge */
								}
								if ((GIV(freeStart) + _numBytes) > (((eden()).limit))) {
									error("no room in eden for allocateSmallNewSpaceSlots:format:classIndex:");
									_newClosure2 = 0;
									goto l437;
								}
							}
							long64Atput(_newObj, ((((usqLong) _numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) _objFormat ) << (formatShift())) )) + ClassFullBlockClosureCompactIndex);
							GIV(freeStart) += _numBytes;
							_newClosure2 = _newObj;
							/* end allocateSmallNewSpaceSlots:format:classIndex: */
							l437:
							;
							/* end eeInstantiateSmallClassIndex:format:numSlots: */
						}
						{
							/* begin storePointerUnchecked:ofObject:withValue: */
							assert(!(isOopForwarded(_newClosure2)));
							longAtput((_newClosure2 + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureOuterContextIndex ) << (shiftForWord())) ), _context);
							/* end storePointerUnchecked:ofObject:withValue: */
							/* begin storePointerUnchecked:ofObject:withValue: */
							assert(!(isOopForwarded(_newClosure2)));
							longAtput((_newClosure2 + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureCompiledBlockIndex ) << (shiftForWord())) ), _compiledBlock);
							/* end storePointerUnchecked:ofObject:withValue: */
							/* begin storePointerUnchecked:ofObject:withValue: */
							assert(!(isOopForwarded(_newClosure2)));
							longAtput((_newClosure2 + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureNumArgsIndex ) << (shiftForWord())) ), ((((usqInt) _numArgs ) << 3) | 1));
							/* end storePointerUnchecked:ofObject:withValue: */
						}
						_newClosure = _newClosure2;
						/* end fullClosureIn:numArgs:numCopiedValues:compiledBlock: */
						/* begin maybeTraceBlockCreation: */
						if (recordSendTrace()) {
							/* begin recordTrace:thing:source: */
							GIV(traceLog)[GIV(traceLogIndex)] = TraceBlockCreation;
							GIV(traceLog)[GIV(traceLogIndex) + 1] = _newClosure;
							GIV(traceLog)[GIV(traceLogIndex) + 2] = TraceIsFromInterpreter;
							GIV(traceLogIndex) = (GIV(traceLogIndex) + 3) % TraceBufferSize;
							/* end recordTrace:thing:source: */
						}
						/* end maybeTraceBlockCreation: */
						if (_receiverIsOnStack) {
							_startIndex = FullClosureReceiverIndex;
							_numCopied2 = _numCopied + 1;
						} else {
							_startIndex = FullClosureFirstCopiedValueIndex;
							/* begin storePointerUnchecked:ofObject:withValue: */
							_valuePointer = unsignedLongAt(local_framePointer + FoxIFReceiver);
							assert(!(isOopForwarded(_newClosure)));
							longAtput((_newClosure + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureReceiverIndex ) << (shiftForWord())) ), _valuePointer);
							/* end storePointerUnchecked:ofObject:withValue: */
							_numCopied2 = _numCopied;
						}
						if (_numCopied2 > 0) {
							for (_i = 0; _i < _numCopied2; _i += 1) {
								/* begin storePointerUnchecked:ofObject:withValue: */
								_valuePointer2 = unsignedLongAt(local_stackPointer + (((_numCopied2 - _i) - 1) * BytesPerWord));
								assert(!(isOopForwarded(_newClosure)));
								longAtput((_newClosure + BaseHeaderSize) + ((sqInt) (((usqInt) (_i + _startIndex) ) << (shiftForWord())) ), _valuePointer2);
								/* end storePointerUnchecked:ofObject:withValue: */
							}
							/* begin pop: */
							local_stackPointer += _numCopied2 * BytesPerWord;
							/* end pop: */
						}
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin push: */
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _newClosure);
						local_stackPointer = _sp;
						/* end push: */
						/* end pushFullClosureNumArgs:copiedValues:compiledBlock:receiverIsOnStack:ignoreContext: */
					}
				}
			}
			BREAK;
			CASE(251)
			{
				/* pushRemoteTempLongBytecode */
				{
					VM_LABEL(pushRemoteTempLongBytecode);
					{
						sqInt t13;
						sqInt _frameNumArgs;
						sqInt _object;
						sqInt _remoteTempIndex;
						char *_sp;
						sqInt _tempVector;
						sqInt _tempVectorIndex;

						/* begin fetchByte */
						_remoteTempIndex = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* begin fetchByte */
						_tempVectorIndex = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin pushRemoteTemp:inVectorAt: */
						/* begin itemporary:in: */
						if (_tempVectorIndex < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
							t13 = unsignedLongAt((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - _tempVectorIndex) * BytesPerWord));
						}
 else {
							t13 = unsignedLongAt(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - _tempVectorIndex) * BytesPerWord));
						}
						_tempVector = t13;
						/* end itemporary:in: */
						/* begin push: */
						_object = unsignedLongAt((_tempVector + BaseHeaderSize) + ((sqInt) (((usqInt) _remoteTempIndex ) << (shiftForWord())) ));
						unsignedLongAtput((_sp = local_stackPointer - BytesPerWord), _object);
						local_stackPointer = _sp;
						/* end push: */
						/* end pushRemoteTemp:inVectorAt: */
					}
				}
			}
			BREAK;
			CASE(252)
			{
				/* storeRemoteTempLongBytecode */
				{
					VM_LABEL(storeRemoteTempLongBytecode);
					{
						sqInt t13;
						int t20;
						int t21;
						int t28;
						int t29;
						sqInt _frameNumArgs;
						sqInt _remoteTempIndex;
						sqInt _tempVector;
						sqInt _tempVectorIndex;
						sqInt _valuePointer;

						/* begin fetchByte */
						_remoteTempIndex = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* begin fetchByte */
						_tempVectorIndex = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin storeRemoteTemp:inVectorAt: */
						/* begin itemporary:in: */
						if (_tempVectorIndex < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
							t13 = unsignedLongAt((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - _tempVectorIndex) * BytesPerWord));
						}
 else {
							t13 = unsignedLongAt(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - _tempVectorIndex) * BytesPerWord));
						}
						_tempVector = t13;
						/* end itemporary:in: */
						/* begin storePointer:ofObject:withValue: */
						_valuePointer = unsignedLongAt(local_stackPointer);
						assert(!(isForwarded(_tempVector)));
						t20 = (_tempVector & (tagMask())) == 0;
						if (t20) {
							t21 = (_tempVector & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask));
						} else {
							t21 = t20;
						}
						if (t21) {
							int t0;
							int t1;

							t0 = (_valuePointer & (tagMask())) == 0;
							if (t0) {
								int t0;

								t0 = (_valuePointer & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask));
								if (t0) {
									t1 = _valuePointer >= ((GIV(memoryMap)->newSpaceStart));
								} else {
									t1 = t0;
								}
							} else {
								t1 = t0;
							}
							if (t1) {
								/* begin possibleOldObjectStoreInto: */
								if (!(((((usqInt) (long64At(_tempVector)) ) >> (rememberedBitShift())) & 1) != 0)) {
									remember(GIV(fromOldSpaceRememberedSet), _tempVector);
								}
								/* end possibleOldObjectStoreInto: */
							}
						}
						/* begin possiblePermObjectStoreInto:value: */
						if (((((usqInt) (long64At(_tempVector)) ) >> (rememberedBitShift())) & 1) != 0) {
							goto l450;
						}
						if (_valuePointer & (tagMask())) {
							goto l450;
						}
						if (!(_tempVector >= 0x20000000000LL)) {
							goto l450;
						}
						if (_valuePointer >= 0x20000000000LL) {
							goto l450;
						}
						t28 = _valuePointer >= GIV(nilObj);
						if (t28) {
							t29 = _valuePointer <= GIV(trueObj);
						} else {
							t29 = t28;
						}
						if (t29) {
							goto l450;
						}
						if (!(_valuePointer >= (startOfObjectMemory(GIV(memoryMap))))) {
							goto l450;
						}
						remember(getFromPermToNewSpaceRememberedSet(), _tempVector);
						l450:
						;
						/* end possiblePermObjectStoreInto:value: */
						unsignedLongAtput((_tempVector + BaseHeaderSize) + ((sqInt) (((usqInt) _remoteTempIndex ) << (shiftForWord())) ), _valuePointer);
						/* end storePointer:ofObject:withValue: */
						/* end storeRemoteTemp:inVectorAt: */
					}
				}
			}
			BREAK;
			CASE(253)
			{
				/* storeAndPopRemoteTempLongBytecode */
				{
					VM_LABEL(storeAndPopRemoteTempLongBytecode);
					{
						sqInt t14;
						int t21;
						int t22;
						int t29;
						int t30;
						sqInt _frameNumArgs;
						sqInt _remoteTempIndex;
						sqInt _tempVector;
						sqInt _tempVectorIndex;
						sqInt _valuePointer;

						/* begin storeRemoteTempLongBytecode */
						/* begin fetchByte */
						_remoteTempIndex = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* begin fetchByte */
						_tempVectorIndex = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin storeRemoteTemp:inVectorAt: */
						/* begin itemporary:in: */
						if (_tempVectorIndex < ((_frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
							t14 = unsignedLongAt((local_framePointer + FoxCallerSavedIP) + ((_frameNumArgs - _tempVectorIndex) * BytesPerWord));
						}
 else {
							t14 = unsignedLongAt(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs - _tempVectorIndex) * BytesPerWord));
						}
						_tempVector = t14;
						/* end itemporary:in: */
						/* begin storePointer:ofObject:withValue: */
						_valuePointer = unsignedLongAt(local_stackPointer);
						assert(!(isForwarded(_tempVector)));
						t21 = (_tempVector & (tagMask())) == 0;
						if (t21) {
							t22 = (_tempVector & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask));
						} else {
							t22 = t21;
						}
						if (t22) {
							int t0;
							int t1;

							t0 = (_valuePointer & (tagMask())) == 0;
							if (t0) {
								int t0;

								t0 = (_valuePointer & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask));
								if (t0) {
									t1 = _valuePointer >= ((GIV(memoryMap)->newSpaceStart));
								} else {
									t1 = t0;
								}
							} else {
								t1 = t0;
							}
							if (t1) {
								/* begin possibleOldObjectStoreInto: */
								if (!(((((usqInt) (long64At(_tempVector)) ) >> (rememberedBitShift())) & 1) != 0)) {
									remember(GIV(fromOldSpaceRememberedSet), _tempVector);
								}
								/* end possibleOldObjectStoreInto: */
							}
						}
						/* begin possiblePermObjectStoreInto:value: */
						if (((((usqInt) (long64At(_tempVector)) ) >> (rememberedBitShift())) & 1) != 0) {
							goto l456;
						}
						if (_valuePointer & (tagMask())) {
							goto l456;
						}
						if (!(_tempVector >= 0x20000000000LL)) {
							goto l456;
						}
						if (_valuePointer >= 0x20000000000LL) {
							goto l456;
						}
						t29 = _valuePointer >= GIV(nilObj);
						if (t29) {
							t30 = _valuePointer <= GIV(trueObj);
						} else {
							t30 = t29;
						}
						if (t30) {
							goto l456;
						}
						if (!(_valuePointer >= (startOfObjectMemory(GIV(memoryMap))))) {
							goto l456;
						}
						remember(getFromPermToNewSpaceRememberedSet(), _tempVector);
						l456:
						;
						/* end possiblePermObjectStoreInto:value: */
						unsignedLongAtput((_tempVector + BaseHeaderSize) + ((sqInt) (((usqInt) _remoteTempIndex ) << (shiftForWord())) ), _valuePointer);
						/* end storePointer:ofObject:withValue: */
						/* end storeRemoteTemp:inVectorAt: */
						/* end storeRemoteTempLongBytecode */
						/* begin pop: */
						local_stackPointer += 1 * BytesPerWord;
						/* end pop: */
					}
				}
			}
			BREAK;
		}
	}
	local_instructionPointer -= 1;
	{
		GIV(framePointer) = local_framePointer;
		GIV(instructionPointer) = local_instructionPointer;
		GIV(stackPointer) = local_stackPointer;
		return null;
	}
	return 0;
}
/* AbstractComposedImageAccess>>#existSegment:inImage: */
static sqInt NoDbgRegParms
existSegmentinImage(sqInt _segmentIndex, sqInt _imageFileName)
{
	char _buffer[255];
	sqInt _fileName;

	{
		snprintf(_buffer, 0xFF, "%s/seg%d%s", ((char *) _imageFileName ), ((int) _segmentIndex ), ".data");
		_fileName = _buffer;
	}
	return fileExists(_fileName);
}
/* AbstractComposedImageAccess>>#fileExists: */
static sqInt NoDbgRegParms
fileExists(char *_fileName)
{
	struct stat _sb;

	return (stat(_fileName, &_sb)) == 0;
}
/* AbstractComposedImageAccess>>#headerFileNameinImage:into:bufferSize: */
static sqInt NoDbgRegParms
headerFileNameinImageintobufferSize(sqInt _imageFileName, sqInt _buffer, sqInt _bufferSize)
{
	char * _headerFileName;

	_headerFileName = "header.ston";
	return (snprintf(_buffer, _bufferSize, "%s/%s", ((char *) _imageFileName ), ((char *) _headerFileName )), _buffer);
}
/* AbstractComposedImageAccess>>#readLineFrom:into:ofSize: */
static void NoDbgRegParms
readLineFromintoofSize(sqImageFile _file, char *_lineBuffer, sqInt _bufferSize)
{
	sqInt _aCharacter;
	int _idx;

	{
		_idx = 0;
		_aCharacter = fgetc(_file);
		while (!(_aCharacter == -1)) {
			if (_aCharacter == 10) {
				_aCharacter = -1;
			} else {
				if (_aCharacter == 13) {
					_aCharacter = fgetc(_file);
					if (_aCharacter != 13) {
						ungetc(_aCharacter, _file);
					}
					_aCharacter = -1;
				} else {
					_lineBuffer[_idx] = _aCharacter;
					_idx += 1;
					if (_bufferSize == (_idx + 1)) {
						_aCharacter = -1;
					} else {
						_aCharacter = fgetc(_file);
					}
				}
			}
		}
		_lineBuffer[_idx] = 0;
	}
}
/* AbstractComposedImageAccess>>#segmentMetadataFile:inImage: */
static sqInt NoDbgRegParms
segmentMetadataFileinImage(sqInt _segmentIndex, sqInt _imageFileName)
{
	char _buffer[255];

	/* begin simulationOnly: */
	/* end simulationOnly: */
	/* begin segmentFileName:withExtension:inImage:into:bufferSize: */
	return (snprintf(_buffer, 0xFF, "%s/seg%d%s", ((char *) _imageFileName ), ((int) _segmentIndex ), ".ston"), _buffer);
	/* end segmentFileName:withExtension:inImage:into:bufferSize: */
}
/*	Read and verify the image file version number and return true if the the 
	given image file needs to be byte-swapped. As a side effect, position the 
	file stream just after the version number of the image header. This code 
	prints a warning and does a hard-exit if it cannot find a valid version 
	number. This code is based on C code by Ian Piumarta. */
/* AbstractImageAccess>>#extractImageVersionFrom:into: */
static void NoDbgRegParms
extractImageVersionFrominto(sqInt _fileVersion, SpurImageHeaderStruct *_header)
{
	sqInt _firstVersion;
	sqInt _version;

	_version = (_firstVersion = _fileVersion);
	if ((_version == 68021) || (_version == 68002)) {
		(_header->imageFormat = _version);
		(_header->swapBytes = 0);
		return;
	}
	if (((SQ_SWAP_4_BYTES(_version)) == 68021) || ((SQ_SWAP_4_BYTES(_version)) == 68002)) {
		(_header->imageFormat = SQ_SWAP_4_BYTES(_version));
		(_header->swapBytes = 1);
		return;
	}
	logError("Invalid image format: detected version %d, expected version %d", _firstVersion, 68021);
	ioExitWithErrorCode(1);
}
/* AbstractImageAccess>>#loadHeaderToMemory: */
static void NoDbgRegParms
loadHeaderToMemory(SpurImageHeaderStruct _header)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _anInteger;
	sqInt _anObject;
	sqInt _aValue;
	sqInt _bytes;
	sqInt _headerFlags;
	sqInt _maxExtSemTabSize;
	sqInt _requestedEdenBytes;
	sqInt _requestedNumPages;
	sqInt _seed;

	/* begin ensureMemoryMap */
	if (GIV(memoryMap)) {
		goto l3;
	}
	GIV(memoryMap) = ((VMMemoryMap *) (malloc(sizeof(VMMemoryMap))) );
	/* begin initializeMemoryMap */
	(GIV(memoryMap)->initialCodeZoneSize) = 0;
	(GIV(memoryMap)->initialPermSpaceSize) = 0;
	(GIV(memoryMap)->minPermSpaceSize) = 0;
	(GIV(memoryMap)->permSpaceStart) = 0;
	(GIV(memoryMap)->permSpaceEnd) = 0;
	(GIV(memoryMap)->permSpaceMask) = -1;
	/* begin simulationOnly: */
	/* end simulationOnly: */
	calculateMaskToUse(GIV(memoryMap));
	/* end initializeMemoryMap */
	l3:
	;
	/* end ensureMemoryMap */
	/* begin specialObjectsOop: */
	_anObject = (_header.initialSpecialObjectsOop);
	GIV(specialObjectsOop) = _anObject;
	/* end specialObjectsOop: */
	/* begin lastHash: */
	_seed = (_header.hdrLastHash);
	GIV(lastHash) = _seed;
	/* end lastHash: */
	/* begin setImageVersion: */
	_aValue = (_header.imageVersion);
	GIV(imageVersionNumber) = _aValue & 0xFFFF;
	/* end setImageVersion: */
	/* begin setImageHeaderFlagsFrom: */
	_headerFlags = (_header.headerFlags);
	GIV(imageHeaderFlags) = _headerFlags;
	GIV(imageFloatsBigEndian) = (((_headerFlags & 2) == 0)
		 ? 1
		 : 0);
	GIV(flagInterpretedMethods) = _headerFlags & 8;
	GIV(preemptionYields) = (_headerFlags & 16) == 0;
	/* end setImageHeaderFlagsFrom: */
	/* begin setExtraVMMemory: */
	_anInteger = (_header.extraVMMemory);
	extraVMMemory = _anInteger;
	/* end setExtraVMMemory: */
	/* begin setNumStackPages: */
	_requestedNumPages = (_header.hdrNumStackPages);
	if (desiredNumStackPages != 0) {
		GIV(numStackPages) = desiredNumStackPages;
	} else {
		GIV(numStackPages) = ((_requestedNumPages == 0)
			 ? defaultNumStackPages()
			 : _requestedNumPages);
	}
	desiredNumStackPages = _requestedNumPages;
	if (GIV(desiredStackPageBytes) == 0) {
		/* begin setDesiredStackPageBytes: */
		GIV(desiredStackPageBytes) = 256 * BytesPerWord;
		/* end setDesiredStackPageBytes: */
	}
	/* end setNumStackPages: */
	/* begin initializeObjectMemoryWithEdenBytes: */
	_requestedEdenBytes = (_header.hdrEdenBytes);
	/* begin edenBytes: */
	if (desiredEdenBytes != 0) {
		_bytes = desiredEdenBytes;
	} else {
		_bytes = ((_requestedEdenBytes == 0)
			 ? defaultEdenBytes()
			 : _requestedEdenBytes);
	}
	GIV(edenBytes) = _bytes;
	/* end edenBytes: */
	desiredEdenBytes = _requestedEdenBytes;
	/* end initializeObjectMemoryWithEdenBytes: */
	if (((_header.hdrMaxExtSemTabSize)) != 0) {
		/* begin setMaxExtSemSizeTo: */
		_maxExtSemTabSize = (_header.hdrMaxExtSemTabSize);
		GIV(maxExtSemTabSizeSet) = 1;
		ioSetMaxExtSemTableSize(_maxExtSemTabSize);
		/* end setMaxExtSemSizeTo: */
	}
}
/* CoInterpreter>>#accessorDepthForPrimitiveIndex: */
signed char
accessorDepthForPrimitiveIndex(sqInt _primIndex)
{
	return primitiveAccessorDepthTable[_primIndex];
}
/*	Activate newMethod when newMethod has been cogged, i.e. create a 
	machine-code frame and (re)enter machine-code. */
/* CoInterpreter>>#activateCoggedNewMethod: */
static void NoDbgRegParms
activateCoggedNewMethod(sqInt _inInterpreter)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	CogMethod *_cogMethod;
	sqInt _i;
	sqInt _methodHeader;
	sqInt _numTemps;
	sqInt _object;
	sqInt _object2;
	sqInt _rcvr;
	char *_sp;
	char *_sp10;
	char *_sp2;
	char *_sp3;
	char *_sp4;
	char *_sp5;
	char *_sp6;
	char *_sp7;
	char *_sp8;
	char *_sp9;
	sqInt _switched;

	/* begin fetchPointer:ofObject: */
	_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(isCogMethodReference(_methodHeader));
	assert((((cogMethodOf(GIV(newMethod)))->methodObject)) == GIV(newMethod));
	_cogMethod = ((CogMethod *) _methodHeader );
	_methodHeader = (_cogMethod->methodHeader);
	_rcvr = unsignedLongAt(GIV(stackPointer) + (((_cogMethod->cmNumArgs)) * BytesPerWord));
	/* begin push: */
	unsignedLongAtput((_sp6 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
	GIV(stackPointer) = _sp6;
	/* end push: */
	if (((_cogMethod->stackCheckOffset)) == 0) {
		{
			if (((_cogMethod->cmNumArgs)) <= (numRegArgs())) {
				callRegisterArgCogMethodatreceiver(_cogMethod, noCheckEntryOffset(), _rcvr);
			}
		}
		/* begin push: */
		_object = ((sqInt) _cogMethod ) + (noCheckEntryOffset());
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
		GIV(stackPointer) = _sp;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _rcvr);
		GIV(stackPointer) = _sp2;
		/* end push: */
		ceCallCogCodePopReceiverReg();
		{
			assert(0);
		}
	}
	/* begin push: */
	unsignedLongAtput((_sp7 = GIV(stackPointer) - BytesPerWord), GIV(framePointer));
	GIV(stackPointer) = _sp7;
	/* end push: */
	GIV(framePointer) = GIV(stackPointer);
	/* begin push: */
	unsignedLongAtput((_sp8 = GIV(stackPointer) - BytesPerWord), ((sqInt) _cogMethod ));
	GIV(stackPointer) = _sp8;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp9 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
	GIV(stackPointer) = _sp9;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp10 = GIV(stackPointer) - BytesPerWord), _rcvr);
	GIV(stackPointer) = _sp10;
	/* end push: */
	_numTemps = (((usqInt) _methodHeader ) >> MethodHeaderTempCountShift) & 0x3F;
	for (_i = ((_cogMethod->cmNumArgs)) + 1; _i <= _numTemps; _i += 1) {
		/* begin push: */
		unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
		GIV(stackPointer) = _sp3;
		/* end push: */
	}
	if ((_methodHeader & AlternateHeaderHasPrimFlag) && (GIV(primFailCode) != 0)) {
		reapAndResetErrorCodeToheader(GIV(framePointer), _methodHeader);
	}
	if (GIV(stackPointer) >= GIV(stackLimit)) {
		assert(((_cogMethod->stackCheckOffset)) > (noCheckEntryOffset()));
		/* begin push: */
		_object2 = ((sqInt) _cogMethod ) + ((_cogMethod->stackCheckOffset));
		unsignedLongAtput((_sp4 = GIV(stackPointer) - BytesPerWord), _object2);
		GIV(stackPointer) = _sp4;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp5 = GIV(stackPointer) - BytesPerWord), _rcvr);
		GIV(stackPointer) = _sp5;
		/* end push: */
		ceEnterCogCodePopReceiverReg();
		{
			assert(0);
		}
	}
	GIV(instructionPointer) = ((sqInt) _cogMethod ) + ((_cogMethod->stackCheckOffset));
	_switched = handleStackOverflowOrEventAllowContextSwitch(canContextSwitchIfActivatingheader(GIV(newMethod), _methodHeader));
	returnToExecutivepostContextSwitch(_inInterpreter, _switched);
}
/*	Eagerly compile it if appropriate so that doits are fast. */
/* CoInterpreter>>#activateNewMethod */
static void
activateNewMethod(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _header;
	sqInt _i;
	sqInt _inInterpreter;
	sqInt _methodHeader;
	sqInt _methodHeader2;
	sqInt _numArgs;
	sqInt _numTemps;
	sqInt _object;
	sqInt _object2;
	sqInt _rcvr;
	sqInt _shouldSkipStoreBytecode;
	char *_sp;
	char *_sp2;
	char *_sp22;
	char *_sp3;
	char *_sp4;
	char *_sp5;
	char *_sp6;
	char *_sp7;
	sqInt _switched;

	/* begin fetchPointer:ofObject: */
	_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	if ((assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0)) {
		if (_inInterpreter) {
			/* begin iframeSavedIP:put: */
			assert(!(isMachineCodeFrame(GIV(framePointer))));
			unsignedLongAtput(GIV(framePointer) + FoxIFSavedIP, ((sqInt) GIV(instructionPointer) ));
			/* end iframeSavedIP:put: */
			GIV(instructionPointer) = ceReturnToInterpreterPC();
		}
		{
			activateCoggedNewMethod(_inInterpreter);
			return;
		}
	} else {
		/* begin activateNewMethodInterpreted */
		/* begin push: */
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
		GIV(stackPointer) = _sp;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), GIV(framePointer));
		GIV(stackPointer) = _sp2;
		/* end push: */
		GIV(framePointer) = GIV(stackPointer);
		/* begin setupFrameForNewMethodInterpreted */
		/* begin methodHeaderOf: */
		assert(isCompiledMethod(GIV(newMethod)));
		/* begin fetchPointer:ofObject: */
		_header = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_header & 7) == 1)) {
			_methodHeader2 = _header;
		} else {
			assert(((usqInt) _header ) < ((GIV(memoryMap)->newSpaceStart)));
			assert((((((CogMethod *) _header ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
			_methodHeader2 = ((((CogMethod *) _header ))->methodHeader);
		}
		/* end methodHeaderOf: */
		_numTemps = (((usqInt) _methodHeader2 ) >> MethodHeaderTempCountShift) & 0x3F;
		/* begin argumentCountOfMethodHeader: */
		_numArgs = (((usqInt) _methodHeader2 ) >> MethodHeaderArgCountShift) & 15;
		/* end argumentCountOfMethodHeader: */
		_rcvr = unsignedLongAt(GIV(stackPointer) + ((_numArgs + 2) * BytesPerWord));
		assert(!(isOopForwarded(_rcvr)));
		/* begin setupFrameFixedPartForNewMethodInterpreted:withHeader:withContext:isBlock:withNumArgs:withReceiver: */
		/* begin push: */
		unsignedLongAtput((_sp22 = GIV(stackPointer) - BytesPerWord), GIV(newMethod));
		GIV(stackPointer) = _sp22;
		/* end push: */
		/* begin setMethod:methodHeader: */
		/* begin setMethod: */
		assert(((usqInt) GIV(newMethod) ) >= (startOfObjectMemory(getMemoryMap())));
		{
			GIV(method) = GIV(newMethod);
			assert(isOopCompiledMethod(GIV(method)));
		}
		/* end setMethod: */
		assert((methodHeaderOf(GIV(method))) == _methodHeader2);
		/* end setMethod:methodHeader: */
		/* begin push: */
		unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
		GIV(stackPointer) = _sp3;
		/* end push: */
		/* begin push: */
		/* begin encodeFrameFieldHasContext:isBlock:numArgs: */
		_object2 = ((VMBIGENDIAN)
			 ? ((1 + ((sqInt) (((usqInt) _numArgs ) << ((BytesPerWord * 8) - 8)) )) + (((GIV(nilObj) != GIV(nilObj))
				 ? 1ULL << ((BytesPerWord * 8) - 16)
				 : 0))) + 0
			 : ((1 + ((sqInt) (((usqInt) _numArgs ) << 8) )) + (((GIV(nilObj) != GIV(nilObj))
				 ? 1U << 16
				 : 0))) + 0);
		/* end encodeFrameFieldHasContext:isBlock:numArgs: */
		unsignedLongAtput((_sp4 = GIV(stackPointer) - BytesPerWord), _object2);
		GIV(stackPointer) = _sp4;
		/* end push: */
		{
			/* begin push: */
			unsignedLongAtput((_sp6 = GIV(stackPointer) - BytesPerWord), 0);
			GIV(stackPointer) = _sp6;
			/* end push: */
		}
		/* begin push: */
		unsignedLongAtput((_sp5 = GIV(stackPointer) - BytesPerWord), _rcvr);
		GIV(stackPointer) = _sp5;
		/* end push: */
		/* end setupFrameFixedPartForNewMethodInterpreted:withHeader:withContext:isBlock:withNumArgs:withReceiver: */
		GIV(instructionPointer) = pointerForOop(((GIV(newMethod) + ((LiteralStart + ((assert(((_methodHeader2 & 7) == 1)), (_methodHeader2 >> 3) & AlternateHeaderNumLiteralsMask))) * BytesPerOop)) + BaseHeaderSize) - 1);
		for (_i = _numArgs + 1; _i <= _numTemps; _i += 1) {
			/* begin push: */
			_object = GIV(nilObj);
			unsignedLongAtput((_sp7 = GIV(stackPointer) - BytesPerWord), _object);
			GIV(stackPointer) = _sp7;
			/* end push: */
		}
		if (methodHeaderHasPrimitive(_methodHeader2)) {
			GIV(instructionPointer) += 3;
			if (GIV(primFailCode) != 0) {
				_shouldSkipStoreBytecode = reapAndResetErrorCodeToheader(GIV(framePointer), _methodHeader2);
				if (_shouldSkipStoreBytecode) {
					GIV(instructionPointer) += 2;
				}
			}
		}
		assert((frameNumArgs(GIV(framePointer))) == GIV(argumentCount));
		assert(!(frameIsBlockActivation(GIV(framePointer))));
		assert(!(frameHasContext(GIV(framePointer))));
		/* end setupFrameForNewMethodInterpreted */
		/* end activateNewMethodInterpreted */
	}
	_switched = 1;
	if (GIV(stackPointer) < GIV(stackLimit)) {
		_switched = handleStackOverflowOrEventAllowContextSwitch(canContextSwitchIfActivatingheader(GIV(newMethod), _methodHeader));
	}
	returnToExecutivepostContextSwitch(_inInterpreter, _switched);
}
/*	Add the given entry to the method cache. 
	The policy is as follows: 
	Look for an empty entry anywhere in the reprobe chain. 
	If found, install the new entry there. 
	If not found, then install the new entry at the first probe position 
	and delete the entries in the rest of the reprobe chain. 
	This has two useful purposes: 
	If there is active contention over the first slot, the second 
	or third will likely be free for reentry after ejection. 
	Also, flushing is good when reprobe chains are getting full.Override to refuse to cache other than compiled methods. 
	This protects open PICs against having to test for compiled methods. */
/* CoInterpreter>>#addNewMethodToCache: */
static void NoDbgRegParms
addNewMethodToCache(sqInt _classObj)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classTag;
	sqInt _err;
	sqInt _err2;
	sqInt _err3;
	sqInt _firstBytecode;
	sqInt _hash2;
	sqInt _hash3;
	sqInt _hash4;
	sqInt _header;
	sqInt _methodHeader;

	if (!(((GIV(newMethod) & (tagMask())) == 0) && (((((usqInt) (longAt(GIV(newMethod))) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())))) {
		primitiveFunctionPointer = primitiveInvokeObjectAsMethod;
		return;
	}
	{
		sqInt _hash;
		sqInt _p;
		sqInt _primitiveIndex;
		sqInt _probe;

		/* begin methodCacheHashOf:with: */
		{
			assert(addressCouldBeClassObj(_classObj));
			_classTag = ((((_hash2 = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask()))) != 0)
				 ? _hash2
				 : ((objCouldBeClassObj(_classObj))
					 ? ((((_err = enterIntoClassTable(_classObj))) != 0)
						 ? -_err
						 : (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask()))
					 : -PrimErrBadReceiver));
		}
		_hash = GIV(messageSelector) ^ ((sqInt) (((usqInt) _classTag ) << 2) );
		/* end methodCacheHashOf:with: */
		if (((GIV(newMethod) & (tagMask())) == 0) && (((((usqInt) (longAt(GIV(newMethod))) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()))) {
			/* begin primitiveIndexOfMethod:header: */
			/* begin methodHeaderOf: */
			assert(isCompiledMethod(GIV(newMethod)));
			/* begin fetchPointer:ofObject: */
			_header = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_header & 7) == 1)) {
				_methodHeader = _header;
			} else {
				assert(((usqInt) _header ) < ((GIV(memoryMap)->newSpaceStart)));
				assert((((((CogMethod *) _header ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
				_methodHeader = ((((CogMethod *) _header ))->methodHeader);
			}
			/* end methodHeaderOf: */
			if (_methodHeader & AlternateHeaderHasPrimFlag) {
				_firstBytecode = (GIV(newMethod) + ((LiteralStart + ((_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) * BytesPerOop)) + BaseHeaderSize;
				_primitiveIndex = (byteAt(_firstBytecode + 1)) + ((sqInt) (((usqInt) (byteAt(_firstBytecode + 2)) ) << 8) );
			} else {
				_primitiveIndex = 0;
			}
			/* end primitiveIndexOfMethod:header: */
			/* begin functionPointerFor: */
			primitiveFunctionPointer = ((void (*)(void)) (((_primitiveIndex > MaxPrimitiveIndex)
				 ? 0
				 : primitiveTable[_primitiveIndex])) );
			/* end functionPointerFor: */
		} else {
			assert(!((isNonImmediate(GIV(newMethod))) && (isForwarded(GIV(newMethod)))));
			primitiveFunctionPointer = primitiveInvokeObjectAsMethod;
		}
		for (_p = 0; _p < CacheProbeMax; _p += 1) {
			_probe = (((usqInt) _hash ) >> _p) & MethodCacheMask;
			if ((GIV(methodCache)[_probe + MethodCacheSelector]) == 0) {
				GIV(methodCache)[_probe + MethodCacheSelector] = GIV(messageSelector);
				GIV(methodCache)[_probe + MethodCacheClass] = (assert(addressCouldBeClassObj(_classObj)), ((((_hash3 = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask()))) != 0)
					 ? _hash3
					 : ((objCouldBeClassObj(_classObj))
						 ? ((((_err2 = enterIntoClassTable(_classObj))) != 0)
							 ? -_err2
							 : (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask()))
						 : -PrimErrBadReceiver)));
				GIV(methodCache)[_probe + MethodCacheMethod] = GIV(newMethod);
				GIV(methodCache)[_probe + MethodCachePrimFunction] = ((sqIntptr_t) primitiveFunctionPointer );
				GIV(lastMethodCacheProbeWrite) = _probe;
				return;
			}
		}
		_probe = _hash & MethodCacheMask;
		GIV(methodCache)[_probe + MethodCacheSelector] = GIV(messageSelector);
		GIV(methodCache)[_probe + MethodCacheClass] = (assert(addressCouldBeClassObj(_classObj)), ((((_hash4 = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask()))) != 0)
			 ? _hash4
			 : ((objCouldBeClassObj(_classObj))
				 ? ((((_err3 = enterIntoClassTable(_classObj))) != 0)
					 ? -_err3
					 : (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask()))
				 : -PrimErrBadReceiver)));
		GIV(methodCache)[_probe + MethodCacheMethod] = GIV(newMethod);
		GIV(methodCache)[_probe + MethodCachePrimFunction] = ((sqIntptr_t) primitiveFunctionPointer );
		GIV(lastMethodCacheProbeWrite) = _probe;
		for (_p = 1; _p < CacheProbeMax; _p += 1) {
			_probe = (((usqInt) _hash ) >> _p) & MethodCacheMask;
			GIV(methodCache)[_probe + MethodCacheSelector] = 0;
		}
	}
}
/* CoInterpreter>>#allocateMemoryForImage:withHeader: */
static void NoDbgRegParms
allocateMemoryForImagewithHeader(sqImageFile _f, SpurImageHeaderStruct _header)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMMemoryMap * cascade0;
	sqInt _actualEdenBytes;
	SpurNewSpaceSpace *_aNewSpace;
	sqInt _bridge;
	sqInt _bridgehead;
	usqLong _bridgeSpan;
	sqInt _bytesRead;
	size_t _bytesRead2;
	sqInt _bytesRead3;
	sqInt _bytesToShift;
	sqInt _bytesToShift2;
	sqInt _classArrayClass;
	sqInt _classArrayClass2;
	sqInt _classArrayObj;
	sqInt _classArrayObj2;
	sqInt _i;
	sqInt _i2;
	sqInt _i22;
	sqInt _i3;
	sqInt _i32;
	sqInt _i4;
	sqInt _iLimit;
	sqInt _iLimit2;
	usqInt _limit;
	sqInt _newBase;
	size_t _nextSegmentSize;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _oldBase;
	sqInt _oldSpaceBytesRead;
	sqInt _oldSpaceBytesRead2;
	sqInt _oop;
	sqInt _oop2;
	sqInt _p;
	sqInt _permSpaceBytesRead;
	sqInt _permSpaceBytesRead2;
	sqInt _requestedSurvivorBytes;
	sqInt _reserve;
	SpurSegmentInfo *_segInfo2;
	sqInt _startAddress;
	sqInt _survivorBytes;
	sqInt _totalBytes;
	size_t _totalBytesRead;

	if (desiredCogCodeSize != 0) {
		GIV(cogCodeSize) = desiredCogCodeSize;
	} else {
		GIV(cogCodeSize) = ((((_header.hdrCogCodeSize)) == 0)
			 ? defaultCogCodeSize()
			 : (_header.hdrCogCodeSize));
	}
	GIV(cogCodeSize) = ((GIV(cogCodeSize) < (maxCogCodeSize())) ? GIV(cogCodeSize) : maxCogCodeSize());
	((getMemoryMap())->initialCodeZoneSize = GIV(cogCodeSize));
	{
		/* begin allocateMemoryForImageHeader: */
		{
			/* begin getMemoryMap */
			cascade0 = GIV(memoryMap);
			/* end getMemoryMap */
			(cascade0->allocationReserve = interpreterAllocationReserveBytes());
			(cascade0->initialOldSpaceSize = (_header.hdrOldSpaceSize));
			(cascade0->initialNewSpaceSize = GIV(edenBytes));
			(cascade0->initialHeadroom = initialHeadroomgivenFreeOldSpaceInImage(extraVMMemory, (_header.freeOldSpaceInImage)));
			allocateHeap(cascade0);
		}
		/* begin initializeFromMemoryMap */
		_reserve = interpreterAllocationReserveBytes();
		/* begin newSpaceStart:newSpaceBytes:survivorBytes: */
		_startAddress = ((sqInt) ((GIV(memoryMap)->newSpaceStart)) );
		_totalBytes = ((sqInt) (((GIV(memoryMap)->newSpaceEnd)) - ((GIV(memoryMap)->newSpaceStart))) );
		_requestedSurvivorBytes = ((sqInt) (((((GIV(memoryMap)->newSpaceEnd)) - ((GIV(memoryMap)->newSpaceStart))) - _reserve) / 7) );
		_survivorBytes = (_requestedSurvivorBytes & ~7);
		_actualEdenBytes = (((_totalBytes - _survivorBytes) - _survivorBytes) & ~7);
		assert((((_totalBytes - _actualEdenBytes) - _survivorBytes) - _survivorBytes) < (allocationUnit()));
		{
			(GIV(pastSpace).start = _startAddress);
			(GIV(pastSpace).limit = _startAddress + _survivorBytes);
		}
		{
			(GIV(futureSpace).start = (GIV(pastSpace).limit));
			(GIV(futureSpace).limit = ((GIV(pastSpace).limit)) + _survivorBytes);
		}
		{
			(GIV(eden).start = (GIV(futureSpace).limit));
			(GIV(eden).limit = _startAddress + _totalBytes);
		}
		((getFromOldSpaceRememberedSet())->fudge = ((((GIV(eden).limit)) - ((GIV(eden).start))) / BytesPerWord) / 1024);
		((getFromPermToOldSpaceRememberedSet())->fudge = ((((GIV(eden).limit)) - ((GIV(eden).start))) / BytesPerWord) / 1024);
		((getFromPermToNewSpaceRememberedSet())->fudge = ((((GIV(eden).limit)) - ((GIV(eden).start))) / BytesPerWord) / 1024);
		assert((((futureSpace()).limit)) <= (_startAddress + _totalBytes));
		assert((((((eden()).start)) % (allocationUnit())) + ((((eden()).limit)) % (allocationUnit()))) == 0);
		assert((((((pastSpace()).start)) % (allocationUnit())) + ((((pastSpace()).limit)) % (allocationUnit()))) == 0);
		assert((((((futureSpace()).start)) % (allocationUnit())) + ((((futureSpace()).limit)) % (allocationUnit()))) == 0);
		/* begin initFutureSpaceStart */
		GIV(futureSurvivorStart) = (GIV(futureSpace).start);
		/* end initFutureSpaceStart */
		/* begin initSpaceForAllocationCheck:limit: */
		_aNewSpace = ((SpurNewSpaceSpace *) &GIV(eden) );
		_limit = (GIV(eden).limit);
		if (checkAllocFiller()) {
			for (_p = (_aNewSpace->start); _p < _limit; _p += BytesPerWord) {
				longAtput(_p, _p);
			}
		}
		/* end initSpaceForAllocationCheck:limit: */
		GIV(tenuringProportion) = 0.9;
		/* end newSpaceStart:newSpaceBytes:survivorBytes: */
		GIV(freeStart) = ((eden()).start);
		GIV(pastSpaceStart) = ((pastSpace()).start);
		GIV(freeOldSpaceStart) = (GIV(memoryMap)->oldSpaceEnd);
		GIV(permSpaceFreeStart) = (GIV(memoryMap)->permSpaceStart);
		/* end initializeFromMemoryMap */
		goto l23;
		l23:
		;
		/* end allocateMemoryForImageHeader: */
		if (hasToUseComposedFormat()) {
			/* begin CIR_doLoadImageFromFile:withHeader: */
			_oldSpaceBytesRead = CIR_readSegmentsFromImageFileheader(_f, _header);
			_permSpaceBytesRead = CIR_readPermanentSpaceFromImageFileheader(_f, _header);
			_bytesRead = _oldSpaceBytesRead + _permSpaceBytesRead;
			/* begin initializeInterpreterFromHeader:withBytes: */
			if (_bytesRead != ((_header.dataSize))) {
				logError("Expecting %lld Got %lld", (_header.dataSize), _bytesRead);
				unableToReadImageError();
			}
			ensureImageFormatIsUpToDate((_header.swapBytes));
			_bytesToShift = (((getMemoryMap())->oldSpaceStart)) - ((_header.oldBaseAddr));
			/* begin initializeInterpreter: */
			initializeObjectMemory(_bytesToShift);
			/* begin checkAssumedCompactClasses */
			/* begin checkCompactIndex:isClass:named: */
			if ((unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ))) != ((assert((ClassArrayCompactIndex >= 1) && (ClassArrayCompactIndex <= (classTablePageSize()))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArrayCompactIndex ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */))) {
				invalidCompactClassError("Array");
			}
			/* end checkCompactIndex:isClass:named: */
			/* begin checkCompactIndex:isClass:named: */
			if ((unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargeNegativeInteger ) << (shiftForWord())) ))) != ((assert((ClassLargeNegativeIntegerCompactIndex >= 1) && (ClassLargeNegativeIntegerCompactIndex <= (classTablePageSize()))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargeNegativeIntegerCompactIndex ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */))) {
				invalidCompactClassError("LargeNegativeInteger");
			}
			/* end checkCompactIndex:isClass:named: */
			/* begin checkCompactIndex:isClass:named: */
			if ((unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ))) != ((assert((ClassLargePositiveIntegerCompactIndex >= 1) && (ClassLargePositiveIntegerCompactIndex <= (classTablePageSize()))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveIntegerCompactIndex ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */))) {
				invalidCompactClassError("LargePositiveInteger");
			}
			/* end checkCompactIndex:isClass:named: */
			/* begin checkCompactIndex:isClass:named: */
			if ((unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassFloat ) << (shiftForWord())) ))) != ((assert((ClassFloatCompactIndex >= 1) && (ClassFloatCompactIndex <= (classTablePageSize()))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassFloatCompactIndex ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */))) {
				invalidCompactClassError("Float");
			}
			/* end checkCompactIndex:isClass:named: */
			/* begin checkCompactIndex:isClass:named: */
			if ((unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassMethodContext ) << (shiftForWord())) ))) != ((assert((ClassMethodContextCompactIndex >= 1) && (ClassMethodContextCompactIndex <= (classTablePageSize()))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassMethodContextCompactIndex ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */))) {
				invalidCompactClassError("MethodContext");
			}
			/* end checkCompactIndex:isClass:named: */
			/* begin compactIndexOfClass: */
			/* begin splObj: */
			/* begin fetchPointer:ofObject: */
			_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteArray ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			/* end splObj: */
			assert((rawHashBitsOf(_objOop)) != 0);
			GIV(classByteArrayCompactIndex) = (uint32AtPointer(_objOop + 4)) & (identityHashHalfWordMask());
			/* end compactIndexOfClass: */
			/* end checkAssumedCompactClasses */
			/* begin initializeExtraClassInstVarIndices */
			/* begin splObj: */
			/* begin fetchPointer:ofObject: */
			_classArrayObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			/* end splObj: */
			_classArrayClass = fetchClassOfNonImm(_classArrayObj);
			/* begin numSlotsOf: */
			assert((classIndexOf(_classArrayClass)) > (isForwardedObjectClassIndexPun()));
			_numSlots = byteAt(_classArrayClass + 7);
			GIV(metaclassNumSlots) = ((_numSlots == (numSlotsMask()))
				 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_classArrayClass - BaseHeaderSize)) ) << 8) ) ) ) >> 8
				 : _numSlots);
			/* end numSlotsOf: */
			GIV(thisClassIndex) = 5;
			for (_i3 = InstanceSpecificationIndex + 1, _iLimit = lengthOfformat(_classArrayClass, (((usqInt) (longAt(_classArrayClass)) ) >> (formatShift())) & (formatMask())); _i3 <= _iLimit; _i3 += 1) {
				if ((unsignedLongAt((_classArrayClass + BaseHeaderSize) + ((sqInt) (((usqInt) (_i3 - 1) ) << (shiftForWord())) ))) == _classArrayObj) {
					GIV(thisClassIndex) = _i3 - 1;
				}
			}
			GIV(classNameIndex) = 6;
			for (_i3 = InstanceSpecificationIndex + 1, _iLimit = lengthOfformat(_classArrayObj, (((usqInt) (longAt(_classArrayObj)) ) >> (formatShift())) & (formatMask())); _i3 <= _iLimit; _i3 += 1) {
				/* begin fetchPointer:ofObject: */
				_oop = unsignedLongAt((_classArrayObj + BaseHeaderSize) + ((sqInt) (((usqInt) (_i3 - 1) ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if ((((_oop & (tagMask())) == 0) && (((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat()))) && (((lengthOfformat(_oop, (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask()))) == 5) && ((strncmp("Array", firstFixedField(_oop), 5)) == 0))) {
					GIV(classNameIndex) = _i3 - 1;
				}
			}
			/* end initializeExtraClassInstVarIndices */
			GIV(method) = (GIV(newMethod) = GIV(nilObj));
			GIV(methodDictLinearSearchLimit) = 8;
			/* begin initialCleanup */
			/* begin flushMethodCache */
			for (_i = 1; _i <= MethodCacheSize; _i += 1) {
				GIV(methodCache)[_i] = 0;
			}
			GIV(lastMethodCacheProbeWrite) = 0;
			/* end flushMethodCache */
			/* begin flushExternalPrimitiveTable */
			for (_i2 = 0; _i2 < MaxExternalPrimitiveTableSize; _i2 += 1) {
				externalPrimitiveTable[_i2] = 0;
			}
			GIV(externalPrimitiveTableFirstFreeIndex) = 0;
			/* end flushExternalPrimitiveTable */
			/* end initialCleanup */
			GIV(profileSemaphore) = (GIV(profileProcess) = (GIV(profileMethod) = GIV(nilObj)));
			/* begin initializeGlobalSessionID */
			while (GIV(globalSessionID) == 0) {
				GIV(globalSessionID) = ((time(NULL)) + (ioMSecs())) & 0x7FFFFFFF;
			}
			/* end initializeGlobalSessionID */
			GIV(metaAccessorDepth) = -2;
			/* end initializeInterpreter: */
			/* end initializeInterpreterFromHeader:withBytes: */
			/* end CIR_doLoadImageFromFile:withHeader: */
		} else {
			/* begin SIR_doLoadImageFromFile:withHeader: */
			/* begin SIR_readSegmentsFromImageFile:header: */
			/* begin prepareSegmentsToRead */
			/* begin clearSegments */
			GIV(numSegments) = 0;
			/* end clearSegments */
			allocateOrExtendSegmentInfos();
			/* end prepareSegmentsToRead */
			_totalBytesRead = 0;
			_oldBase = (_header.oldBaseAddr);
			_newBase = ((getMemoryMap())->oldSpaceStart);
			_nextSegmentSize = (_header.firstSegSize);
			_bridgehead = (((_header.firstSegSize)) + (((getMemoryMap())->oldSpaceStart))) - (2 * BaseHeaderSize);
			while (1) {
				/* begin withNewSegmentDo: */
				_segInfo2 = &(GIV(segments)[GIV(numSegments)]);
				{
					(_segInfo2->segStart = _oldBase);
					(_segInfo2->segSize = _nextSegmentSize);
					(_segInfo2->swizzle = _newBase - _oldBase);
				}
				if (((GIV(numSegments) += 1)) >= GIV(numSegInfos)) {
					allocateOrExtendSegmentInfos();
				}
				/* end withNewSegmentDo: */
				_bytesRead2 = sqImageFileRead(pointerForOop(_newBase), sizeof(char), _nextSegmentSize, ((sqImageFile) _f ));
				if (_bytesRead2 > 0) {
					_totalBytesRead += _bytesRead2;
				}
				if (_bytesRead2 != _nextSegmentSize) {
					unableToReadImageError();
				}
				_bridge = _bridgehead + BaseHeaderSize;
				_bridgeSpan = (((byteAt(_bridgehead + 7)) == 0)
					 ? 0
					 : BytesPerOop * (((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_bridge - BaseHeaderSize)) ) << 8) ) ) ) >> 8));
				_oldBase = (_oldBase + _nextSegmentSize) + _bridgeSpan;
				_newBase = (_newBase + _nextSegmentSize) - (2 * BaseHeaderSize);
				_nextSegmentSize = ((usqInt) (long64At(_bridge)) );
				if (!(_nextSegmentSize != 0)) 
					break;
				_bridgehead = (_bridgehead - (2 * BaseHeaderSize)) + _nextSegmentSize;
			}
			/* begin finalizeSegmentsRead:newBase: */
			assert((_newBase - (((getMemoryMap())->oldSpaceStart))) == (_totalBytesRead - ((numSegments()) * (bridgeSize()))));
			/* begin setCanSwizzle: */
			GIV(canSwizzle) = 1;
			/* end setCanSwizzle: */
			/* begin setFreeOldSpaceStart: */
			GIV(freeOldSpaceStart) = _newBase;
			/* end setFreeOldSpaceStart: */
			/* end finalizeSegmentsRead:newBase: */
			_oldSpaceBytesRead2 = _totalBytesRead;
			/* end SIR_readSegmentsFromImageFile:header: */
			_permSpaceBytesRead2 = 0;
			_bytesRead3 = _oldSpaceBytesRead2 + _permSpaceBytesRead2;
			/* begin initializeInterpreterFromHeader:withBytes: */
			if (_bytesRead3 != ((_header.dataSize))) {
				logError("Expecting %lld Got %lld", (_header.dataSize), _bytesRead3);
				unableToReadImageError();
			}
			ensureImageFormatIsUpToDate((_header.swapBytes));
			_bytesToShift2 = (((getMemoryMap())->oldSpaceStart)) - ((_header.oldBaseAddr));
			/* begin initializeInterpreter: */
			initializeObjectMemory(_bytesToShift2);
			/* begin checkAssumedCompactClasses */
			/* begin checkCompactIndex:isClass:named: */
			if ((unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ))) != ((assert((ClassArrayCompactIndex >= 1) && (ClassArrayCompactIndex <= (classTablePageSize()))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArrayCompactIndex ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */))) {
				invalidCompactClassError("Array");
			}
			/* end checkCompactIndex:isClass:named: */
			/* begin checkCompactIndex:isClass:named: */
			if ((unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargeNegativeInteger ) << (shiftForWord())) ))) != ((assert((ClassLargeNegativeIntegerCompactIndex >= 1) && (ClassLargeNegativeIntegerCompactIndex <= (classTablePageSize()))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargeNegativeIntegerCompactIndex ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */))) {
				invalidCompactClassError("LargeNegativeInteger");
			}
			/* end checkCompactIndex:isClass:named: */
			/* begin checkCompactIndex:isClass:named: */
			if ((unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ))) != ((assert((ClassLargePositiveIntegerCompactIndex >= 1) && (ClassLargePositiveIntegerCompactIndex <= (classTablePageSize()))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveIntegerCompactIndex ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */))) {
				invalidCompactClassError("LargePositiveInteger");
			}
			/* end checkCompactIndex:isClass:named: */
			/* begin checkCompactIndex:isClass:named: */
			if ((unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassFloat ) << (shiftForWord())) ))) != ((assert((ClassFloatCompactIndex >= 1) && (ClassFloatCompactIndex <= (classTablePageSize()))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassFloatCompactIndex ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */))) {
				invalidCompactClassError("Float");
			}
			/* end checkCompactIndex:isClass:named: */
			/* begin checkCompactIndex:isClass:named: */
			if ((unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassMethodContext ) << (shiftForWord())) ))) != ((assert((ClassMethodContextCompactIndex >= 1) && (ClassMethodContextCompactIndex <= (classTablePageSize()))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassMethodContextCompactIndex ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */))) {
				invalidCompactClassError("MethodContext");
			}
			/* end checkCompactIndex:isClass:named: */
			/* begin compactIndexOfClass: */
			/* begin splObj: */
			/* begin fetchPointer:ofObject: */
			_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteArray ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			/* end splObj: */
			assert((rawHashBitsOf(_objOop2)) != 0);
			GIV(classByteArrayCompactIndex) = (uint32AtPointer(_objOop2 + 4)) & (identityHashHalfWordMask());
			/* end compactIndexOfClass: */
			/* end checkAssumedCompactClasses */
			/* begin initializeExtraClassInstVarIndices */
			/* begin splObj: */
			/* begin fetchPointer:ofObject: */
			_classArrayObj2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			/* end splObj: */
			_classArrayClass2 = fetchClassOfNonImm(_classArrayObj2);
			/* begin numSlotsOf: */
			assert((classIndexOf(_classArrayClass2)) > (isForwardedObjectClassIndexPun()));
			_numSlots2 = byteAt(_classArrayClass2 + 7);
			GIV(metaclassNumSlots) = ((_numSlots2 == (numSlotsMask()))
				 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_classArrayClass2 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
				 : _numSlots2);
			/* end numSlotsOf: */
			GIV(thisClassIndex) = 5;
			for (_i32 = InstanceSpecificationIndex + 1, _iLimit2 = lengthOfformat(_classArrayClass2, (((usqInt) (longAt(_classArrayClass2)) ) >> (formatShift())) & (formatMask())); _i32 <= _iLimit2; _i32 += 1) {
				if ((unsignedLongAt((_classArrayClass2 + BaseHeaderSize) + ((sqInt) (((usqInt) (_i32 - 1) ) << (shiftForWord())) ))) == _classArrayObj2) {
					GIV(thisClassIndex) = _i32 - 1;
				}
			}
			GIV(classNameIndex) = 6;
			for (_i32 = InstanceSpecificationIndex + 1, _iLimit2 = lengthOfformat(_classArrayObj2, (((usqInt) (longAt(_classArrayObj2)) ) >> (formatShift())) & (formatMask())); _i32 <= _iLimit2; _i32 += 1) {
				/* begin fetchPointer:ofObject: */
				_oop2 = unsignedLongAt((_classArrayObj2 + BaseHeaderSize) + ((sqInt) (((usqInt) (_i32 - 1) ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if ((((_oop2 & (tagMask())) == 0) && (((((usqInt) (longAt(_oop2)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat()))) && (((lengthOfformat(_oop2, (((usqInt) (longAt(_oop2)) ) >> (formatShift())) & (formatMask()))) == 5) && ((strncmp("Array", firstFixedField(_oop2), 5)) == 0))) {
					GIV(classNameIndex) = _i32 - 1;
				}
			}
			/* end initializeExtraClassInstVarIndices */
			GIV(method) = (GIV(newMethod) = GIV(nilObj));
			GIV(methodDictLinearSearchLimit) = 8;
			/* begin initialCleanup */
			/* begin flushMethodCache */
			for (_i4 = 1; _i4 <= MethodCacheSize; _i4 += 1) {
				GIV(methodCache)[_i4] = 0;
			}
			GIV(lastMethodCacheProbeWrite) = 0;
			/* end flushMethodCache */
			/* begin flushExternalPrimitiveTable */
			for (_i22 = 0; _i22 < MaxExternalPrimitiveTableSize; _i22 += 1) {
				externalPrimitiveTable[_i22] = 0;
			}
			GIV(externalPrimitiveTableFirstFreeIndex) = 0;
			/* end flushExternalPrimitiveTable */
			/* end initialCleanup */
			GIV(profileSemaphore) = (GIV(profileProcess) = (GIV(profileMethod) = GIV(nilObj)));
			/* begin initializeGlobalSessionID */
			while (GIV(globalSessionID) == 0) {
				GIV(globalSessionID) = ((time(NULL)) + (ioMSecs())) & 0x7FFFFFFF;
			}
			/* end initializeGlobalSessionID */
			GIV(metaAccessorDepth) = -2;
			/* end initializeInterpreter: */
			/* end initializeInterpreterFromHeader:withBytes: */
			/* end SIR_doLoadImageFromFile:withHeader: */
		}
	}
	initializeCodeZoneFromupTo(((getMemoryMap())->codeZoneStart), ((getMemoryMap())->codeZoneEnd));
}
/* CoInterpreter>>#argumentCountAddress */
usqInt
argumentCountAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((usqInt) &GIV(argumentCount) );
}
/* CoInterpreter>>#assertValidExecutionPointe:r:s:imbar:line: */
static void NoDbgRegParms
assertValidExecutionPointersimbarline(usqInt _lip, char *_lifp, char *_lisp, sqInt _inInterpreter, sqInt _ln)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	CogMethod *_cogMethod;
	sqInt _methodField;
	sqInt _methodField2;
	usqInt _theIP;

	assertl(GIV(stackPage) == (mostRecentlyUsedPage()), _ln);
	assertl(addressIsInPage(GIV(stackPage), _lifp), _ln);
	assert(deferStackLimitSmashAroundwith(assertValidStackLimits, _ln));
	assertl(_lisp < _lifp, _ln);
	assertl(_lifp > _lisp, _ln);
	assertl(_lisp >= (((GIV(stackPage)->realStackLimit)) - (stackLimitOffset())), _ln);
	assertl(((_lifp - _lisp) / BytesPerOop) < LargeContextSlots, _ln);
	_methodField = unsignedLongAt(_lifp + FoxMethod);
	if (_inInterpreter) {
		assertl(!(isMachineCodeFrame(_lifp)), _ln);
		assertl(GIV(method) == _methodField, _ln);
		if (assertal(cheapAddressCouldBeInHeap(_methodField), _ln)) {
			if (_lip == (ceReturnToInterpreterPC())) {
				_theIP = unsignedLongAt(_lifp + FoxIFSavedIP);
			} else {
				_theIP = _lip;
			}
			assertl((_theIP >= (_methodField + (lastPointerOf(_methodField)))) && (_theIP <= (((_methodField + (numBytesOfBytes(_methodField))) + BaseHeaderSize) - 1)), _ln);
		}
		assertl((iframeIsBlockActivation(_lifp)) || ((pushedReceiverOrClosureOfFrame(_lifp)) == (iframeReceiver(_lifp))), _ln);
	} else {
		assertl(isMachineCodeFrame(_lifp), _ln);
		if ((assertal(((usqInt) _methodField ) >= (minCogMethodAddress()), _ln)) && (assertal(((usqInt) _methodField ) < (maxCogMethodAddress()), _ln))) {
			/* begin mframeHomeMethod: */
			_methodField2 = unsignedLongAt(_lifp + FoxMethod);
			_cogMethod = ((CogMethod *) (_methodField2 & MFMethodMask) );
			/* end mframeHomeMethod: */
			assertl((_lip > (_methodField + (sizeof(CogMethod)))) && (_lip < (_methodField + ((_cogMethod->blockSize)))), _ln);
		}
		assertl((mframeIsBlockActivation(_lifp)) || ((pushedReceiverOrClosureOfFrame(_lifp)) == (mframeReceiver(_lifp))), _ln);
	}
	if ((unsignedLongAt(_lifp + FoxSavedFP)) == 0) {
		assertl(frameHasContext(_lifp), _ln);
		assertl((frameContext(_lifp)) == (unsignedLongAt(((GIV(stackPage)->baseAddress)) - BytesPerWord)), _ln);
	}
}
/* CoInterpreter>>#assertValidMachineCodeFrame: */
void
assertValidMachineCodeFrame(sqInt _instrPtr)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	CogMethod *_cogMethod;

	assert(isMachineCodeFrame(GIV(framePointer)));
	_cogMethod = ((CogMethod *) ((unsignedLongAt(GIV(framePointer) + FoxMethod)) & MFMethodMask) );
	assert((methodFor(_cogMethod)) == _cogMethod);
	assert((_instrPtr > ((sqInt) _cogMethod )) && (_instrPtr < (((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))));
}
/*	Check that the stacked instruction pointers in the given page are correct. 
	Checks the interpreter sender/machine code callee contract. */
/* CoInterpreter>>#assertValidStackedInstructionPointersIn:line: */
static sqInt NoDbgRegParms
assertValidStackedInstructionPointersInline(StackPage *_aStackPage, sqInt _ln)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_callerFP;
	sqInt _methodField;
	usqInt _methodObj;
	int _prevFrameWasCogged;
	char *_theFP;
	usqInt _theIP;
	CogMethod *_theMethod;

	if (!(assertal(!(isFree(_aStackPage)), _ln))) {
		return 0;
	}
	_prevFrameWasCogged = 0;
	if ((GIV(stackPage) == _aStackPage) && (GIV(instructionPointer) != 0)) {
		_theIP = GIV(instructionPointer);
		_theFP = GIV(framePointer);
	} else {
		_theIP = ((usqInt) (unsignedLongAt((_aStackPage->headSP))) );
		_theFP = (_aStackPage->headFP);
		if (GIV(stackPage) == _aStackPage) {
			assertl(GIV(framePointer) == _theFP, _ln);
		}
	}
	while (1) {
		if (isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) ))) {
			/* begin mframeHomeMethod: */
			_methodField = unsignedLongAt(_theFP + FoxMethod);
			_theMethod = ((CogMethod *) (_methodField & MFMethodMask) );
			/* end mframeHomeMethod: */
			assertl((_theIP == (ceCannotResumePC())) || ((_theIP >= ((usqInt) _theMethod )) && (_theIP < (((usqInt) _theMethod ) + ((_theMethod->blockSize))))), _ln);
			_prevFrameWasCogged = 1;
		} else {
			_methodObj = unsignedLongAt(_theFP + FoxMethod);
			if (_prevFrameWasCogged) {
				assertl(_theIP == (ceReturnToInterpreterPC()), _ln);
			}
			if (_theIP == (ceReturnToInterpreterPC())) {
				_theIP = unsignedLongAt(_theFP + FoxIFSavedIP);
			}
			assertl((_theIP >= (_methodObj + (lastPointerOf(_methodObj)))) && (_theIP <= (((_methodObj + (numBytesOfBytes(_methodObj))) + BaseHeaderSize) - 1)), _ln);
			_prevFrameWasCogged = 0;
		}
		_theIP = ((usqInt) (unsignedLongAt(_theFP + FoxCallerSavedIP)) );
		if (!(((_callerFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP)))) != 0)) 
			break;
		_theFP = _callerFP;
	}
	assertl(_theIP == (ceBaseFrameReturnPC()), _ln);
	return 1;
}
/*	Check that the stacked instruction pointers in all pages are correct. 
	Checks the interpreter sender/machine code callee contract. 
	Written so it will be optimized away if not in an assert VM. */
/* CoInterpreter>>#assertValidStackedInstructionPointers: */
static void NoDbgRegParms
assertValidStackedInstructionPointers(sqInt _ln)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	StackPage *_thePage2;

	/* begin usedStackPagesDo: */
	/* begin allStackPagesDo: */
	for (_i = 0; _i < GIV(numStackPages); _i += 1) {
		/* begin stackPageAt: */
		_thePage2 = stackPageAtpages(_i, GIV(pages));
		/* end stackPageAt: */
		{
			if (!(((_thePage2->baseFP)) == 0)) {
				{
					{
						assertl(assertValidStackedInstructionPointersInline(_thePage2, _ln), _ln);
					}
				}
			}
		}
	}
	/* end allStackPagesDo: */
	/* end usedStackPagesDo: */
}
/*	Attempt to convert the current interpreted activation into a machine code 
	activation, and if this is popssible, jump into machine code. bcpc is the 
	0-relative pc of the backward branch bytecode (not any preceding 
	extension).  */
/* CoInterpreter>>#attemptToSwitchToMachineCode: */
static void NoDbgRegParms
attemptToSwitchToMachineCode(sqInt _bcpc)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _closure;
	sqInt _cls;
	CogMethod *_cogMethod;
	CogMethod *_cogMethod2;
	CogMethod *_cogMethod3;
	sqInt _methodField;
	sqInt _methodHeader;
	sqInt _numArgs;
	char *_p;
	usqInt _pc;
	usqInt _pc2;
	sqInt _savedIP;
	char *_sp;
	char *_sp2;
	sqInt _startBcpc;
	char *_theFP;

	if (!((assert(isNonImmediate(GIV(method))), isCogMethodReference(rawHeaderOf(GIV(method)))))) {
		if ((byteAt((GIV(framePointer) + FoxIFrameFlags) + 3)) != 0) {
			/* begin frameStackedReceiver:numArgs: */
			if (isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) ))) {
				_numArgs = ((((CogMethod *) ((unsignedLongAt(GIV(framePointer) + FoxMethod)) & MFMethodMask) ))->cmNumArgs);
			} else {
				/* begin iframeNumArgs: */
				_numArgs = byteAt((GIV(framePointer) + FoxIFrameFlags) + 1);
				/* end iframeNumArgs: */
			}
			_cls = unsignedLongAt(GIV(framePointer) + ((FoxCallerSavedIP + BytesPerWord) + ((sqInt) (((usqInt) _numArgs ) << (shiftForWord())) )));
			/* end frameStackedReceiver:numArgs: */
			cogFullBlockMethodnumCopied(GIV(method), (numPointerSlotsOf(_cls)) - FullClosureFirstCopiedValueIndex);
		} else {
			cogselector(GIV(method), GIV(nilObj));
		}
	}
	if ((assert(isNonImmediate(GIV(method))), isCogMethodReference(rawHeaderOf(GIV(method))))) {
		/* begin cogMethodOf: */
		/* begin fetchPointer:ofObject: */
		_methodHeader = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert((isNonImmediate(_methodHeader)) && (((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))));
		_cogMethod = ((CogMethod *) _methodHeader );
		/* end cogMethodOf: */
		/* begin convertToMachineCodeFrame:bcpc: */
		assert(!(isMachineCodeFrame(GIV(framePointer))));
		if ((unsignedLongAt(GIV(framePointer) + FoxSavedFP)) == 0) {
			unsignedLongAtput(GIV(framePointer) + FoxCallerSavedIP, ceBaseFrameReturnPC());
		} else {
			if (!(isMachineCodeFrame(pointerForOop(unsignedLongAt(GIV(framePointer) + FoxSavedFP))))) {
				/* begin iframeSavedIP:put: */
				_theFP = pointerForOop(unsignedLongAt(GIV(framePointer) + FoxSavedFP));
				_savedIP = ((sqInt) (pointerForOop(unsignedLongAt(GIV(framePointer) + FoxCallerSavedIP))) );
				assert(!(isMachineCodeFrame(_theFP)));
				unsignedLongAtput(_theFP + FoxIFSavedIP, _savedIP);
				/* end iframeSavedIP:put: */
				unsignedLongAtput(GIV(framePointer) + FoxCallerSavedIP, ceReturnToInterpreterPC());
			}
		}
		if ((byteAt((GIV(framePointer) + FoxIFrameFlags) + 3)) != 0) {
			_closure = unsignedLongAt(GIV(framePointer) + (frameStackedReceiverOffset(GIV(framePointer))));
			_startBcpc = (((assert(((((_cogMethod->methodHeader)) & 7) == 1)), (((_cogMethod->methodHeader)) >> 3) & AlternateHeaderNumLiteralsMask)) + LiteralStart) * BytesPerOop;
			_cogMethod3 = ((CogMethod *) _cogMethod );
			_methodField = ((sqInt) _cogMethod3 ) + MFMethodFlagIsBlockFlag;
		} else {
			_startBcpc = (((assert(((((_cogMethod->methodHeader)) & 7) == 1)), (((_cogMethod->methodHeader)) >> 3) & AlternateHeaderNumLiteralsMask)) + LiteralStart) * BytesPerOop;
			_cogMethod3 = ((CogMethod *) _cogMethod );
			_methodField = ((sqInt) _cogMethod );
		}
		_pc2 = mcPCForBackwardBranchstartBcpcin(_bcpc, _startBcpc, _cogMethod3);
		assert(_pc2 > (((usqInt) _cogMethod3 ) + (noCheckEntryOffset())));
		assert(_bcpc == (bytecodePCForstartBcpcin(_pc2, _startBcpc, _cogMethod3)));
		unsignedLongAtput(GIV(framePointer) + FoxMethod, _methodField + ((((byteAt((GIV(framePointer) + FoxIFrameFlags) + 2)) != 0)
			 ? MFMethodFlagHasContextFlag
			 : 0)));
		for (_p = GIV(framePointer) + FoxIFReceiver; _p >= GIV(stackPointer); _p += -BytesPerWord) {
			unsignedLongAtput((_p + FoxMFReceiver) - FoxIFReceiver, unsignedLongAt(_p));
		}
		GIV(stackPointer) = (GIV(stackPointer) + FoxMFReceiver) - FoxIFReceiver;
		_pc = _pc2;
		/* end convertToMachineCodeFrame:bcpc: */
		/* begin assertValidMachineCodeFrame: */
		assert(isMachineCodeFrame(GIV(framePointer)));
		_cogMethod2 = ((CogMethod *) ((unsignedLongAt(GIV(framePointer) + FoxMethod)) & MFMethodMask) );
		assert((methodFor(_cogMethod2)) == _cogMethod2);
		assert((_pc > ((sqInt) _cogMethod2 )) && (_pc < (((sqInt) _cogMethod2 ) + ((_cogMethod2->blockSize)))));
		/* end assertValidMachineCodeFrame: */
		/* begin push: */
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _pc);
		GIV(stackPointer) = _sp;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
		GIV(stackPointer) = _sp2;
		/* end push: */
		ceEnterCogCodePopReceiverReg();
	}
}
/* CoInterpreter>>#callForCogCompiledCodeCompaction */
void
callForCogCompiledCodeCompaction(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	GIV(cogCompiledCodeCompactionCalledFor) = 1;
	forceInterruptCheck();
}
/*	convert 
	rcvr	base 
	arg(s) 
	retpc	<- sp 
	to 
	retpc	base 
	entrypc 
	rcvr 
	arg(s)	<- sp 
	and then enter at either the checked or the unchecked entry-point. */
/* CoInterpreter>>#callRegisterArgCogMethod:at:receiver: */
static void NoDbgRegParms
callRegisterArgCogMethodatreceiver(CogMethod *_cogMethod, sqInt _entryOffset, sqInt _rcvr)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _object;
	sqInt _object2;
	sqInt _oop;
	sqInt _oop2;
	sqInt _oop3;
	sqInt _oop4;
	char *_sp;
	char *_sp2;
	char *_sp3;

	assert(((_cogMethod->cmNumArgs)) <= (numRegArgs()));
	if (((_cogMethod->cmNumArgs)) == 2) {
		/* begin stackValue:put: */
		_oop = unsignedLongAt(GIV(stackPointer));
		unsignedLongAtput(GIV(stackPointer) + (3 * BytesPerWord), _oop);
		/* end stackValue:put: */
		/* begin push: */
		_object = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
		GIV(stackPointer) = _sp;
		/* end push: */
		/* begin stackValue:put: */
		_oop2 = unsignedLongAt(GIV(stackPointer) + (3 * BytesPerWord));
		unsignedLongAtput(GIV(stackPointer) + (1 * BytesPerWord), _oop2);
		/* end stackValue:put: */
		unsignedLongAtput(GIV(stackPointer) + (2 * BytesPerWord), _rcvr);
		unsignedLongAtput(GIV(stackPointer) + (3 * BytesPerWord), ((sqInt) _cogMethod ) + _entryOffset);
		/* begin callEnilopmart: */
		ceCallCogCodePopReceiverArg1Arg0Regs();
		/* end callEnilopmart: */
		{
			assert(0);
		}
	}
	if (((_cogMethod->cmNumArgs)) == 1) {
		/* begin stackValue:put: */
		_oop3 = unsignedLongAt(GIV(stackPointer));
		unsignedLongAtput(GIV(stackPointer) + (2 * BytesPerWord), _oop3);
		/* end stackValue:put: */
		/* begin push: */
		_object2 = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
		unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _object2);
		GIV(stackPointer) = _sp2;
		/* end push: */
		unsignedLongAtput(GIV(stackPointer) + (1 * BytesPerWord), _rcvr);
		unsignedLongAtput(GIV(stackPointer) + (2 * BytesPerWord), ((sqInt) _cogMethod ) + _entryOffset);
		/* begin callEnilopmart: */
		ceCallCogCodePopReceiverArg0Regs();
		/* end callEnilopmart: */
		{
			assert(0);
		}
	}
	assert(((_cogMethod->cmNumArgs)) == 0);
	/* begin stackValue:put: */
	_oop4 = unsignedLongAt(GIV(stackPointer));
	unsignedLongAtput(GIV(stackPointer) + (1 * BytesPerWord), _oop4);
	/* end stackValue:put: */
	unsignedLongAtput(GIV(stackPointer) + (0 * BytesPerWord), ((sqInt) _cogMethod ) + _entryOffset);
	/* begin push: */
	unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), _rcvr);
	GIV(stackPointer) = _sp3;
	/* end push: */
	/* begin callEnilopmart: */
	ceCallCogCodePopReceiverReg();
	/* end callEnilopmart: */
	{
		assert(0);
	}
}
/*	An external call or FFI primitive has failed. Build the frame and 
	activate as appropriate. Enter either the interpreter or machine 
	code depending on whether aPrimitiveMethod has been or is still 
	cogged. Note that we could always interpret but want the efficiency 
	of executing machine code if it is available. */
/* CoInterpreter>>#ceActivateFailingPrimitiveMethod: */
void
ceActivateFailingPrimitiveMethod(sqInt _aPrimitiveMethod)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _methodHeader;
	sqInt _result;
	char *_sp;

	assert(GIV(primFailCode) != 0);
	assert(GIV(newMethod) == _aPrimitiveMethod);
	retryPrimitiveOnFailure();
	if (!GIV(primFailCode)) {
		_result = unsignedLongAt(GIV(stackPointer));
		unsignedLongAtput(GIV(stackPointer), GIV(instructionPointer));
		/* begin push: */
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _result);
		GIV(stackPointer) = _sp;
		/* end push: */
		/* begin callEnilopmart: */
		ceEnterCogCodePopReceiverReg();
		/* end callEnilopmart: */
	}
	/* begin fetchPointer:ofObject: */
	_methodHeader = unsignedLongAt((_aPrimitiveMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if ((assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0)) {
		activateCoggedNewMethod(0);
	}
 else {
		activateNewMethod();
	}
}
/*	Return across a page boundary. The context to return to (which may be 
	married) is stored in the first word of the stack. We get here when a 
	return instruction jumps 
	to the ceBaseFrameReturn: address that is the return pc for base frames. A 
	consequence of this is that the current frame is no longer valid since an 
	interrupt may have overwritten 
	its state as soon as the stack pointer has been cut-back beyond the return 
	pc. So to have 
	a context to send the cannotReturn: message to we also store the base 
	frame's context 
	in the second word of the stack page. */
/* CoInterpreter>>#ceBaseFrameReturn: */
sqInt
ceBaseFrameReturn(sqInt _returnValue)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aMethodObj;
	char *_callerFP;
	sqInt _contextToReturnFrom;
	sqInt _contextToReturnTo;
	char *_fp;
	char *_frameAbove;
	sqInt _isAContext;
	StackPage *_lruOrFree;
	StackPage *_newPage;
	sqInt _senderOop;
	char *_sp;
	char *_sp2;
	char *_sp3;
	char *_sp4;
	char *_theFP;
	StackPage *_thePage;

	assert((stackPageFor(GIV(stackPointer))) == GIV(stackPage));
	assert((mostRecentlyUsedPage()) == GIV(stackPage));
	assertCStackWellAligned();
	assert(GIV(framePointer) == 0);
	assert(GIV(stackPointer) <= (((GIV(stackPage)->baseAddress)) - BytesPerWord));
	assert((((GIV(stackPage)->baseFP)) + (2 * BytesPerWord)) < ((GIV(stackPage)->baseAddress)));
	assert((addressCouldBeObj(longAt(((GIV(stackPage)->baseAddress)) - BytesPerWord))) && (isContext(longAt(((GIV(stackPage)->baseAddress)) - BytesPerWord))));
	_contextToReturnTo = longAt((GIV(stackPage)->baseAddress));
	assert(addressCouldBeObj(_contextToReturnTo));
	freeStackPageNoAssert(GIV(stackPage));
	_isAContext = ((_contextToReturnTo & (tagMask())) == 0) && (((longAt(_contextToReturnTo)) & (classIndexMask())) == ClassMethodContextCompactIndex);
	if (_isAContext && (((((unsignedLongAt((_contextToReturnTo + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_contextToReturnTo))))) {
		/* begin frameOfMarriedContext: */
		/* begin fetchPointer:ofObject: */
		_senderOop = unsignedLongAt((_contextToReturnTo + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		{
			assert(((_senderOop & 7) == 1));
			GIV(framePointer) = pointerForOop(_senderOop - 1);
		}
		/* end frameOfMarriedContext: */
		/* begin stackPageFor: */
		/* begin stackPageAt: */
		_thePage = stackPageAtpages((assert((((char *) GIV(framePointer) ) >= (GIV(stackBasePlus1) - 1)) && (((char *) GIV(framePointer) ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(GIV(framePointer), GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
		/* end stackPageAt: */
		/* end stackPageFor: */
		if (GIV(framePointer) == ((_thePage->headFP))) {
			GIV(stackPointer) = (_thePage->headSP);
		} else {
			/* begin findFrameAbove:inPage: */
			_theFP = GIV(framePointer);
			_fp = (_thePage->headFP);
			if (_fp == _theFP) {
				_frameAbove = 0;
				goto l6;
			}
			while (((_callerFP = pointerForOop(unsignedLongAt(_fp + FoxSavedFP)))) != 0) {
				if (_callerFP == _theFP) {
					_frameAbove = _fp;
					goto l6;
				}
				_fp = _callerFP;
			}
			error("did not find theFP in stack page");
			_frameAbove = 0;
			l6:
			;
			/* end findFrameAbove:inPage: */
			/* begin newStackPage */
			_lruOrFree = (GIV(mostRecentlyUsedPage)->nextPage);
			if (((_lruOrFree->baseFP)) == 0) {
				_newPage = _lruOrFree;
				goto l3;
			}
			divorceFramesIn(_lruOrFree);
			_newPage = _lruOrFree;
			l3:
			;
			/* end newStackPage */
			assert(_newPage == GIV(stackPage));
			moveFramesInthroughtoPage(_thePage, _frameAbove, _newPage);
			markStackPageMostRecentlyUsed(_newPage);
			/* begin setStackPointersFromPage: */
			GIV(stackPointer) = (_thePage->headSP);
			GIV(framePointer) = (_thePage->headFP);
			/* end setStackPointersFromPage: */
		}
	} else {
		if (!(_isAContext && ((((unsignedLongAt((_contextToReturnTo + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ))) & 7) == 1)))) {
			_contextToReturnFrom = longAt(((GIV(stackPage)->baseAddress)) - BytesPerWord);
			tearDownAndRebuildFrameForCannotReturnBaseFrameReturnFromtoreturnValue(_contextToReturnFrom, _contextToReturnTo, _returnValue);
			/* begin externalCannotReturn:from: */
			/* begin push: */
			unsignedLongAtput((_sp4 = GIV(stackPointer) - BytesPerWord), _contextToReturnFrom);
			GIV(stackPointer) = _sp4;
			/* end push: */
			/* begin push: */
			unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _returnValue);
			GIV(stackPointer) = _sp2;
			/* end push: */
			/* begin push: */
			unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
			GIV(stackPointer) = _sp3;
			/* end push: */
			return ceSendAborttonumArgs(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorCannotReturn ) << (shiftForWord())) )), _contextToReturnFrom, 1);
			/* end externalCannotReturn:from: */
		}
		_thePage = makeBaseFrameFor(_contextToReturnTo);
		/* begin setStackPointersFromPage: */
		GIV(stackPointer) = (_thePage->headSP);
		GIV(framePointer) = (_thePage->headFP);
		/* end setStackPointersFromPage: */
	}
	/* begin setStackPageAndLimit: */
	assert(_thePage != 0);
	GIV(stackPage) = _thePage;
	if (GIV(stackLimit) != ((char *) ((usqInt) -1 ) )) {
		GIV(stackLimit) = (GIV(stackPage)->stackLimit);
	}
	markStackPageMostRecentlyUsed(_thePage);
	/* end setStackPageAndLimit: */
	assert((stackPageFor(GIV(framePointer))) == GIV(stackPage));
	if (isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) ))) {
		/* begin push: */
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _returnValue);
		GIV(stackPointer) = _sp;
		/* end push: */
		/* begin callEnilopmart: */
		ceEnterCogCodePopReceiverReg();
		/* end callEnilopmart: */
		{
			assert(0);
		}
	}
	GIV(instructionPointer) = unsignedLongAt(GIV(stackPointer));
	if (((usqIntptr_t) GIV(instructionPointer) ) == (ceReturnToInterpreterPC())) {
		GIV(instructionPointer) = unsignedLongAt(GIV(framePointer) + FoxIFSavedIP);
	}
	/* begin setMethod: */
	_aMethodObj = unsignedLongAt(GIV(framePointer) + FoxMethod);
	assert(((usqInt) _aMethodObj ) >= (startOfObjectMemory(getMemoryMap())));
	{
		GIV(method) = _aMethodObj;
		assert(isOopCompiledMethod(GIV(method)));
	}
	/* end setMethod: */
	unsignedLongAtput(GIV(stackPointer), _returnValue);
	assert(checkIsStillMarriedContextcurrentFP(_contextToReturnTo, GIV(framePointer)));
	siglongjmp(reenterInterpreter, ReturnToInterpreter);
	return (assert(0), null);
}
/*	index is unboxed and 0-based. The call-back expects 1-based value (to 
	perform the operation with instVarAt:put: */
/* CoInterpreter>>#ceCannotAssignTo:withIndex:valueToAssign: */

#if IMMUTABILITY
sqInt
ceCannotAssignTowithIndexvalueToAssign(sqInt _immutableObject, sqInt _index, sqInt _valueToAssign)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_sp;
	char *_sp2;
	char *_sp3;
	char *_sp4;
	sqInt _top;

	/* begin popStack */
	_top = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	GIV(instructionPointer) = _top;
	/* end popStack */
	/* begin push: */
	unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _immutableObject);
	GIV(stackPointer) = _sp;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _valueToAssign);
	GIV(stackPointer) = _sp2;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), ((((usqInt) (_index + 1) ) << 3) | 1));
	GIV(stackPointer) = _sp3;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp4 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
	GIV(stackPointer) = _sp4;
	/* end push: */
	return ceSendAborttonumArgs(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorAttemptToAssign ) << (shiftForWord())) )), _immutableObject, 2);
}
#endif /* IMMUTABILITY */
/*	A context that has been returned from, or otherwise has an invalid pc has 
	been reentered. 
	Until we have a cannotResume: selector, simply resend cannotReturn:. */
/* CoInterpreter>>#ceCannotResume */
sqInt
ceCannotResume(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _object;
	sqInt _object2;
	sqInt _resultOop;
	char *_sp;
	char *_sp2;
	char *_sp3;

	assert(isMachineCodeFrame(GIV(framePointer)));
	assert(frameHasContext(GIV(framePointer)));
	_resultOop = unsignedLongAt(GIV(stackPointer));
	/* begin push: */
	_object = unsignedLongAt(GIV(framePointer) + FoxThisContext);
	unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
	GIV(stackPointer) = _sp;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _resultOop);
	GIV(stackPointer) = _sp2;
	/* end push: */
	/* begin push: */
	_object2 = ceCannotResumePC();
	unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), _object2);
	GIV(stackPointer) = _sp3;
	/* end push: */
	return ceSendAborttonumArgs(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorCannotReturn ) << (shiftForWord())) )), unsignedLongAt(GIV(framePointer) + FoxThisContext), 1);
}
/*	Log failure and then retry if there's an accessorDepth or failure due to 
	no memory. */
/* CoInterpreter>>#ceCheckAndMaybeRetryPrimitive: */
void
ceCheckAndMaybeRetryPrimitive(sqInt primIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _retried;

	if (recordPrimTrace()) {
		/* begin fastLogPrim: */
		GIV(primTraceLog)[GIV(primTraceLogIndex)] = TracePrimitiveFailure;
		primTraceLogIndex(GIV(primTraceLogIndex) + 1);
		/* end fastLogPrim: */
	}
	_retried = retryPrimitiveOnFailure();
	if (_retried && (recordPrimTrace())) {
		/* begin fastLogPrim: */
		GIV(primTraceLog)[GIV(primTraceLogIndex)] = TracePrimitiveRetry;
		primTraceLogIndex(GIV(primTraceLogIndex) + 1);
		/* end fastLogPrim: */
	}
}
/* CoInterpreter>>#ceCheckForInterrupts */
void
ceCheckForInterrupts(void)
{
	sqInt _switched;

	_switched = checkForEventsMayContextSwitch(1);
	returnToExecutivepostContextSwitch(0, _switched);
}
/*	Check if the profile timer has expired and if so take a sample. 
	If the primitive has failed sample the profileMethod as nil. 
	As a courtesy to compileInterpreterPrimitive: map NULL to nilObj. */
/* CoInterpreter>>#ceCheckProfileTick */
void
ceCheckProfileTick(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (!GIV(newMethod)) {
		GIV(newMethod) = GIV(nilObj);
	}
	checkProfileTick(GIV(newMethod));
}
/* CoInterpreter>>#ceContext:instVar: */
sqInt
ceContextinstVar(sqInt _maybeContext, sqInt _slotIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _result;
	char *_sp;
	sqInt _top;

	if (((longAt(_maybeContext)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
		/* begin popStack */
		_top = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		GIV(instructionPointer) = _top;
		/* end popStack */
		_result = instVarofContext(_slotIndex, _maybeContext);
		/* begin push: */
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
		GIV(stackPointer) = _sp;
		/* end push: */
	} else {
		_result = unsignedLongAt((_maybeContext + BaseHeaderSize) + ((sqInt) (((usqInt) _slotIndex ) << (shiftForWord())) ));
	}
	return _result;
}
/*	genStorePop:MaybeContextReceiverVariable: filters out unmarried contexts 
	but not arbitrary objects in subclasses. It answers maybeMarriedContext so 
	that the StackToRegisterMappingCogit can keep ReceiverResultReg live. */
/* CoInterpreter>>#ceContext:instVar:value: */
sqInt
ceContextinstVarvalue(sqInt _maybeMarriedContext, sqInt _slotIndex, sqInt _anOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	int _onCurrentPage;
	sqInt _senderOop;
	char *_sp;
	char * _theFP;
	StackPage * _thePage;
	StackPage *_thePage2;
	sqInt _thePC;
	char *_theSP;
	sqInt _top;

	if ((((longAt(_maybeMarriedContext)) & (classIndexMask())) == ClassMethodContextCompactIndex) && ((((unsignedLongAt((_maybeMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1))) {
		/* begin popStack */
		_top = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		GIV(instructionPointer) = _top;
		/* end popStack */
		/* begin instVar:ofContext:put: */
		assert(!(isObjImmutable(_maybeMarriedContext)));
		/* begin writeBackHeadFramePointers */
		assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
		assert(GIV(stackPage) == (mostRecentlyUsedPage()));
		assert(!(isFree(GIV(stackPage))));
		/* begin setHeadFP:andSP:inPage: */
		_theSP = GIV(stackPointer);
		assert(_theSP < GIV(framePointer));
		assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
		assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
		{
			(GIV(stackPage)->headFP = GIV(framePointer));
			(GIV(stackPage)->headSP = _theSP);
		}
		/* end setHeadFP:andSP:inPage: */
		assert(pageListIsWellFormed());
		/* end writeBackHeadFramePointers */
		if (!(((((unsignedLongAt((_maybeMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_maybeMarriedContext))))) {
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(_maybeMarriedContext)));
			if (((_maybeMarriedContext & (tagMask())) == 0) && ((_maybeMarriedContext & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((_anOop & (tagMask())) == 0) && (((_anOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_anOop >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(_maybeMarriedContext)) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), _maybeMarriedContext);
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(_maybeMarriedContext)) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l9;
			}
			if (_anOop & (tagMask())) {
				goto l9;
			}
			if (!(_maybeMarriedContext >= 0x20000000000LL)) {
				goto l9;
			}
			if (_anOop >= 0x20000000000LL) {
				goto l9;
			}
			if ((_anOop >= GIV(nilObj)) && (_anOop <= GIV(trueObj))) {
				goto l9;
			}
			if (!(_anOop >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l9;
			}
			remember(getFromPermToNewSpaceRememberedSet(), _maybeMarriedContext);
			l9:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((_maybeMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) _slotIndex ) << (shiftForWord())) ), _anOop);
			/* end storePointer:ofObject:withValue: */
			if (_slotIndex == StackPointerIndex) {
				ensureContextIsExecutionSafeAfterAssignToStackPointer(_maybeMarriedContext);
			}
			goto l12;
		}
		/* begin frameOfMarriedContext: */
		/* begin fetchPointer:ofObject: */
		_senderOop = unsignedLongAt((_maybeMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		{
			assert(((_senderOop & 7) == 1));
			_theFP = pointerForOop(_senderOop - 1);
		}
		/* end frameOfMarriedContext: */
		if (_slotIndex == SenderIndex) {
			/* begin stackPageFor: */
			/* begin stackPageAt: */
			_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
			/* end stackPageAt: */
			/* end stackPageFor: */
			assert(GIV(stackPage) == (mostRecentlyUsedPage()));
			_onCurrentPage = _thePage == GIV(stackPage);
			storeSenderOfFramewithValue(_theFP, _anOop);
			if (_onCurrentPage) {
				/* begin setStackPointersFromPage: */
				_thePage2 = GIV(stackPage);
				GIV(stackPointer) = (_thePage2->headSP);
				GIV(framePointer) = (_thePage2->headFP);
				/* end setStackPointersFromPage: */
			} else {
				markStackPageMostRecentlyUsed(GIV(stackPage));
			}
			goto l12;
		}
		divorceFrameandContext(_theFP, _maybeMarriedContext);
		if ((_slotIndex == MethodIndex) && ((((int) ((_thePC = unsignedLongAt((_maybeMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )))) ) < 0) && (((_thePC & 7) == 1)))) {
			ensureContextHasBytecodePC(_maybeMarriedContext);
		}
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_maybeMarriedContext)));
		if (((_maybeMarriedContext & (tagMask())) == 0) && ((_maybeMarriedContext & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_anOop & (tagMask())) == 0) && (((_anOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_anOop >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_maybeMarriedContext)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _maybeMarriedContext);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_maybeMarriedContext)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l6;
		}
		if (_anOop & (tagMask())) {
			goto l6;
		}
		if (!(_maybeMarriedContext >= 0x20000000000LL)) {
			goto l6;
		}
		if (_anOop >= 0x20000000000LL) {
			goto l6;
		}
		if ((_anOop >= GIV(nilObj)) && (_anOop <= GIV(trueObj))) {
			goto l6;
		}
		if (!(_anOop >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l6;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _maybeMarriedContext);
		l6:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_maybeMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) _slotIndex ) << (shiftForWord())) ), _anOop);
		/* end storePointer:ofObject:withValue: */
		if (_slotIndex == StackPointerIndex) {
			ensureContextIsExecutionSafeAfterAssignToStackPointer(_maybeMarriedContext);
		}
		markStackPageMostRecentlyUsed(GIV(stackPage));
		l12:
		;
		/* end instVar:ofContext:put: */
		/* begin push: */
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
		GIV(stackPointer) = _sp;
		/* end push: */
	} else {
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_maybeMarriedContext)));
		if (((_maybeMarriedContext & (tagMask())) == 0) && ((_maybeMarriedContext & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_anOop & (tagMask())) == 0) && (((_anOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_anOop >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_maybeMarriedContext)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _maybeMarriedContext);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_maybeMarriedContext)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l3;
		}
		if (_anOop & (tagMask())) {
			goto l3;
		}
		if (!(_maybeMarriedContext >= 0x20000000000LL)) {
			goto l3;
		}
		if (_anOop >= 0x20000000000LL) {
			goto l3;
		}
		if ((_anOop >= GIV(nilObj)) && (_anOop <= GIV(trueObj))) {
			goto l3;
		}
		if (!(_anOop >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l3;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _maybeMarriedContext);
		l3:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_maybeMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) _slotIndex ) << (shiftForWord())) ), _anOop);
		/* end storePointer:ofObject:withValue: */
	}
	return _maybeMarriedContext;
}
/* CoInterpreter>>#ceInterpretMethodFromPIC:receiver: */
void
ceInterpretMethodFromPICreceiver(sqInt _aMethodObj, sqInt _rcvr)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _firstBytecode;
	sqInt _header;
	sqInt _methodHeader;
	CogMethod *_pic;
	sqInt _primitiveIndex;
	sqInt _top;

	_pic = ((CogMethod *) ((popStack()) - (interpretOffset())) );
	assert((((_pic->cmType)) == CMMegamorphicIC) || (((_pic->cmType)) == CMPolymorphicIC));
	if (((_pic->cmType)) == CMMegamorphicIC) {
		assert(!(methodHasCogMethod(_aMethodObj)));
		cogMethodIfPossibleselector(_aMethodObj, (_pic->selector));
	}
	if ((assert(isNonImmediate(_aMethodObj)), isCogMethodReference(rawHeaderOf(_aMethodObj)))) {
		executeCogMethodfromUnlinkedSendWithReceiver(cogMethodOf(_aMethodObj), _rcvr);
		{
			assert(0);
		}
	}
	GIV(messageSelector) = (_pic->selector);
	GIV(newMethod) = _aMethodObj;
	/* begin primitiveIndexOfMethod:header: */
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_aMethodObj));
	/* begin fetchPointer:ofObject: */
	_header = unsignedLongAt((_aMethodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header & 7) == 1)) {
		_methodHeader = _header;
	} else {
		assert(((usqInt) _header ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_methodHeader = ((((CogMethod *) _header ))->methodHeader);
	}
	/* end methodHeaderOf: */
	if (_methodHeader & AlternateHeaderHasPrimFlag) {
		_firstBytecode = (_aMethodObj + ((LiteralStart + ((_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) * BytesPerOop)) + BaseHeaderSize;
		_primitiveIndex = (byteAt(_firstBytecode + 1)) + ((sqInt) (((usqInt) (byteAt(_firstBytecode + 2)) ) << 8) );
	} else {
		_primitiveIndex = 0;
	}
	/* end primitiveIndexOfMethod:header: */
	/* begin functionPointerFor: */
	primitiveFunctionPointer = ((void (*)(void)) (((_primitiveIndex > MaxPrimitiveIndex)
		 ? 0
		 : primitiveTable[_primitiveIndex])) );
	/* end functionPointerFor: */
	GIV(argumentCount) = (_pic->cmNumArgs);
	/* begin popStack */
	_top = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	GIV(instructionPointer) = _top;
	/* end popStack */
	interpretMethodFromMachineCode();
	{
		assert(0);
	}
}
/* CoInterpreter>>#ceMNUFromPICMNUMethod:receiver: */
void
ceMNUFromPICMNUMethodreceiver(sqInt _aMethodObj, sqInt _rcvr)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	CogMethod *_cPIC;
	sqInt _firstBytecode;
	sqInt _header;
	sqInt _methodHeader;
	sqInt _primitiveIndex;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	sqInt _top;

	assert(addressCouldBeOop(_rcvr));
	assert((_aMethodObj == 0) || ((addressCouldBeObj(_aMethodObj)) && (isOopCompiledMethod(_aMethodObj))));
	_cPIC = ((CogMethod *) ((popStack()) - (mnuOffset())) );
	assert((((_cPIC->cmType)) == CMPolymorphicIC) || (((_cPIC->cmType)) == CMMegamorphicIC));
	GIV(argumentCount) = (_cPIC->cmNumArgs);
	GIV(messageSelector) = (_cPIC->selector);
	if (_aMethodObj != 0) {
		/* begin popStack */
		_top = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		GIV(instructionPointer) = _top;
		/* end popStack */
		createActualMessageTo(((((_tagBits = _rcvr & (tagMask()))) != 0)
			 ? (/* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */)
			 : fetchClassOfNonImm(_rcvr)));
		if (((_aMethodObj & (tagMask())) == 0) && ((((((usqInt) (longAt(_aMethodObj)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && (isCogMethodReference(rawHeaderOf(_aMethodObj))))) {
			/* begin push: */
			unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
			GIV(stackPointer) = _sp;
			/* end push: */
			executeCogMethodfromUnlinkedSendWithReceiver(cogMethodOf(_aMethodObj), _rcvr);
			{
				assert(0);
			}
		}
		GIV(newMethod) = _aMethodObj;
		/* begin primitiveIndexOfMethod:header: */
		/* begin methodHeaderOf: */
		assert(isCompiledMethod(_aMethodObj));
		/* begin fetchPointer:ofObject: */
		_header = unsignedLongAt((_aMethodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_header & 7) == 1)) {
			_methodHeader = _header;
		} else {
			assert(((usqInt) _header ) < ((GIV(memoryMap)->newSpaceStart)));
			assert((((((CogMethod *) _header ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
			_methodHeader = ((((CogMethod *) _header ))->methodHeader);
		}
		/* end methodHeaderOf: */
		if (_methodHeader & AlternateHeaderHasPrimFlag) {
			_firstBytecode = (_aMethodObj + ((LiteralStart + ((_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) * BytesPerOop)) + BaseHeaderSize;
			_primitiveIndex = (byteAt(_firstBytecode + 1)) + ((sqInt) (((usqInt) (byteAt(_firstBytecode + 2)) ) << 8) );
		} else {
			_primitiveIndex = 0;
		}
		/* end primitiveIndexOfMethod:header: */
		/* begin functionPointerFor: */
		primitiveFunctionPointer = ((void (*)(void)) (((_primitiveIndex > MaxPrimitiveIndex)
			 ? 0
			 : primitiveTable[_primitiveIndex])) );
		/* end functionPointerFor: */
		{
			interpretMethodFromMachineCode();
			return;
		}
	}
	handleMNUInMachineCodeToclassForMessage(SelectorDoesNotUnderstand, _rcvr, ((((_tagBits2 = _rcvr & (tagMask()))) != 0)
		 ? (/* begin fetchPointer:ofObject: */ (GIV(lkupClass) = unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits2 ) << (shiftForWord())) ))) /* end fetchPointer:ofObject: */)
		 : (GIV(lkupClass) = fetchClassOfNonImm(_rcvr))));
	{
		assert(0);
	}
}
/*	We know anObject has not a hash yet (or this trampoline would not be 
	called. Sets the hash, then answers it as a smallinteger */
/* CoInterpreter>>#ceNewHashOf: */
sqInt
ceNewHashOf(sqInt _anObject)
{
	assert((isNonImmediate(_anObject)) && ((rawHashBitsOf(_anObject)) == 0));
	return ((((usqInt) (newHashBitsOf(_anObject)) ) << 3) | 1);
}
/* CoInterpreter>>#ceNonLocalReturn: */
sqInt
ceNonLocalReturn(sqInt _returnValue)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _callerContextOrNil;
	sqInt _callerContextOrNil2;
	sqInt _callerContextOrNil3;
	char *_callerFP;
	sqInt _closure;
	sqInt _contextToReturnTo;
	sqInt _currentCtx;
	char *_frameToReturnTo;
	sqInt _home;
	StackPage *_newPage;
	sqInt _nextCntx;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _ourContext;
	sqInt _ourContext2;
	sqInt _senderOop;
	sqInt _senderOop2;
	char *_sp;
	char *_sp2;
	char *_sp22;
	char *_sp23;
	char *_sp24;
	char *_sp3;
	char *_sp32;
	char *_sp33;
	char *_sp34;
	char *_sp4;
	char *_sp42;
	char *_sp5;
	char *_sp6;
	char *_theFP;
	char *_theFP2;
	char *_theFP3;
	char *_theFP4;
	char *_theFP5;
	char *_theFP6;
	char *_theFP7;
	StackPage *_thePage;
	StackPage *_thePage2;
	StackPage *_thePage3;
	StackPage *_thePage4;
	char *_theSP;
	char *_theSP2;
	char *_theSP3;
	char *_theSP4;
	char *_theSP5;
	sqInt _top;
	sqInt _unwindContextOrNilOrZero;
	sqInt _valuePointer;
	sqInt _valuePointer2;

	_frameToReturnTo = ((char *) 0 );
	assert(isMachineCodeFrame(GIV(framePointer)));
	assert(frameIsBlockActivation(GIV(framePointer)));
	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	_theSP4 = GIV(stackPointer);
	assert(_theSP4 < GIV(framePointer));
	assert((_theSP4 < ((GIV(stackPage)->baseAddress))) && (_theSP4 > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(GIV(stackPage)->headFP = GIV(framePointer));
		(GIV(stackPage)->headSP = _theSP4);
	}
	/* end setHeadFP:andSP:inPage: */
	assert(pageListIsWellFormed());
	/* end writeBackHeadFramePointers */
	_closure = unsignedLongAt(GIV(framePointer) + (frameStackedReceiverOffset(GIV(framePointer))));
	_home = null;
	while (_closure != GIV(nilObj)) {
		/* begin followField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop = unsignedLongAt((_closure + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureOuterContextIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_objOop = fixFollowedFieldofObjectwithInitialValue(FullClosureOuterContextIndex, _closure, _objOop);
		}
		_home = _objOop;
		/* end followField:ofObject: */
		if (!(((_home & (tagMask())) == 0) && (((longAt(_home)) & (classIndexMask())) == ClassMethodContextCompactIndex))) {
			/* begin ensureFrameIsMarried:SP: */
			_theFP2 = GIV(framePointer);
			_theSP = GIV(stackPointer);
			if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP2 + FoxMethod)) )))
				 ? ((unsignedLongAt(_theFP2 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
				 : (byteAt((_theFP2 + FoxIFrameFlags) + 2)) != 0)) {
				assert(isContext(frameContext(_theFP2)));
				_ourContext = unsignedLongAt(_theFP2 + FoxThisContext);
				goto l9;
			}
			_ourContext = marryFrameSP(_theFP2, _theSP);
			l9:
			;
			/* end ensureFrameIsMarried:SP: */
			/* begin externalCannotReturn:from: */
			/* begin push: */
			unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _ourContext);
			GIV(stackPointer) = _sp;
			/* end push: */
			/* begin push: */
			unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _returnValue);
			GIV(stackPointer) = _sp2;
			/* end push: */
			/* begin push: */
			unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
			GIV(stackPointer) = _sp3;
			/* end push: */
			return ceSendAborttonumArgs(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorCannotReturn ) << (shiftForWord())) )), _ourContext, 1);
			/* end externalCannotReturn:from: */
		}
		/* begin followField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop2 = unsignedLongAt((_home + BaseHeaderSize) + ((sqInt) (((usqInt) ClosureIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_objOop2 & (tagMask())) == 0) && (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_objOop2 = fixFollowedFieldofObjectwithInitialValue(ClosureIndex, _home, _objOop2);
		}
		_closure = _objOop2;
		/* end followField:ofObject: */
	}
	_unwindContextOrNilOrZero = findUnwindThroughContext(_home);
	if (_unwindContextOrNilOrZero == GIV(nilObj)) {
		/* begin ensureFrameIsMarried:SP: */
		_theFP3 = GIV(framePointer);
		_theSP2 = GIV(stackPointer);
		if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP3 + FoxMethod)) )))
			 ? ((unsignedLongAt(_theFP3 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
			 : (byteAt((_theFP3 + FoxIFrameFlags) + 2)) != 0)) {
			assert(isContext(frameContext(_theFP3)));
			_ourContext = unsignedLongAt(_theFP3 + FoxThisContext);
			goto l14;
		}
		_ourContext = marryFrameSP(_theFP3, _theSP2);
		l14:
		;
		/* end ensureFrameIsMarried:SP: */
		/* begin externalCannotReturn:from: */
		/* begin push: */
		unsignedLongAtput((_sp4 = GIV(stackPointer) - BytesPerWord), _ourContext);
		GIV(stackPointer) = _sp4;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp22 = GIV(stackPointer) - BytesPerWord), _returnValue);
		GIV(stackPointer) = _sp22;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp32 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
		GIV(stackPointer) = _sp32;
		/* end push: */
		return ceSendAborttonumArgs(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorCannotReturn ) << (shiftForWord())) )), _ourContext, 1);
		/* end externalCannotReturn:from: */
	}
	if (_unwindContextOrNilOrZero != 0) {
		/* begin externalAboutToReturn:through: */
		/* begin ensureFrameIsMarried:SP: */
		_theFP5 = GIV(framePointer);
		_theSP5 = GIV(stackPointer);
		if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP5 + FoxMethod)) )))
			 ? ((unsignedLongAt(_theFP5 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
			 : (byteAt((_theFP5 + FoxIFrameFlags) + 2)) != 0)) {
			assert(isContext(frameContext(_theFP5)));
			_ourContext2 = unsignedLongAt(_theFP5 + FoxThisContext);
			goto l18;
		}
		_ourContext2 = marryFrameSP(_theFP5, _theSP5);
		l18:
		;
		/* end ensureFrameIsMarried:SP: */
		/* begin push: */
		unsignedLongAtput((_sp6 = GIV(stackPointer) - BytesPerWord), _ourContext2);
		GIV(stackPointer) = _sp6;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp24 = GIV(stackPointer) - BytesPerWord), _returnValue);
		GIV(stackPointer) = _sp24;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp34 = GIV(stackPointer) - BytesPerWord), _unwindContextOrNilOrZero);
		GIV(stackPointer) = _sp34;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp42 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
		GIV(stackPointer) = _sp42;
		/* end push: */
		return ceSendAborttonumArgs(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorAboutToReturn ) << (shiftForWord())) )), _ourContext2, 2);
		/* end externalAboutToReturn:through: */
	}
	_contextToReturnTo = null;
	if ((((unsignedLongAt((_home + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
		assert(checkIsStillMarriedContextcurrentFP(_home, GIV(framePointer)));
		/* begin frameOfMarriedContext: */
		/* begin fetchPointer:ofObject: */
		_senderOop = unsignedLongAt((_home + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		{
			assert(((_senderOop & 7) == 1));
			_theFP = pointerForOop(_senderOop - 1);
		}
		/* end frameOfMarriedContext: */
		if ((unsignedLongAt(_theFP + FoxSavedFP)) == 0) {
			/* begin frameCallerContext: */
			assert(isBaseFrame(_theFP));
			/* begin stackPageFor: */
			/* begin stackPageAt: */
			_thePage2 = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
			/* end stackPageAt: */
			/* end stackPageFor: */
			_callerContextOrNil = unsignedLongAt((_thePage2->baseAddress));
			assert(addressCouldBeObj(_callerContextOrNil));
			assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
			_contextToReturnTo = _callerContextOrNil;
			/* end frameCallerContext: */
		} else {
			_frameToReturnTo = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP));
		}
	} else {
		_contextToReturnTo = unsignedLongAt((_home + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		if ((((_contextToReturnTo & (tagMask())) == 0) && (((longAt(_contextToReturnTo)) & (classIndexMask())) == ClassMethodContextCompactIndex)) && ((((unsignedLongAt((_contextToReturnTo + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1))) {
			assert(checkIsStillMarriedContextcurrentFP(_contextToReturnTo, GIV(framePointer)));
			/* begin frameOfMarriedContext: */
			/* begin fetchPointer:ofObject: */
			_senderOop2 = unsignedLongAt((_contextToReturnTo + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			{
				assert(((_senderOop2 & 7) == 1));
				_frameToReturnTo = pointerForOop(_senderOop2 - 1);
			}
			/* end frameOfMarriedContext: */
			_contextToReturnTo = null;
		}
	}
	if (_contextToReturnTo != null) {
		_frameToReturnTo = establishFrameForContextToReturnTo(_contextToReturnTo);
		if (_frameToReturnTo == 0) {
			/* begin ensureFrameIsMarried:SP: */
			_theFP4 = GIV(framePointer);
			_theSP3 = GIV(stackPointer);
			if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP4 + FoxMethod)) )))
				 ? ((unsignedLongAt(_theFP4 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
				 : (byteAt((_theFP4 + FoxIFrameFlags) + 2)) != 0)) {
				assert(isContext(frameContext(_theFP4)));
				_ourContext = unsignedLongAt(_theFP4 + FoxThisContext);
				goto l15;
			}
			_ourContext = marryFrameSP(_theFP4, _theSP3);
			l15:
			;
			/* end ensureFrameIsMarried:SP: */
			/* begin externalCannotReturn:from: */
			/* begin push: */
			unsignedLongAtput((_sp5 = GIV(stackPointer) - BytesPerWord), _ourContext);
			GIV(stackPointer) = _sp5;
			/* end push: */
			/* begin push: */
			unsignedLongAtput((_sp23 = GIV(stackPointer) - BytesPerWord), _returnValue);
			GIV(stackPointer) = _sp23;
			/* end push: */
			/* begin push: */
			unsignedLongAtput((_sp33 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
			GIV(stackPointer) = _sp33;
			/* end push: */
			return ceSendAborttonumArgs(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorCannotReturn ) << (shiftForWord())) )), _ourContext, 1);
			/* end externalCannotReturn:from: */
		}
	}
	assert(pageListIsWellFormed());
	/* begin stackPageFor: */
	/* begin stackPageAt: */
	_newPage = stackPageAtpages((assert((((char *) _frameToReturnTo ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _frameToReturnTo ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_frameToReturnTo, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
	/* end stackPageAt: */
	/* end stackPageFor: */
	if (_newPage != GIV(stackPage)) {
		/* begin frameCallerContext: */
		_theFP7 = (GIV(stackPage)->baseFP);
		assert(isBaseFrame(_theFP7));
		/* begin stackPageFor: */
		/* begin stackPageAt: */
		_thePage4 = stackPageAtpages((assert((((char *) _theFP7 ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP7 ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP7, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
		/* end stackPageAt: */
		/* end stackPageFor: */
		_callerContextOrNil3 = unsignedLongAt((_thePage4->baseAddress));
		assert(addressCouldBeObj(_callerContextOrNil3));
		assert((_callerContextOrNil3 == (nilObject())) || (isContext(_callerContextOrNil3)));
		_currentCtx = _callerContextOrNil3;
		/* end frameCallerContext: */
		assert(isContext(_currentCtx));
		freeStackPage(GIV(stackPage));
		while (1) {
			assert(isContext(_currentCtx));
			if (((((unsignedLongAt((_currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && ((stackPageFor((_theFP = frameOfMarriedContext(_currentCtx)))) == _newPage)) 
				break;
			if ((((unsignedLongAt((_currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
				/* begin stackPageFor: */
				/* begin stackPageAt: */
				_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
				/* end stackPageAt: */
				/* end stackPageFor: */
				/* begin frameCallerContext: */
				_theFP6 = (_thePage->baseFP);
				assert(isBaseFrame(_theFP6));
				/* begin stackPageFor: */
				/* begin stackPageAt: */
				_thePage3 = stackPageAtpages((assert((((char *) _theFP6 ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP6 ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP6, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
				/* end stackPageAt: */
				/* end stackPageFor: */
				_callerContextOrNil2 = unsignedLongAt((_thePage3->baseAddress));
				assert(addressCouldBeObj(_callerContextOrNil2));
				assert((_callerContextOrNil2 == (nilObject())) || (isContext(_callerContextOrNil2)));
				_currentCtx = _callerContextOrNil2;
				/* end frameCallerContext: */
				freeStackPage(_thePage);
			} else {
				_nextCntx = unsignedLongAt((_currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
				/* begin markContextAsDead: */
				assert(isContext(_currentCtx));
				{
					/* begin storePointerUnchecked:ofObject:withValue: */
					_valuePointer = GIV(nilObj);
					assert(!(isOopForwarded(_currentCtx)));
					longAtput((_currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), _valuePointer);
					/* end storePointerUnchecked:ofObject:withValue: */
					/* begin storePointerUnchecked:ofObject:withValue: */
					_valuePointer2 = GIV(nilObj);
					assert(!(isOopForwarded(_currentCtx)));
					longAtput((_currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), _valuePointer2);
					/* end storePointerUnchecked:ofObject:withValue: */
				}
				/* end markContextAsDead: */
				_currentCtx = _nextCntx;
			}
		}
		/* begin setStackPageAndLimit: */
		assert(_newPage != 0);
		GIV(stackPage) = _newPage;
		if (GIV(stackLimit) != ((char *) ((usqInt) -1 ) )) {
			GIV(stackLimit) = (GIV(stackPage)->stackLimit);
		}
		markStackPageMostRecentlyUsed(_newPage);
		/* end setStackPageAndLimit: */
		/* begin setStackPointersFromPage: */
		GIV(stackPointer) = (_newPage->headSP);
		GIV(framePointer) = (_newPage->headFP);
		/* end setStackPointersFromPage: */
	}
	if (GIV(framePointer) == _frameToReturnTo) {
		/* begin popStack */
		_top = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		GIV(instructionPointer) = _top;
		/* end popStack */
	} else {
		do {
			_callerFP = GIV(framePointer);
			GIV(framePointer) = pointerForOop(unsignedLongAt(GIV(framePointer) + FoxSavedFP));
		} while (GIV(framePointer) != _frameToReturnTo);
		GIV(instructionPointer) = ((usqInt) (pointerForOop(unsignedLongAt(_callerFP + FoxCallerSavedIP))) );
		{
			assert(!(isBaseFrame(_callerFP)));
			GIV(stackPointer) = (_callerFP + (frameStackedReceiverOffset(_callerFP))) + BytesPerWord;
		}
	}
	return returntoExecutive(_returnValue, 0);
}
/* CoInterpreter>>#ceReapAndResetErrorCodeFor: */
void
ceReapAndResetErrorCodeFor(CogMethod *_cogMethod)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	assert(GIV(primFailCode) != 0);
	GIV(newMethod) = (_cogMethod->methodObject);
	reapAndResetErrorCodeToheader(GIV(framePointer), (_cogMethod->methodHeader));
}
/*	Perform a return from a machine code frame to an interpreted frame. 
	The machine code has executed a return instruction when the return address 
	is set to ceReturnToInterpreterPC. Return the result and switch to the 
	interpreter.  */
/* CoInterpreter>>#ceReturnToInterpreter: */
void
ceReturnToInterpreter(sqInt _anOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aMethodObj;
	char *_sp;
	StackPage *_thePage;

	assert(addressCouldBeOop(_anOop));
	flag("are you really sure setStackPageAndLimit: is needed?");
	/* begin setStackPageAndLimit: */
	_thePage = GIV(stackPage);
	assert(_thePage != 0);
	GIV(stackPage) = _thePage;
	if (GIV(stackLimit) != ((char *) ((usqInt) -1 ) )) {
		GIV(stackLimit) = (GIV(stackPage)->stackLimit);
	}
	markStackPageMostRecentlyUsed(_thePage);
	/* end setStackPageAndLimit: */
	assert(!(isMachineCodeFrame(GIV(framePointer))));
	/* begin setMethod: */
	_aMethodObj = unsignedLongAt(GIV(framePointer) + FoxMethod);
	assert(((usqInt) _aMethodObj ) >= (startOfObjectMemory(getMemoryMap())));
	{
		GIV(method) = _aMethodObj;
		assert(isOopCompiledMethod(GIV(method)));
	}
	/* end setMethod: */
	assertValidExecutionPointersimbarline(unsignedLongAt(GIV(framePointer) + FoxIFSavedIP), GIV(framePointer), GIV(stackPointer), 1, __LINE__);
	GIV(instructionPointer) = unsignedLongAt(GIV(framePointer) + FoxIFSavedIP);
	/* begin push: */
	unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _anOop);
	GIV(stackPointer) = _sp;
	/* end push: */
	siglongjmp(reenterInterpreter, ReturnToInterpreter);
	{
		assert(0);
	}
}
/*	Entry-point for an abort send in a CogMethod (aboutToReturn:through:, 
	cannotReturn: et al). 
	Try and dispatch the send, but the send may turn into an MNU in which case 
	defer to 
	handleMNUInMachineCodeTo:... which will dispatch the MNU. 
	 
	Continue execution via either executeMethod or 
	interpretMethodFromMachineCode: depending on whether the target method is 
	cogged or not. */
/* CoInterpreter>>#ceSendAbort:to:numArgs: */
sqInt
ceSendAborttonumArgs(sqInt _selector, sqInt _rcvr, sqInt _numArgs)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classObj;
	sqInt _classTablePage;
	sqInt _classTag;
	CogMethod *_cogMethod;
	sqInt _errSelIdx;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;
	sqInt _inInterpreter;
	sqInt _methodHeader;
	sqInt _methodHeader2;
	sqInt _nArgs;
	char *_savedFramePointer;
	char *_savedStackPointer;
	sqInt _succeeded;
	sqInt _tagBits;
	sqInt _top;

	_nArgs = 0;
	_savedFramePointer = ((char *) 0 );
	_savedStackPointer = ((char *) 0 );
	assertCStackWellAligned();
	assert(addressCouldBeOop(_rcvr));
	/* begin sendBreakpoint:receiver: */
	sendBreakpointreceiver(firstFixedFieldOfMaybeImmediate(_selector), lengthOfMaybeImmediate(_selector), _rcvr);
	/* end sendBreakpoint:receiver: */
	GIV(argumentCount) = _numArgs;
	if (((_tagBits = _rcvr & (tagMask()))) != 0) {
		_classTag = _tagBits;
	} else {
		/* begin classIndexOf: */
		_classTag = (longAt(_rcvr)) & (classIndexMask());
		/* end classIndexOf: */
	}
	if (lookupInMethodCacheSelclassTag(_selector, _classTag)) {
		/* begin ifAppropriateCompileToNativeCode:selector: */
		/* begin fetchPointer:ofObject: */
		_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if ((assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0)) {
			_cogMethod = ((CogMethod *) _methodHeader );
			if (((_cogMethod->selector)) == GIV(nilObj)) {
				setSelectorOfto(_cogMethod, _selector);
			}
		} else {
			if (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
				cogselector(GIV(newMethod), _selector);
			}
 else {
				maybeFlagMethodAsInterpreted(GIV(newMethod));
			}
		}
		/* end ifAppropriateCompileToNativeCode:selector: */
	} else {
		GIV(messageSelector) = _selector;
		/* begin classAtIndex: */
		assert((_classTag >= 0) && ((_classTag <= (tagMask())) || ((_classTag >= (arrayClassIndexPun())) && (_classTag <= (classIndexMask())))));
		/* begin fetchPointer:ofObject: */
		_fieldIndex2 = ((usqInt) _classTag ) >> (classTableMajorIndexShift());
		_classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (_classTablePage == GIV(nilObj)) {
			_classObj = null;
		} else {
			/* begin fetchPointer:ofObject: */
			_fieldIndex = _classTag & ((1U << (classTableMajorIndexShift())) - 1);
			_classObj = unsignedLongAt((_classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
		}
		/* end classAtIndex: */
		if (((_errSelIdx = lookupMethodWithoutMNUProcessingInClass(_classObj))) != 0) {
			handleMNUInMachineCodeToclassForMessage(_errSelIdx, _rcvr, _classObj);
			{
				assert(0);
			}
		}
	}
	/* begin popStack */
	_top = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	GIV(instructionPointer) = _top;
	/* end popStack */
	if (((GIV(newMethod) & (tagMask())) == 0) && ((((((usqInt) (longAt(GIV(newMethod))) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && (isCogMethodReference(rawHeaderOf(GIV(newMethod)))))) {
		/* begin executeNewMethod */
		/* begin executeNewMethod: */
		_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
		/* begin executePrimitiveFromInterpreter:ifFail: */
		if (primitiveFunctionPointer != 0) {
			if (((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex) {
				executeQuickPrimitive();
				/* begin returnToExecutive: */
				returntoExecutive(popStack(), _inInterpreter);
				/* end returnToExecutive: */
				goto l11;
			}
			/* begin slowPrimitiveResponse */
			if (recordPrimTrace()) {
				/* begin fastLogPrim: */
				GIV(primTraceLog)[GIV(primTraceLogIndex)] = GIV(messageSelector);
				primTraceLogIndex(GIV(primTraceLogIndex) + 1);
				/* end fastLogPrim: */
			}
			assert((remapBufferCount()) == 0);
			{
				_nArgs = GIV(argumentCount);
				_savedStackPointer = GIV(stackPointer);
				_savedFramePointer = GIV(framePointer);
			}
			/* begin initPrimCall */
			GIV(primFailCode) = 0;
			/* end initPrimCall */
			/* begin dispatchFunctionPointer: */
			primitiveFunctionPointer();
			/* end dispatchFunctionPointer: */
			assert(maybeLeakCheckExternalPrimCall(GIV(newMethod)));
			/* begin maybeRetryPrimitiveOnFailure */
			if (GIV(primFailCode)) {
				retryPrimitiveOnFailure();
			}
			/* end maybeRetryPrimitiveOnFailure */
			/* begin maybeFailForLastObjectOverwrite */
			if (checkAllocFiller) {
				if (((freeStart0()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart0())) != (freeStart0()))) {
					/* begin primitiveFailFor: */
					GIV(primFailCode) = PrimErrWritePastObject;
					/* end primitiveFailFor: */
				}
			}
			/* end maybeFailForLastObjectOverwrite */
			if (!GIV(primFailCode) && ((GIV(framePointer) == _savedFramePointer) && (!(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))))) {
				if (GIV(stackPointer) != (_savedStackPointer + (_nArgs * BytesPerWord))) {
					flag("Would be nice to make this a message send of e.g. unbalancedPrimitive to the current process or context");
					failUnbalancedPrimitive();
					GIV(stackPointer) = _savedStackPointer;
				}
			}
			if (GIV(nextProfileTick) > 0) {
				checkProfileTick(GIV(newMethod));
			}
			_succeeded = !GIV(primFailCode);
			goto l7;
			l7:
			;
			/* end slowPrimitiveResponse */
			if (_succeeded) {
				/* begin returnToExecutive: */
				returntoExecutive(popStack(), _inInterpreter);
				/* end returnToExecutive: */
				goto l11;
			}
		}
		{
			{
				/* begin fetchPointer:ofObject: */
				_methodHeader2 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (!((assert((((_methodHeader2 & 7) == 1)) || ((((usqInt) _methodHeader2 ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader2 ) >= (minCogMethodAddress())))), (_methodHeader2 & (smallIntegerTag())) == 0))) {
					if (((assert(((_methodHeader2 & 7) == 1)), (_methodHeader2 >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
						cogselector(GIV(newMethod), GIV(nilObj));
						/* begin fetchPointer:ofObject: */
						_methodHeader2 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
					} else {
						maybeFlagMethodAsInterpreted(GIV(newMethod));
					}
				}
			}
			activateNewMethod();
		}
		l11:
		;
		/* end executePrimitiveFromInterpreter:ifFail: */
		/* end executeNewMethod: */
		/* end executeNewMethod */
		{
			assert(0);
		}
	}
	interpretMethodFromMachineCode();
	return (assert(0), null);
}
/*	Send from an Megamorphic IC when the first-level method lookup probe has 
	failed, or to continue when PIC creation has failed (e.g. because we're 
	out of code space), 
	or when a send has failed due to a forwarded receiver. */
/* CoInterpreter>>#ceSendFromInLineCacheMiss: */
sqInt
ceSendFromInLineCacheMiss(sqInt _cogMethodOrPICAddr)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classObj;
	sqInt _classTablePage;
	sqInt _classTag;
	CogMethod *_cogMethod;
	CogMethod * _cogMethodOrPIC;
	sqInt _errSelIdx;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;
	sqInt _inInterpreter;
	sqInt _methodHeader;
	sqInt _methodHeader2;
	sqInt _nArgs;
	usqInt _numArgs;
	sqInt _rcvr;
	char *_savedFramePointer;
	char *_savedStackPointer;
	sqInt _selector;
	sqInt _succeeded;
	sqInt _tagBits;
	sqInt _top;

	_nArgs = 0;
	_savedFramePointer = ((char *) 0 );
	_savedStackPointer = ((char *) 0 );
	_cogMethodOrPIC = ((CogMethod *) _cogMethodOrPICAddr );
	_numArgs = (_cogMethodOrPIC->cmNumArgs);
	_rcvr = unsignedLongAt(GIV(stackPointer) + ((_numArgs + 1) * BytesPerWord));
	assert(addressCouldBeOop(_rcvr));
	if (((_tagBits = _rcvr & (tagMask()))) != 0) {
		_classTag = _tagBits;
	} else {
		/* begin classIndexOf: */
		_classTag = (longAt(_rcvr)) & (classIndexMask());
		/* end classIndexOf: */
	}
	GIV(argumentCount) = _numArgs;
	if (((((_cogMethodOrPIC->selector)) & (tagMask())) == 0) && (((long64At((_cogMethodOrPIC->selector))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		setSelectorOfto(_cogMethodOrPIC, handleForwardedSelectorFaultFor((_cogMethodOrPIC->selector)));
		return ceSendFromInLineCacheMiss(_cogMethodOrPIC);
	}
	if (_classTag == (isForwardedObjectClassIndexPun())) {
		handleForwardedSendFaultForReceiverrcvrStackOffsetFromTop(_rcvr, _numArgs + 1);
		return ceSendFromInLineCacheMiss(_cogMethodOrPIC);
	}
	if (lookupInMethodCacheSelclassTag((_cogMethodOrPIC->selector), _classTag)) {
		/* begin ifAppropriateCompileToNativeCode:selector: */
		_selector = (_cogMethodOrPIC->selector);
		/* begin fetchPointer:ofObject: */
		_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if ((assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0)) {
			_cogMethod = ((CogMethod *) _methodHeader );
			if (((_cogMethod->selector)) == GIV(nilObj)) {
				setSelectorOfto(_cogMethod, _selector);
			}
		} else {
			if (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
				cogselector(GIV(newMethod), _selector);
			}
 else {
				maybeFlagMethodAsInterpreted(GIV(newMethod));
			}
		}
		/* end ifAppropriateCompileToNativeCode:selector: */
	} else {
		GIV(messageSelector) = (_cogMethodOrPIC->selector);
		/* begin classAtIndex: */
		assert((_classTag >= 0) && ((_classTag <= (tagMask())) || ((_classTag >= (arrayClassIndexPun())) && (_classTag <= (classIndexMask())))));
		/* begin fetchPointer:ofObject: */
		_fieldIndex2 = ((usqInt) _classTag ) >> (classTableMajorIndexShift());
		_classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (_classTablePage == GIV(nilObj)) {
			_classObj = null;
		} else {
			/* begin fetchPointer:ofObject: */
			_fieldIndex = _classTag & ((1U << (classTableMajorIndexShift())) - 1);
			_classObj = unsignedLongAt((_classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
		}
		/* end classAtIndex: */
		if (((_errSelIdx = lookupMethodWithoutMNUProcessingInClass(_classObj))) != 0) {
			handleMNUInMachineCodeToclassForMessage(_errSelIdx, _rcvr, _classObj);
			{
				assert(0);
			}
		}
	}
	/* begin popStack */
	_top = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	GIV(instructionPointer) = _top;
	/* end popStack */
	if (((GIV(newMethod) & (tagMask())) == 0) && ((((((usqInt) (longAt(GIV(newMethod))) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && (isCogMethodReference(rawHeaderOf(GIV(newMethod)))))) {
		/* begin executeNewMethod */
		/* begin executeNewMethod: */
		_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
		/* begin executePrimitiveFromInterpreter:ifFail: */
		if (primitiveFunctionPointer != 0) {
			if (((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex) {
				executeQuickPrimitive();
				/* begin returnToExecutive: */
				returntoExecutive(popStack(), _inInterpreter);
				/* end returnToExecutive: */
				goto l11;
			}
			/* begin slowPrimitiveResponse */
			if (recordPrimTrace()) {
				/* begin fastLogPrim: */
				GIV(primTraceLog)[GIV(primTraceLogIndex)] = GIV(messageSelector);
				primTraceLogIndex(GIV(primTraceLogIndex) + 1);
				/* end fastLogPrim: */
			}
			assert((remapBufferCount()) == 0);
			{
				_nArgs = GIV(argumentCount);
				_savedStackPointer = GIV(stackPointer);
				_savedFramePointer = GIV(framePointer);
			}
			/* begin initPrimCall */
			GIV(primFailCode) = 0;
			/* end initPrimCall */
			/* begin dispatchFunctionPointer: */
			primitiveFunctionPointer();
			/* end dispatchFunctionPointer: */
			assert(maybeLeakCheckExternalPrimCall(GIV(newMethod)));
			/* begin maybeRetryPrimitiveOnFailure */
			if (GIV(primFailCode)) {
				retryPrimitiveOnFailure();
			}
			/* end maybeRetryPrimitiveOnFailure */
			/* begin maybeFailForLastObjectOverwrite */
			if (checkAllocFiller) {
				if (((freeStart0()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart0())) != (freeStart0()))) {
					/* begin primitiveFailFor: */
					GIV(primFailCode) = PrimErrWritePastObject;
					/* end primitiveFailFor: */
				}
			}
			/* end maybeFailForLastObjectOverwrite */
			if (!GIV(primFailCode) && ((GIV(framePointer) == _savedFramePointer) && (!(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))))) {
				if (GIV(stackPointer) != (_savedStackPointer + (_nArgs * BytesPerWord))) {
					flag("Would be nice to make this a message send of e.g. unbalancedPrimitive to the current process or context");
					failUnbalancedPrimitive();
					GIV(stackPointer) = _savedStackPointer;
				}
			}
			if (GIV(nextProfileTick) > 0) {
				checkProfileTick(GIV(newMethod));
			}
			_succeeded = !GIV(primFailCode);
			goto l7;
			l7:
			;
			/* end slowPrimitiveResponse */
			if (_succeeded) {
				/* begin returnToExecutive: */
				returntoExecutive(popStack(), _inInterpreter);
				/* end returnToExecutive: */
				goto l11;
			}
		}
		{
			{
				/* begin fetchPointer:ofObject: */
				_methodHeader2 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (!((assert((((_methodHeader2 & 7) == 1)) || ((((usqInt) _methodHeader2 ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader2 ) >= (minCogMethodAddress())))), (_methodHeader2 & (smallIntegerTag())) == 0))) {
					if (((assert(((_methodHeader2 & 7) == 1)), (_methodHeader2 >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
						cogselector(GIV(newMethod), GIV(nilObj));
						/* begin fetchPointer:ofObject: */
						_methodHeader2 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
					} else {
						maybeFlagMethodAsInterpreted(GIV(newMethod));
					}
				}
			}
			activateNewMethod();
		}
		l11:
		;
		/* end executePrimitiveFromInterpreter:ifFail: */
		/* end executeNewMethod: */
		/* end executeNewMethod */
		{
			assert(0);
		}
	}
	interpretMethodFromMachineCode();
	{
		assert(0);
	}
	return 0;
}
/*	For RegisterAllocatingCogit we want the pc following a conditional branch 
	not to be reachable, so 
	we don't have to generate code to reload registers. But notionally the pc 
	following a conditional 
	branch is reached when continuing from a mustBeBoolean error. Instead of 
	supporting this in the 
	JIT, simply convert to an interpreter frame, backup the pc to the branch, 
	reenter the interpreter 
	and hence retry the mustBeBoolean send therein. N.B. We could do this for 
	immutability violations 
	too, but immutability is used in actual applications and so should be 
	performant, whereas 
	mustBeBoolean errors are extremely rare and so we choose brevity over 
	performance in this case. */
/* CoInterpreter>>#ceSendMustBeBooleanTo:interpretingAtDelta: */
void
ceSendMustBeBooleanTointerpretingAtDelta(sqInt _aNonBooleanObject, sqInt _jumpSize)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	CogMethod *_cogMethod;
	sqInt _methodHeader;
	sqInt _methodObj;
	sqInt _oop;
	char *_p;
	char *_sp;
	sqInt _startBcpc;
	sqInt _top;

	assert(addressCouldBeOop(_aNonBooleanObject));
	_cogMethod = ((CogMethod *) ((unsignedLongAt(GIV(framePointer) + FoxMethod)) & MFMethodMask) );
	_methodHeader = ((((CogMethod *) _cogMethod ))->methodHeader);
	_methodObj = ((((CogMethod *) _cogMethod ))->methodObject);
	_startBcpc = ((literalCountOfMethodHeader(methodHeaderOf(_methodObj))) + LiteralStart) * BytesPerOop;
	/* begin popStack */
	_top = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	GIV(instructionPointer) = _top;
	/* end popStack */
	GIV(instructionPointer) = bytecodePCForstartBcpcin(GIV(instructionPointer), _startBcpc, _cogMethod);
	GIV(instructionPointer) = (((_methodObj + BaseHeaderSize) + GIV(instructionPointer)) - _jumpSize) - 1;
	for (_p = GIV(stackPointer); _p <= (GIV(framePointer) + FoxMFReceiver); _p += BytesPerWord) {
		_oop = unsignedLongAt(_p);
		unsignedLongAtput((_p - BytesPerWord) - BytesPerWord, unsignedLongAt(_p));
	}
	GIV(stackPointer) = (GIV(stackPointer) - BytesPerWord) - BytesPerWord;
	/* begin push: */
	unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _aNonBooleanObject);
	GIV(stackPointer) = _sp;
	/* end push: */
	{
		unsignedLongAtput(GIV(framePointer) + FoxIFrameFlags, encodeFrameFieldHasContextisBlocknumArgs(((unsignedLongAt(GIV(framePointer) + FoxMethod)) & MFMethodFlagHasContextFlag) != 0, ((unsignedLongAt(GIV(framePointer) + FoxMethod)) & MFMethodFlagIsBlockFlag) != 0, (_cogMethod->cmNumArgs)));
		unsignedLongAtput(GIV(framePointer) + FoxIFSavedIP, 0);
		unsignedLongAtput(GIV(framePointer) + FoxMethod, _methodObj);
	}
	/* begin setMethod:methodHeader: */
	/* begin setMethod: */
	assert(((usqInt) _methodObj ) >= (startOfObjectMemory(getMemoryMap())));
	{
		GIV(method) = _methodObj;
		assert(isOopCompiledMethod(GIV(method)));
	}
	/* end setMethod: */
	assert((methodHeaderOf(GIV(method))) == _methodHeader);
	/* end setMethod:methodHeader: */
	siglongjmp(reenterInterpreter, ReturnToInterpreter);
}
/* CoInterpreter>>#ceSendMustBeBoolean: */
sqInt
ceSendMustBeBoolean(sqInt _anObject)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_sp;
	char *_sp2;
	sqInt _top;

	/* begin popStack */
	_top = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	GIV(instructionPointer) = _top;
	/* end popStack */
	/* begin push: */
	unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _anObject);
	GIV(stackPointer) = _sp;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
	GIV(stackPointer) = _sp2;
	/* end push: */
	return ceSendAborttonumArgs(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorMustBeBoolean ) << (shiftForWord())) )), _anObject, 0);
}
/*	Entry-point for an unlinked directed super send in a CogMethod. 
	methodClassBinding is an association whose value is the class above which 
	to start the lookup. 
	Smalltalk stack looks like: 
	receiver 
	args 
	head sp -> sender return pc */
/* CoInterpreter>>#ceSend:aboveClassBinding:to:numArgs: */
void
ceSendaboveClassBindingtonumArgs(sqInt _selector, sqInt _methodClassBinding, sqInt _rcvr, sqInt _numArgs)
{
	ceSendabovetonumArgs(_selector, fetchPointerofObject(ValueIndex, ((((_methodClassBinding & (tagMask())) == 0) && (((long64At(_methodClassBinding)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))
		 ? noInlineFollowForwarded(_methodClassBinding)
		 : _methodClassBinding)), _rcvr, _numArgs);
}
/*	Entry-point for an unlinked directed super send in a CogMethod. 
	methodClass is the class above which to start the lookup. 
	Smalltalk stack looks like: 
	receiver 
	args 
	head sp -> sender return pc */
/* CoInterpreter>>#ceSend:above:to:numArgs: */
void
ceSendabovetonumArgs(sqInt _maybeForwardedSelector, sqInt _methodClass, sqInt _receiver, sqInt _numArgs)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classObj;
	sqInt _classObj2;
	sqInt _classPointer;
	sqInt _classTag;
	CogMethod *_cogMethod;
	CogMethod *_cogMethod2;
	sqInt _err;
	sqInt _errSelIdx;
	sqInt _found;
	sqInt _hash;
	sqInt _inInterpreter;
	sqInt _methodHeader;
	sqInt _methodHeader2;
	sqInt _methodHeader3;
	CogMethod *_mnuPIC;
	sqInt _nArgs;
	sqInt _objOop;
	char *_savedFramePointer;
	char *_savedStackPointer;
	sqInt _selector;
	sqInt _succeeded;
	sqInt _top;
	sqInt _top2;

	_nArgs = 0;
	_savedFramePointer = ((char *) 0 );
	_savedStackPointer = ((char *) 0 );
	assert(addressCouldBeOop(_receiver));
	/* begin superclassOf: */
	_classPointer = ((((_methodClass & (tagMask())) == 0) && (((long64At(_methodClass)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))
		 ? noInlineFollowForwarded(_methodClass)
		 : _methodClass);
	/* begin followField:ofObject: */
	/* begin fetchPointer:ofObject: */
	_objOop = unsignedLongAt((_classPointer + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		_objOop = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _classPointer, _objOop);
	}
	_classObj = _objOop;
	/* end followField:ofObject: */
	/* end superclassOf: */
	{
		assert(addressCouldBeClassObj(_classObj));
		_classTag = ((((_hash = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask()))) != 0)
			 ? _hash
			 : ((objCouldBeClassObj(_classObj))
				 ? ((((_err = enterIntoClassTable(_classObj))) != 0)
					 ? -_err
					 : (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask()))
				 : -PrimErrBadReceiver));
	}
	/* begin handleUnlinkedSendFor:to:isSuper:classTag:numArgs:classObjGetter: */
	assertCStackWellAligned();
	assert(!(isForwardedClassTag(_classTag)));
	assert(isNotForwarded(_receiver));
	GIV(argumentCount) = _numArgs;
	_selector = _maybeForwardedSelector;
	if (((_maybeForwardedSelector & (tagMask())) == 0) && (((long64At(_maybeForwardedSelector)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		_selector = handleForwardedSelectorFaultFor(_maybeForwardedSelector);
	}
	_found = lookupInMethodCacheSelclassTag(_selector, _classTag);
	if (_found) {
		/* begin ifAppropriateCompileToNativeCode:selector: */
		/* begin fetchPointer:ofObject: */
		_methodHeader2 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if ((assert((((_methodHeader2 & 7) == 1)) || ((((usqInt) _methodHeader2 ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader2 ) >= (minCogMethodAddress())))), (_methodHeader2 & (smallIntegerTag())) == 0)) {
			_cogMethod2 = ((CogMethod *) _methodHeader2 );
			if (((_cogMethod2->selector)) == GIV(nilObj)) {
				setSelectorOfto(_cogMethod2, _selector);
			}
		} else {
			if (((assert(((_methodHeader2 & 7) == 1)), (_methodHeader2 >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
				cogselector(GIV(newMethod), _selector);
			}
 else {
				maybeFlagMethodAsInterpreted(GIV(newMethod));
			}
		}
		/* end ifAppropriateCompileToNativeCode:selector: */
	}
	if (!_found) {
		GIV(messageSelector) = _selector;
		{
			_classObj2 = _classObj;
		}
		assert(isNotForwarded(_receiver));
		_errSelIdx = lookupMethodWithoutMNUProcessingInClass(_classObj2);
		if (_errSelIdx != 0) {
			if (_errSelIdx == SelectorDoesNotUnderstand) {
				_mnuPIC = cogMNUPICSelectorreceivermethodOperandnumArgs(GIV(messageSelector), _receiver, mnuMethodOrNilFor(_receiver), GIV(argumentCount));
				if (((usqIntptr_t) _mnuPIC ) > (minCogMethodAddress())) {
					linkSendAtintooffsetreceiver(longAt(GIV(stackPointer)), mframeHomeMethod(GIV(framePointer)), _mnuPIC, ((1 == 0)
						 ? entryOffset()
						 : noCheckEntryOffset()), _receiver);
				}
			}
			handleMNUInMachineCodeToclassForMessage(_errSelIdx, _receiver, _classObj2);
			{
				assert(0);
			}
		}
	}
	if (!(((GIV(newMethod) & (tagMask())) == 0) && ((((((usqInt) (longAt(GIV(newMethod))) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && (isCogMethodReference(rawHeaderOf(GIV(newMethod))))))) {
		/* begin popStack */
		_top = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		GIV(instructionPointer) = _top;
		/* end popStack */
		interpretMethodFromMachineCode();
		{
			assert(0);
		}
	}
	/* begin cogMethodOf: */
	/* begin fetchPointer:ofObject: */
	_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert((isNonImmediate(_methodHeader)) && (((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))));
	_cogMethod = ((CogMethod *) _methodHeader );
	/* end cogMethodOf: */
	if (((_cogMethod->selector)) == GIV(nilObj)) {
		setSelectorOfto(_cogMethod, _selector);
	}
	if (((_cogMethod->selector)) == _selector) {
		linkSendAtintooffsetreceiver(longAt(GIV(stackPointer)), mframeHomeMethod(GIV(framePointer)), _cogMethod, ((1 == 0)
			 ? entryOffset()
			 : noCheckEntryOffset()), _receiver);
	} else {
		if (1 == 0) {
			patchToMegamorphicICFornumArgsreceiver(_selector, _numArgs, _receiver);
		}
	}
	/* begin popStack */
	_top2 = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	GIV(instructionPointer) = _top2;
	/* end popStack */
	/* begin executeNewMethod */
	/* begin executeNewMethod: */
	_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	/* begin executePrimitiveFromInterpreter:ifFail: */
	if (primitiveFunctionPointer != 0) {
		if (((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex) {
			executeQuickPrimitive();
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), _inInterpreter);
			/* end returnToExecutive: */
			goto l11;
		}
		/* begin slowPrimitiveResponse */
		if (recordPrimTrace()) {
			/* begin fastLogPrim: */
			GIV(primTraceLog)[GIV(primTraceLogIndex)] = GIV(messageSelector);
			primTraceLogIndex(GIV(primTraceLogIndex) + 1);
			/* end fastLogPrim: */
		}
		assert((remapBufferCount()) == 0);
		{
			_nArgs = GIV(argumentCount);
			_savedStackPointer = GIV(stackPointer);
			_savedFramePointer = GIV(framePointer);
		}
		/* begin initPrimCall */
		GIV(primFailCode) = 0;
		/* end initPrimCall */
		/* begin dispatchFunctionPointer: */
		primitiveFunctionPointer();
		/* end dispatchFunctionPointer: */
		assert(maybeLeakCheckExternalPrimCall(GIV(newMethod)));
		/* begin maybeRetryPrimitiveOnFailure */
		if (GIV(primFailCode)) {
			retryPrimitiveOnFailure();
		}
		/* end maybeRetryPrimitiveOnFailure */
		/* begin maybeFailForLastObjectOverwrite */
		if (checkAllocFiller) {
			if (((freeStart0()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart0())) != (freeStart0()))) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrWritePastObject;
				/* end primitiveFailFor: */
			}
		}
		/* end maybeFailForLastObjectOverwrite */
		if (!GIV(primFailCode) && ((GIV(framePointer) == _savedFramePointer) && (!(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))))) {
			if (GIV(stackPointer) != (_savedStackPointer + (_nArgs * BytesPerWord))) {
				flag("Would be nice to make this a message send of e.g. unbalancedPrimitive to the current process or context");
				failUnbalancedPrimitive();
				GIV(stackPointer) = _savedStackPointer;
			}
		}
		if (GIV(nextProfileTick) > 0) {
			checkProfileTick(GIV(newMethod));
		}
		_succeeded = !GIV(primFailCode);
		goto l7;
		l7:
		;
		/* end slowPrimitiveResponse */
		if (_succeeded) {
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), _inInterpreter);
			/* end returnToExecutive: */
			goto l11;
		}
	}
	{
		{
			/* begin fetchPointer:ofObject: */
			_methodHeader3 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (!((assert((((_methodHeader3 & 7) == 1)) || ((((usqInt) _methodHeader3 ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader3 ) >= (minCogMethodAddress())))), (_methodHeader3 & (smallIntegerTag())) == 0))) {
				if (((assert(((_methodHeader3 & 7) == 1)), (_methodHeader3 >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
					cogselector(GIV(newMethod), GIV(nilObj));
					/* begin fetchPointer:ofObject: */
					_methodHeader3 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
				} else {
					maybeFlagMethodAsInterpreted(GIV(newMethod));
				}
			}
		}
		activateNewMethod();
	}
	l11:
	;
	/* end executePrimitiveFromInterpreter:ifFail: */
	/* end executeNewMethod: */
	/* end executeNewMethod */
	{
		assert(0);
	}
	/* end handleUnlinkedSendFor:to:isSuper:classTag:numArgs:classObjGetter: */
	{
		assert(0);
	}
}
/*	Entry-point for an unlinked send in a CogMethod. 
	Smalltalk stack looks like: 
	receiver 
	args 
	head sp -> sender return pc */
/* CoInterpreter>>#ceSend:super:to:numArgs: */
void
ceSendsupertonumArgs(sqInt _maybeForwardedSelector, sqInt _isSuperSend, sqInt _maybeForwardedReceiver, sqInt _numArgs)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classObj;
	sqInt _classObj2;
	sqInt _classObj3;
	sqInt _classPointer;
	sqInt _classTablePage;
	sqInt _classTag;
	CogMethod *_cogMethod;
	CogMethod *_cogMethod2;
	CogMethod *_cogMethod22;
	CogMethod *_cogMethod3;
	sqInt _err;
	sqInt _errSelIdx;
	sqInt _errSelIdx2;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;
	sqInt _found;
	sqInt _found2;
	sqInt _hash;
	sqInt _inInterpreter;
	sqInt _inInterpreter2;
	sqInt _literal;
	sqInt _methodHeader;
	sqInt _methodHeader2;
	sqInt _methodHeader22;
	sqInt _methodHeader3;
	sqInt _methodHeader32;
	sqInt _methodHeader4;
	sqInt _methodPointer;
	CogMethod *_mnuPIC;
	CogMethod *_mnuPIC2;
	sqInt _nArgs;
	sqInt _nArgs2;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _objOop3;
	sqInt _offset;
	sqInt _receiver;
	char *_savedFramePointer;
	char *_savedFramePointer2;
	char *_savedStackPointer;
	char *_savedStackPointer2;
	sqInt _selector;
	sqInt _selector2;
	sqInt _succeeded;
	sqInt _succeeded2;
	sqInt _tagBits;
	sqInt _tagBits2;
	sqInt _top;
	sqInt _top2;
	sqInt _top22;
	sqInt _top3;

	_nArgs = 0;
	_nArgs2 = 0;
	_savedFramePointer = ((char *) 0 );
	_savedFramePointer2 = ((char *) 0 );
	_savedStackPointer = ((char *) 0 );
	_savedStackPointer2 = ((char *) 0 );
	if (_isSuperSend == 0) {
		if (((_tagBits = _maybeForwardedReceiver & (tagMask()))) != 0) {
			_classTag = _tagBits;
		} else {
			/* begin classIndexOf: */
			_classTag = (longAt(_maybeForwardedReceiver)) & (classIndexMask());
			/* end classIndexOf: */
		}
		_receiver = _maybeForwardedReceiver;
		if (_classTag == (isForwardedObjectClassIndexPun())) {
			_receiver = handleForwardedSendFaultForReceiverrcvrStackOffsetFromTop(_maybeForwardedReceiver, _numArgs + 1);
			if (((_tagBits2 = _receiver & (tagMask()))) != 0) {
				_classTag = _tagBits2;
			} else {
				/* begin classIndexOf: */
				_classTag = (longAt(_receiver)) & (classIndexMask());
				/* end classIndexOf: */
			}
		}
		/* begin handleUnlinkedSendFor:to:isSuper:classTag:numArgs:classObjGetter: */
		assertCStackWellAligned();
		assert(!(isForwardedClassTag(_classTag)));
		assert(isNotForwarded(_receiver));
		GIV(argumentCount) = _numArgs;
		_selector = _maybeForwardedSelector;
		if (((_maybeForwardedSelector & (tagMask())) == 0) && (((long64At(_maybeForwardedSelector)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_selector = handleForwardedSelectorFaultFor(_maybeForwardedSelector);
		}
		_found = lookupInMethodCacheSelclassTag(_selector, _classTag);
		if (_found) {
			/* begin ifAppropriateCompileToNativeCode:selector: */
			/* begin fetchPointer:ofObject: */
			_methodHeader2 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if ((assert((((_methodHeader2 & 7) == 1)) || ((((usqInt) _methodHeader2 ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader2 ) >= (minCogMethodAddress())))), (_methodHeader2 & (smallIntegerTag())) == 0)) {
				_cogMethod2 = ((CogMethod *) _methodHeader2 );
				if (((_cogMethod2->selector)) == GIV(nilObj)) {
					setSelectorOfto(_cogMethod2, _selector);
				}
			} else {
				if (((assert(((_methodHeader2 & 7) == 1)), (_methodHeader2 >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
					cogselector(GIV(newMethod), _selector);
				}
 else {
					maybeFlagMethodAsInterpreted(GIV(newMethod));
				}
			}
			/* end ifAppropriateCompileToNativeCode:selector: */
		}
		if (!_found) {
			GIV(messageSelector) = _selector;
			{
				/* begin classAtIndex: */
				assert((_classTag >= 0) && ((_classTag <= (tagMask())) || ((_classTag >= (arrayClassIndexPun())) && (_classTag <= (classIndexMask())))));
				/* begin fetchPointer:ofObject: */
				_fieldIndex2 = ((usqInt) _classTag ) >> (classTableMajorIndexShift());
				_classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				_classObj2 = ((_classTablePage == GIV(nilObj))
					 ? null
					 : (/* begin fetchPointer:ofObject: */ (_fieldIndex = _classTag & ((1U << (classTableMajorIndexShift())) - 1)), unsignedLongAt((_classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */));
				/* end classAtIndex: */
			}
			assert(isNotForwarded(_receiver));
			_errSelIdx = lookupMethodWithoutMNUProcessingInClass(_classObj2);
			if (_errSelIdx != 0) {
				if (_errSelIdx == SelectorDoesNotUnderstand) {
					_mnuPIC = cogMNUPICSelectorreceivermethodOperandnumArgs(GIV(messageSelector), _receiver, mnuMethodOrNilFor(_receiver), GIV(argumentCount));
					if (((usqIntptr_t) _mnuPIC ) > (minCogMethodAddress())) {
						linkSendAtintooffsetreceiver(longAt(GIV(stackPointer)), mframeHomeMethod(GIV(framePointer)), _mnuPIC, ((_isSuperSend == 0)
							 ? entryOffset()
							 : noCheckEntryOffset()), _receiver);
					}
				}
				handleMNUInMachineCodeToclassForMessage(_errSelIdx, _receiver, _classObj2);
				{
					assert(0);
				}
			}
		}
		if (!(((GIV(newMethod) & (tagMask())) == 0) && ((((((usqInt) (longAt(GIV(newMethod))) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && (isCogMethodReference(rawHeaderOf(GIV(newMethod))))))) {
			/* begin popStack */
			_top = unsignedLongAt(GIV(stackPointer));
			GIV(stackPointer) += BytesPerWord;
			GIV(instructionPointer) = _top;
			/* end popStack */
			interpretMethodFromMachineCode();
			{
				assert(0);
			}
		}
		/* begin cogMethodOf: */
		/* begin fetchPointer:ofObject: */
		_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert((isNonImmediate(_methodHeader)) && (((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))));
		_cogMethod = ((CogMethod *) _methodHeader );
		/* end cogMethodOf: */
		if (((_cogMethod->selector)) == GIV(nilObj)) {
			setSelectorOfto(_cogMethod, _selector);
		}
		if (((_cogMethod->selector)) == _selector) {
			linkSendAtintooffsetreceiver(longAt(GIV(stackPointer)), mframeHomeMethod(GIV(framePointer)), _cogMethod, ((_isSuperSend == 0)
				 ? entryOffset()
				 : noCheckEntryOffset()), _receiver);
		} else {
			if (_isSuperSend == 0) {
				patchToMegamorphicICFornumArgsreceiver(_selector, _numArgs, _receiver);
			}
		}
		/* begin popStack */
		_top2 = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		GIV(instructionPointer) = _top2;
		/* end popStack */
		/* begin executeNewMethod */
		/* begin executeNewMethod: */
		_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
		/* begin executePrimitiveFromInterpreter:ifFail: */
		if (primitiveFunctionPointer != 0) {
			if (((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex) {
				executeQuickPrimitive();
				/* begin returnToExecutive: */
				returntoExecutive(popStack(), _inInterpreter);
				/* end returnToExecutive: */
				goto l19;
			}
			/* begin slowPrimitiveResponse */
			if (recordPrimTrace()) {
				/* begin fastLogPrim: */
				GIV(primTraceLog)[GIV(primTraceLogIndex)] = GIV(messageSelector);
				primTraceLogIndex(GIV(primTraceLogIndex) + 1);
				/* end fastLogPrim: */
			}
			assert((remapBufferCount()) == 0);
			{
				_nArgs = GIV(argumentCount);
				_savedStackPointer = GIV(stackPointer);
				_savedFramePointer = GIV(framePointer);
			}
			/* begin initPrimCall */
			GIV(primFailCode) = 0;
			/* end initPrimCall */
			/* begin dispatchFunctionPointer: */
			primitiveFunctionPointer();
			/* end dispatchFunctionPointer: */
			assert(maybeLeakCheckExternalPrimCall(GIV(newMethod)));
			/* begin maybeRetryPrimitiveOnFailure */
			if (GIV(primFailCode)) {
				retryPrimitiveOnFailure();
			}
			/* end maybeRetryPrimitiveOnFailure */
			/* begin maybeFailForLastObjectOverwrite */
			if (checkAllocFiller) {
				if (((freeStart0()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart0())) != (freeStart0()))) {
					/* begin primitiveFailFor: */
					GIV(primFailCode) = PrimErrWritePastObject;
					/* end primitiveFailFor: */
				}
			}
			/* end maybeFailForLastObjectOverwrite */
			if (!GIV(primFailCode) && ((GIV(framePointer) == _savedFramePointer) && (!(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))))) {
				if (GIV(stackPointer) != (_savedStackPointer + (_nArgs * BytesPerWord))) {
					flag("Would be nice to make this a message send of e.g. unbalancedPrimitive to the current process or context");
					failUnbalancedPrimitive();
					GIV(stackPointer) = _savedStackPointer;
				}
			}
			if (GIV(nextProfileTick) > 0) {
				checkProfileTick(GIV(newMethod));
			}
			_succeeded = !GIV(primFailCode);
			goto l21;
			l21:
			;
			/* end slowPrimitiveResponse */
			if (_succeeded) {
				/* begin returnToExecutive: */
				returntoExecutive(popStack(), _inInterpreter);
				/* end returnToExecutive: */
				goto l19;
			}
		}
		{
			{
				/* begin fetchPointer:ofObject: */
				_methodHeader3 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (!((assert((((_methodHeader3 & 7) == 1)) || ((((usqInt) _methodHeader3 ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader3 ) >= (minCogMethodAddress())))), (_methodHeader3 & (smallIntegerTag())) == 0))) {
					if (((assert(((_methodHeader3 & 7) == 1)), (_methodHeader3 >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
						cogselector(GIV(newMethod), GIV(nilObj));
						/* begin fetchPointer:ofObject: */
						_methodHeader3 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
					} else {
						maybeFlagMethodAsInterpreted(GIV(newMethod));
					}
				}
			}
			activateNewMethod();
		}
		l19:
		;
		/* end executePrimitiveFromInterpreter:ifFail: */
		/* end executeNewMethod: */
		/* end executeNewMethod */
		{
			assert(0);
		}
		/* end handleUnlinkedSendFor:to:isSuper:classTag:numArgs:classObjGetter: */
	} else {
		assert(isNotForwarded(_maybeForwardedReceiver));
		/* begin superclassOf: */
		/* begin methodClassOf: */
		_methodPointer = ((isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))
			 ? ((mframeHomeMethod(GIV(framePointer)))->methodObject)
			 : (/* begin iframeMethod: */ unsignedLongAt(GIV(framePointer) + FoxMethod) /* end iframeMethod: */));
		/* begin followLiteral:ofMethod: */
		_offset = (literalCountOfMethodHeader(methodHeaderOf(_methodPointer))) - 1;
		/* begin followField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop2 = unsignedLongAt((_methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset + LiteralStart) ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_objOop2 & (tagMask())) == 0) && (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_objOop2 = fixFollowedFieldofObjectwithInitialValue(_offset + LiteralStart, _methodPointer, _objOop2);
		}
		_literal = _objOop2;
		/* end followField:ofObject: */
		/* end followLiteral:ofMethod: */
		if ((_literal != GIV(nilObj)) && (((_literal & (tagMask())) == 0) && (((((usqInt) (longAt(_literal)) ) >> (formatShift())) & (formatMask())) <= 5))) {
			assert((numSlotsOf(_literal)) > ValueIndex);
			/* begin followField:ofObject: */
			/* begin fetchPointer:ofObject: */
			_objOop3 = unsignedLongAt((_literal + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_objOop3 & (tagMask())) == 0) && (((long64At(_objOop3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				_objOop3 = fixFollowedFieldofObjectwithInitialValue(ValueIndex, _literal, _objOop3);
			}
			_classPointer = _objOop3;
			/* end followField:ofObject: */
		} else {
			/* begin nilObject */
			_classPointer = GIV(nilObj);
			/* end nilObject */
		}
		/* end methodClassOf: */
		/* begin followField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop = unsignedLongAt((_classPointer + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_objOop = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _classPointer, _objOop);
		}
		_classObj = _objOop;
		/* end followField:ofObject: */
		/* end superclassOf: */
		{
			assert(addressCouldBeClassObj(_classObj));
			_classTag = ((((_hash = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask()))) != 0)
				 ? _hash
				 : ((objCouldBeClassObj(_classObj))
					 ? ((((_err = enterIntoClassTable(_classObj))) != 0)
						 ? -_err
						 : (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask()))
					 : -PrimErrBadReceiver));
		}
		/* begin handleUnlinkedSendFor:to:isSuper:classTag:numArgs:classObjGetter: */
		assertCStackWellAligned();
		assert(!(isForwardedClassTag(_classTag)));
		assert(isNotForwarded(_maybeForwardedReceiver));
		GIV(argumentCount) = _numArgs;
		_selector2 = _maybeForwardedSelector;
		if (((_maybeForwardedSelector & (tagMask())) == 0) && (((long64At(_maybeForwardedSelector)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_selector2 = handleForwardedSelectorFaultFor(_maybeForwardedSelector);
		}
		_found2 = lookupInMethodCacheSelclassTag(_selector2, _classTag);
		if (_found2) {
			/* begin ifAppropriateCompileToNativeCode:selector: */
			/* begin fetchPointer:ofObject: */
			_methodHeader22 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if ((assert((((_methodHeader22 & 7) == 1)) || ((((usqInt) _methodHeader22 ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader22 ) >= (minCogMethodAddress())))), (_methodHeader22 & (smallIntegerTag())) == 0)) {
				_cogMethod22 = ((CogMethod *) _methodHeader22 );
				if (((_cogMethod22->selector)) == GIV(nilObj)) {
					setSelectorOfto(_cogMethod22, _selector2);
				}
			} else {
				if (((assert(((_methodHeader22 & 7) == 1)), (_methodHeader22 >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
					cogselector(GIV(newMethod), _selector2);
				}
 else {
					maybeFlagMethodAsInterpreted(GIV(newMethod));
				}
			}
			/* end ifAppropriateCompileToNativeCode:selector: */
		}
		if (!_found2) {
			GIV(messageSelector) = _selector2;
			{
				_classObj3 = _classObj;
			}
			assert(isNotForwarded(_maybeForwardedReceiver));
			_errSelIdx2 = lookupMethodWithoutMNUProcessingInClass(_classObj3);
			if (_errSelIdx2 != 0) {
				if (_errSelIdx2 == SelectorDoesNotUnderstand) {
					_mnuPIC2 = cogMNUPICSelectorreceivermethodOperandnumArgs(GIV(messageSelector), _maybeForwardedReceiver, mnuMethodOrNilFor(_maybeForwardedReceiver), GIV(argumentCount));
					if (((usqIntptr_t) _mnuPIC2 ) > (minCogMethodAddress())) {
						linkSendAtintooffsetreceiver(longAt(GIV(stackPointer)), mframeHomeMethod(GIV(framePointer)), _mnuPIC2, ((_isSuperSend == 0)
							 ? entryOffset()
							 : noCheckEntryOffset()), _maybeForwardedReceiver);
					}
				}
				handleMNUInMachineCodeToclassForMessage(_errSelIdx2, _maybeForwardedReceiver, _classObj3);
				{
					assert(0);
				}
			}
		}
		if (!(((GIV(newMethod) & (tagMask())) == 0) && ((((((usqInt) (longAt(GIV(newMethod))) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && (isCogMethodReference(rawHeaderOf(GIV(newMethod))))))) {
			/* begin popStack */
			_top3 = unsignedLongAt(GIV(stackPointer));
			GIV(stackPointer) += BytesPerWord;
			GIV(instructionPointer) = _top3;
			/* end popStack */
			interpretMethodFromMachineCode();
			{
				assert(0);
			}
		}
		/* begin cogMethodOf: */
		/* begin fetchPointer:ofObject: */
		_methodHeader4 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert((isNonImmediate(_methodHeader4)) && (((usqInt) _methodHeader4 ) < (startOfObjectMemory(getMemoryMap()))));
		_cogMethod3 = ((CogMethod *) _methodHeader4 );
		/* end cogMethodOf: */
		if (((_cogMethod3->selector)) == GIV(nilObj)) {
			setSelectorOfto(_cogMethod3, _selector2);
		}
		if (((_cogMethod3->selector)) == _selector2) {
			linkSendAtintooffsetreceiver(longAt(GIV(stackPointer)), mframeHomeMethod(GIV(framePointer)), _cogMethod3, ((_isSuperSend == 0)
				 ? entryOffset()
				 : noCheckEntryOffset()), _maybeForwardedReceiver);
		} else {
			if (_isSuperSend == 0) {
				patchToMegamorphicICFornumArgsreceiver(_selector2, _numArgs, _maybeForwardedReceiver);
			}
		}
		/* begin popStack */
		_top22 = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		GIV(instructionPointer) = _top22;
		/* end popStack */
		/* begin executeNewMethod */
		/* begin executeNewMethod: */
		_inInterpreter2 = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
		/* begin executePrimitiveFromInterpreter:ifFail: */
		if (primitiveFunctionPointer != 0) {
			if (((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex) {
				executeQuickPrimitive();
				/* begin returnToExecutive: */
				returntoExecutive(popStack(), _inInterpreter2);
				/* end returnToExecutive: */
				goto l29;
			}
			/* begin slowPrimitiveResponse */
			if (recordPrimTrace()) {
				/* begin fastLogPrim: */
				GIV(primTraceLog)[GIV(primTraceLogIndex)] = GIV(messageSelector);
				primTraceLogIndex(GIV(primTraceLogIndex) + 1);
				/* end fastLogPrim: */
			}
			assert((remapBufferCount()) == 0);
			{
				_nArgs2 = GIV(argumentCount);
				_savedStackPointer2 = GIV(stackPointer);
				_savedFramePointer2 = GIV(framePointer);
			}
			/* begin initPrimCall */
			GIV(primFailCode) = 0;
			/* end initPrimCall */
			/* begin dispatchFunctionPointer: */
			primitiveFunctionPointer();
			/* end dispatchFunctionPointer: */
			assert(maybeLeakCheckExternalPrimCall(GIV(newMethod)));
			/* begin maybeRetryPrimitiveOnFailure */
			if (GIV(primFailCode)) {
				retryPrimitiveOnFailure();
			}
			/* end maybeRetryPrimitiveOnFailure */
			/* begin maybeFailForLastObjectOverwrite */
			if (checkAllocFiller) {
				if (((freeStart0()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart0())) != (freeStart0()))) {
					/* begin primitiveFailFor: */
					GIV(primFailCode) = PrimErrWritePastObject;
					/* end primitiveFailFor: */
				}
			}
			/* end maybeFailForLastObjectOverwrite */
			if (!GIV(primFailCode) && ((GIV(framePointer) == _savedFramePointer2) && (!(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))))) {
				if (GIV(stackPointer) != (_savedStackPointer2 + (_nArgs2 * BytesPerWord))) {
					flag("Would be nice to make this a message send of e.g. unbalancedPrimitive to the current process or context");
					failUnbalancedPrimitive();
					GIV(stackPointer) = _savedStackPointer2;
				}
			}
			if (GIV(nextProfileTick) > 0) {
				checkProfileTick(GIV(newMethod));
			}
			_succeeded2 = !GIV(primFailCode);
			goto l31;
			l31:
			;
			/* end slowPrimitiveResponse */
			if (_succeeded2) {
				/* begin returnToExecutive: */
				returntoExecutive(popStack(), _inInterpreter2);
				/* end returnToExecutive: */
				goto l29;
			}
		}
		{
			{
				/* begin fetchPointer:ofObject: */
				_methodHeader32 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (!((assert((((_methodHeader32 & 7) == 1)) || ((((usqInt) _methodHeader32 ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader32 ) >= (minCogMethodAddress())))), (_methodHeader32 & (smallIntegerTag())) == 0))) {
					if (((assert(((_methodHeader32 & 7) == 1)), (_methodHeader32 >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
						cogselector(GIV(newMethod), GIV(nilObj));
						/* begin fetchPointer:ofObject: */
						_methodHeader32 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
					} else {
						maybeFlagMethodAsInterpreted(GIV(newMethod));
					}
				}
			}
			activateNewMethod();
		}
		l29:
		;
		/* end executePrimitiveFromInterpreter:ifFail: */
		/* end executeNewMethod: */
		/* end executeNewMethod */
		{
			assert(0);
		}
		/* end handleUnlinkedSendFor:to:isSuper:classTag:numArgs:classObjGetter: */
	}
	{
		assert(0);
	}
}
/*	If contextSwitchIfNotNil is nil we can't context switch. 
	contextSwitchIfNotNil is set to nil by 
	- the special primitiveClosureValueNoContextSwitch entry-point in block 
	dispatch - the stack check in methods with primitive 198. 
	In a normal method contextSwitchIfNotNil will be the method (see e.g. 
	SimpleStackBasedCogit>>compileFrameBuild). In a block it will be the 
	closure (see e.g. SimpleStackBasedCogit>>compileMethodBody). */
/* CoInterpreter>>#ceStackOverflow: */
void
ceStackOverflow(sqInt _contextSwitchIfNotNil)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _cesoRetAddr;
	CogMethod *_cogMethod;
	sqInt _switched;
	sqInt _top;

	/* begin popStack */
	_top = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	_cesoRetAddr = _top;
	/* end popStack */
	_cogMethod = ((CogMethod *) ((unsignedLongAt(GIV(framePointer) + FoxMethod)) & MFMethodMask) );
	assert((_cesoRetAddr - (abortOffset())) == ((sqInt) _cogMethod ));
	GIV(instructionPointer) = ((sqInt) _cogMethod ) + ((_cogMethod->stackCheckOffset));
	assertValidExecutionPointersimbarline(GIV(instructionPointer), GIV(framePointer), GIV(stackPointer), 0, __LINE__);
	GIV(method) = (GIV(newMethod) = (GIV(messageSelector) = GIV(nilObj)));
	_switched = handleStackOverflowOrEventAllowContextSwitch(_contextSwitchIfNotNil != 0);
	returnToExecutivepostContextSwitch(0, _switched);
	error("should not be reached");
}
/* CoInterpreter>>#ceTraceBlockActivation */
void
ceTraceBlockActivation(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _selector;

	if (recordBlockTrace()) {
		/* begin recordTrace:thing:source: */
		_selector = ((mframeHomeMethod(GIV(framePointer)))->methodObject);
		GIV(traceLog)[GIV(traceLogIndex)] = TraceBlockActivation;
		GIV(traceLog)[GIV(traceLogIndex) + 1] = _selector;
		GIV(traceLog)[GIV(traceLogIndex) + 2] = TraceIsFromMachineCode;
		GIV(traceLogIndex) = (GIV(traceLogIndex) + 3) % TraceBufferSize;
		/* end recordTrace:thing:source: */
		if (printOnTrace()) {
			printActivationNameForreceiverisBlockfirstTemporary(((mframeHomeMethod(GIV(framePointer)))->methodObject), ((isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))
				 ? (/* begin mframeReceiver: */ unsignedLongAt(GIV(framePointer) + FoxMFReceiver) /* end mframeReceiver: */)
				 : (/* begin iframeReceiver: */ unsignedLongAt(GIV(framePointer) + FoxIFReceiver) /* end iframeReceiver: */)), 1, null);
			/* begin cr */
			print("\n");
			/* end cr */
		}
	}
}
/* CoInterpreter>>#ceTraceLinkedSend: */
void
ceTraceLinkedSend(sqInt _theReceiver)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classOrInteger;
	CogMethod *_cogMethod;
	sqInt _selector;
	sqInt _selector2;
	sqInt _tagBits;

	_cogMethod = ((CogMethod *) ((unsignedLongAt(GIV(stackPointer))) - (traceLinkedSendOffset())) );
	/* begin recordTrace:thing:source: */
	if (((_tagBits = _theReceiver & (tagMask()))) != 0) {
		/* begin fetchPointer:ofObject: */
		_classOrInteger = unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
	} else {
		_classOrInteger = fetchClassOfNonImm(_theReceiver);
	}
	_selector = (_cogMethod->selector);
	GIV(traceLog)[GIV(traceLogIndex)] = _classOrInteger;
	GIV(traceLog)[GIV(traceLogIndex) + 1] = _selector;
	GIV(traceLog)[GIV(traceLogIndex) + 2] = TraceIsFromMachineCode;
	GIV(traceLogIndex) = (GIV(traceLogIndex) + 3) % TraceBufferSize;
	/* end recordTrace:thing:source: */
	if (printOnTrace()) {
		{
			printActivationNameForreceiverisBlockfirstTemporary((_cogMethod->methodObject), _theReceiver, 0, null);
			/* begin cr */
			print("\n");
			/* end cr */
		}
	}
	/* begin sendBreakpoint:receiver: */
	_selector2 = (_cogMethod->selector);
	sendBreakpointreceiver(firstFixedFieldOfMaybeImmediate(_selector2), lengthOfMaybeImmediate(_selector2), _theReceiver);
	/* end sendBreakpoint:receiver: */
}
/*	For assertion checking. */
/* CoInterpreter>>#ceTraceStoreOf:into: */
void
ceTraceStoreOfinto(sqInt _aValue, sqInt _anObject)
{
	assert((isImmediate(_aValue)) || (addressCouldBeObj(_aValue)));
	assert(addressCouldBeObj(_anObject));
}
/* CoInterpreter>>#checkAssertsEnabledInCoInterpreter */
void
checkAssertsEnabledInCoInterpreter(void)
{
	int _assertsAreEnabledInCoInterpreter;

	_assertsAreEnabledInCoInterpreter = 0;
	assert(_assertsAreEnabledInCoInterpreter);
}
/*	Perform an integrity/leak check using the heapMap. Assume 
	clearLeakMapAndMapAccessibleObjects has set a bit at each 
	object's header. Check that all object references in machine 
	code are valid. Answer if all checks pass. */
/* CoInterpreter>>#checkCodeIntegrity: */
static sqInt NoDbgRegParms
checkCodeIntegrity(sqInt _gcModes)
{
	return checkIntegrityOfObjectReferencesInCode(_gcModes);
}
/*	Check the log for leaks. The trace log is a circular buffer of pairs of 
	entries. If there is an entry at traceLogIndex - 3 \\ TraceBufferSize it 
	has entries. If 
	there is something at traceLogIndex it has wrapped. */
/* CoInterpreter>>#checkLogIntegrity */
static sqInt
checkLogIntegrity(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _limit;
	int _ok;
	sqInt _oop;
	sqInt _remainder;

	_limit = ((((_remainder = (GIV(traceLogIndex) - 3) % TraceBufferSize)) < 0)
		 ? _remainder + TraceBufferSize
		 : _remainder);
	if ((GIV(traceLog)[_limit]) == 0) {
		return 1;
	}
	if ((GIV(traceLog)[GIV(traceLogIndex)]) != 0) {
		_limit = TraceBufferSize - 3;
	}
	_ok = 1;
	for (_i = 0; _i <= _limit; _i += 3) {
		_oop = GIV(traceLog)[_i];
		if (!(_oop & (tagMask()))) {
			if (!(checkOopIntegritynamedindex(_oop, "traceLog", _i))) {
				_ok = 0;
			}
		}
		_oop = GIV(traceLog)[_i + 1];
		if (!(_oop & (tagMask()))) {
			if (!(checkOopIntegritynamedindex(_oop, "traceLog", _i + 1))) {
				_ok = 0;
			}
		}
	}
	return _ok;
}
/* CoInterpreter>>#clearTraceLog */
void
clearTraceLog(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;

	GIV(traceLogIndex) = 0;
	for (_i = 0; _i < TraceBufferSize; _i += 1) {
		GIV(traceLog)[_i] = 0;
	}
}
/* CoInterpreter>>#cogMethodOf: */
CogMethod *
cogMethodOf(sqInt _aMethodOop)
{
	sqInt _methodHeader;

	/* begin fetchPointer:ofObject: */
	_methodHeader = unsignedLongAt((_aMethodOop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert((isNonImmediate(_methodHeader)) && (((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))));
	return ((CogMethod *) _methodHeader );
}
/* CoInterpreter>>#commenceCogCompiledCodeCompaction */
static void
commenceCogCompiledCodeCompaction(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_sp;
	usqLong _startTime;
	sqInt _top;

	GIV(cogCompiledCodeCompactionCalledFor) = 0;
	if (recordEventTrace()) {
		/* begin recordTrace:thing:source: */
		GIV(traceLog)[GIV(traceLogIndex)] = TraceCodeCompaction;
		GIV(traceLog)[GIV(traceLogIndex) + 1] = TraceCodeCompaction;
		GIV(traceLog)[GIV(traceLogIndex) + 2] = 0;
		GIV(traceLogIndex) = (GIV(traceLogIndex) + 3) % TraceBufferSize;
		/* end recordTrace:thing:source: */
	}
	if (recordPrimTrace()) {
		/* begin fastLogPrim: */
		GIV(primTraceLog)[GIV(primTraceLogIndex)] = TraceCodeCompaction;
		primTraceLogIndex(GIV(primTraceLogIndex) + 1);
		/* end fastLogPrim: */
	}
	_startTime = ioUTCMicrosecondsNow();
	if (GIV(instructionPointer) != 0) {
		assert(((usqIntptr_t) (stackTop()) ) != ((usqIntptr_t) GIV(instructionPointer) ));
		/* begin push: */
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
		GIV(stackPointer) = _sp;
		/* end push: */
		/* begin writeBackHeadStackPointer */
		assert((GIV(stackPointer) < ((GIV(stackPage)->baseAddress))) && (GIV(stackPointer) > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
		(GIV(stackPage)->headSP = GIV(stackPointer));
		/* end writeBackHeadStackPointer */
	}
	compactCogCompiledCode();
	/* begin nilUncoggableMethods */
	GIV(lastCoggableInterpretedBlockMethod) = (GIV(lastUncoggableInterpretedBlockMethod) = null);
	/* end nilUncoggableMethods */
	if (GIV(instructionPointer) != 0) {
		/* begin popStack */
		_top = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		GIV(instructionPointer) = _top;
		/* end popStack */
		/* begin writeBackHeadStackPointer */
		assert((GIV(stackPointer) < ((GIV(stackPage)->baseAddress))) && (GIV(stackPointer) > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
		(GIV(stackPage)->headSP = GIV(stackPointer));
		/* end writeBackHeadStackPointer */
	}
	GIV(statCodeCompactionCount) += 1;
	GIV(statCodeCompactionUsecs) += (ioUTCMicrosecondsNow()) - _startTime;
	if (checkForLeaks != 0) {
		clearLeakMapAndMapAccessibleObjects();
		assert(checkCodeIntegrity(0));
	}
}
/* CoInterpreter>>#compilationBreakpointFor: */
void
compilationBreakpointFor(sqInt selectorOop)
{
	suppressHeartbeatFlag = 1;
	warning("compilation send break (heartbeat suppressed)");
}
/*	Answer a value to store in the InstructionPointer index of a context 
	object for theIP and theFP. 
	Mapping native pcs to bytecode pcs is quite expensive, requiring a search 
	through the method 
	map. We mitigate this cost by deferring mapping until we really have to, 
	which is when a context's 
	instruction pointer is accessed by Smalltalk code (either direct inst var 
	access or through the 
	instVarAt: primitive). But to defer mapping we have to be able to 
	distinguish machine code from 
	bytecode pcs, which we do by using negative values for machine code pcs. 
	So if the frame is a 
	machine code one answer the negation of the offset in the cog method. 
	 
	As a whorish performance hack we also include the block method offset in 
	the pc of a block. 
	The least significant 16 bits are the native pc and the most significant 
	14 bits are the block 
	start, in block alignment units. So when mapping back we can find the 
	start of the block. 
	 
	See mustMapMachineCodePC:context: for the code that does the actual 
	mapping.  */
/* CoInterpreter>>#contextInstructionPointer:frame: */
static sqInt NoDbgRegParms
contextInstructionPointerframe(sqInt _anIP, char *_theFP)
{
	CogMethod *_cogMethod;
	sqInt _theIP;

	_theIP = _anIP;
	assert(validInstructionPointerinFrame(_theIP, _theFP));
	if (isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) ))) {
		/* begin encodedNativePCOf:cogMethod: */
		_cogMethod = ((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) );
		if (_theIP == (ceCannotResumePC())) {
			return HasBeenReturnedFromMCPCOop;
		}
		return ((((usqInt) (((sqInt) _cogMethod ) - _theIP) ) << 3) | 1);
		/* end encodedNativePCOf:cogMethod: */
	}
	if (_theIP == (ceReturnToInterpreterPC())) {
		_theIP = unsignedLongAt(_theFP + FoxIFSavedIP);
	}
	{
		assert(validInstructionPointerinFrame(_theIP, _theFP));
		return ((((usqInt) (((_theIP - (unsignedLongAt(_theFP + FoxMethod))) - BaseHeaderSize) + 2) ) << 3) | 1);
	}
	return 0;
}
/*	Defer smashes of the stackLimit around the call of functionSymbol (for 
	assert checks) */
/* CoInterpreter>>#deferStackLimitSmashAround:with: */
static sqInt NoDbgRegParms
deferStackLimitSmashAroundwith(void (*_functionSymbol)(sqInt), sqInt _arg)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	GIV(deferSmash) = 1;
	sqLowLevelMFence();
	_functionSymbol(_arg);
	GIV(deferSmash) = 0;
	sqLowLevelMFence();
	if (GIV(deferredSmash)) {
		GIV(deferredSmash) = 0;
		sqLowLevelMFence();
		forceInterruptCheck();
	}
	return 1;
}
/*	Divorce at most one frame in the current page (since the divorce may cause 
	the page to be split) 
	and answer whether a frame was divorced. */
/* CoInterpreter>>#divorceAMachineCodeFrameWithCogMethod:in: */
static sqInt NoDbgRegParms
divorceAMachineCodeFrameWithCogMethodin(CogMethod *_cogMethod, StackPage *_aStackPage)
{
	char *_calleeFP;
	sqInt _theContext;
	char *_theFP;
	char *_theSP;

	_theFP = (_aStackPage->headFP);
	_theSP = (_aStackPage->headSP);
	_theSP += BytesPerWord;
	while (1) {
		if ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) ))) && (_cogMethod == (mframeHomeMethod(_theFP)))) {
			/* begin ensureFrameIsMarried:SP: */
			if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
				 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
				 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0)) {
				assert(isContext(frameContext(_theFP)));
				_theContext = unsignedLongAt(_theFP + FoxThisContext);
				goto l2;
			}
			_theContext = marryFrameSP(_theFP, _theSP);
			l2:
			;
			/* end ensureFrameIsMarried:SP: */
			divorceFrameandContext(_theFP, _theContext);
			return 1;
		}
		_calleeFP = _theFP;
		_theFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP));
		if (!(_theFP != 0)) 
			break;
		{
			assert(!(isBaseFrame(_calleeFP)));
			_theSP = (_calleeFP + (frameStackedReceiverOffset(_calleeFP))) + BytesPerWord;
		}
	}
	return 0;
}
/*	The prim trace log is a circular buffer of entries. If there is 
	an entry at primTraceLogIndex \\ PrimTraceLogSize it has entries. 
	If there is something at primTraceLogIndex it has wrapped. */
/* CoInterpreter>>#dumpPrimTraceLog */
void
dumpPrimTraceLog(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _remainder;

	if ((GIV(primTraceLog)[((((_remainder = (GIV(primTraceLogIndex) - 1) % PrimTraceLogSize)) < 0)
		 ? _remainder + PrimTraceLogSize
		 : _remainder)]) == 0) {
		return;
	}
	if ((GIV(primTraceLog)[GIV(primTraceLogIndex)]) != 0) {
		for (_i = GIV(primTraceLogIndex); _i < PrimTraceLogSize; _i += 1) {
			{
				printPrimLogEntryAt(_i);
				/* begin cr */
				print("\n");
				/* end cr */
			}
		}
	}
	for (_i = 0; _i < GIV(primTraceLogIndex); _i += 1) {
		{
			printPrimLogEntryAt(_i);
			/* begin cr */
			print("\n");
			/* end cr */
		}
	}
}
/*	The trace log is a circular buffer of pairs of entries. If there is 
	an entry at traceLogIndex - 3 \\ TraceBufferSize it has entries. 
	If there is something at traceLogIndex it has wrapped. */
/* CoInterpreter>>#dumpTraceLog */
void
dumpTraceLog(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _remainder;

	if ((GIV(traceLog)[((((_remainder = (GIV(traceLogIndex) - 3) % TraceBufferSize)) < 0)
		 ? _remainder + TraceBufferSize
		 : _remainder)]) == 0) {
		return;
	}
	if ((GIV(traceLog)[GIV(traceLogIndex)]) != 0) {
		for (_i = GIV(traceLogIndex); _i <= (TraceBufferSize - 3); _i += 3) {
			printLogEntryAt(_i);
		}
	}
	for (_i = 0; _i <= (GIV(traceLogIndex) - 3); _i += 3) {
		printLogEntryAt(_i);
	}
}
/*	Make sure the context has a byetcode pc. Can only be used on single 
	contexts.  */
/* CoInterpreter>>#ensureContextHasBytecodePC: */
static void NoDbgRegParms
ensureContextHasBytecodePC(sqInt _aContext)
{
	sqInt _pc;

	assert(!(isMarriedOrWidowedContext(_aContext)));
	_pc = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ));
	if ((((_pc & 7) == 1)) && (((_pc = _pc >> 3)) < 0)) {
		_pc = mustMapMachineCodePCcontext(_pc, _aContext);
		assert(validBCPCinMethod(_pc >> 3, fetchPointerofObject(MethodIndex, _aContext)));
		{
			assert(!(isOopForwarded(_aContext)));
			longAtput((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), _pc);
		}
	}
}
/*	Safety to give the JIT lattitude in calling convention. Conceptually, 
	returning a value to a context involves pushing that value onto the stack. 
	This is used 
	in Squeak methods such as ContextPart>>jump 
	jump 
	| top | 
	thisContext sender push: nil. 
	stackp = 0 ifTrue: [self stepToSendOrReturn]. 
	stackp = 0 ifTrue: [self push: nil]. 
	top := self pop. 
	thisContext privSender: self. 
	^top 
	Here jump may pop the value of a temporary variable off the stack which 
	will, conceptually and, in the interpreter, actually, get pushed back on 
	return. But 
	if the JIT is mapping the stack to registers disaster may ensue since the 
	value may not get pushed to the stack and code may access an invalid value 
	(e.g. a pc). 
	 
	The solution is to fall back on the interpreter. If the stack pointer is 
	changed we 
	also ensure the pc is a bytecode pc (+ive) which will cause 
	makeBaseFrameFor: to create an interpreter frame if the context is 
	executed again. */
/* CoInterpreter>>#ensureContextIsExecutionSafeAfterAssignToStackPointer: */
static void NoDbgRegParms
ensureContextIsExecutionSafeAfterAssignToStackPointer(sqInt _aContext)
{
	ensureContextHasBytecodePC(_aContext);
}
/*	Main entry-point into the interpreter at each execution level, where an 
	execution level is either the start of execution or reentry for a 
	callback. Capture the C stack 
	pointers so that calls from machine-code into the C run-time occur at this 
	level. This is the actual implementation, separated from 
	enterSmalltalkExecutive so the 
	simulator can wrap it in an exception handler and hence simulate the 
	setjmp/longjmp.  */
/* CoInterpreter>>#enterSmalltalkExecutiveImplementation */
static sqInt
enterSmalltalkExecutiveImplementation(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aMethodObj;

	assertCStackWellAligned();
	ceCaptureCStackPointers();
	sigsetjmp(reenterInterpreter, 0);
	if (isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) ))) {
		returnToExecutivepostContextSwitch(0, 1);
		{
			assert(0);
		}
	}
	/* begin setMethod: */
	_aMethodObj = unsignedLongAt(GIV(framePointer) + FoxMethod);
	assert(((usqInt) _aMethodObj ) >= (startOfObjectMemory(getMemoryMap())));
	{
		GIV(method) = _aMethodObj;
		assert(isOopCompiledMethod(GIV(method)));
	}
	/* end setMethod: */
	if (((usqIntptr_t) GIV(instructionPointer) ) == (ceReturnToInterpreterPC())) {
		GIV(instructionPointer) = unsignedLongAt(GIV(framePointer) + FoxIFSavedIP);
	}
	assertValidExecutionPointersimbarline(GIV(instructionPointer), GIV(framePointer), GIV(stackPointer), 1, __LINE__);
	interpret();
	return 0;
}
/*	Execute a CogMethod from a linked send. The receiver, 
	arguments and return address are on the Smalltalk stack. First 
	push the entry-point and finally the register argument(s). Then write 
	back the frame pointers and call the routine that will pop off the 
	register argument(s) and jump to the entry by executing a return 
	instruction.  
	In the simple jit only the receiver gets passed in registers, so only the 
	receiver gets pushed. */
/* CoInterpreter>>#executeCogMethod:fromLinkedSendWithReceiver: */
void
executeCogMethodfromLinkedSendWithReceiver(CogMethod *_cogMethod, sqInt _rcvr)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _object;
	char *_sp;
	char *_sp2;

	assertCStackWellAligned();
	assert(isMachineCodeFrame(GIV(framePointer)));
	assertValidExecutionPointersimbarline(unsignedLongAt(GIV(stackPointer)), GIV(framePointer), GIV(stackPointer), 0, __LINE__);
	{
		if (((_cogMethod->cmNumArgs)) <= (numRegArgs())) {
			callRegisterArgCogMethodatreceiver(_cogMethod, entryOffset(), _rcvr);
		}
	}
	{
		/* begin push: */
		_object = ((sqInt) _cogMethod ) + (entryOffset());
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
		GIV(stackPointer) = _sp;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _rcvr);
		GIV(stackPointer) = _sp2;
		/* end push: */
	}
	/* begin callEnilopmart: */
	ceCallCogCodePopReceiverReg();
	/* end callEnilopmart: */
	{
		assert(0);
	}
}
/*	Execute a CogMethod from an unlinked send. The receiver, 
	arguments and return address are on the Smalltalk stack. First 
	push the entry-point and finally the register argument(s). Then write 
	back the frame pointers and call the routine that will pop off the 
	register argument(s) and jump to the entry by executing a return 
	instruction.  
	In the simple jit only the receiver gets passed in registers, so only the 
	receiver gets pushed. */
/* CoInterpreter>>#executeCogMethod:fromUnlinkedSendWithReceiver: */
static void NoDbgRegParms
executeCogMethodfromUnlinkedSendWithReceiver(CogMethod *_cogMethod, sqInt _rcvr)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _object;
	char *_sp;
	char *_sp2;

	assertCStackWellAligned();
	assert(isMachineCodeFrame(GIV(framePointer)));
	assertValidExecutionPointersimbarline(unsignedLongAt(GIV(stackPointer)), GIV(framePointer), GIV(stackPointer), 0, __LINE__);
	{
		if (((_cogMethod->cmNumArgs)) <= (numRegArgs())) {
			callRegisterArgCogMethodatreceiver(_cogMethod, noCheckEntryOffset(), _rcvr);
		}
	}
	{
		/* begin push: */
		_object = ((sqInt) _cogMethod ) + (noCheckEntryOffset());
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
		GIV(stackPointer) = _sp;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _rcvr);
		GIV(stackPointer) = _sp2;
		/* end push: */
	}
	/* begin callEnilopmart: */
	ceCallCogCodePopReceiverReg();
	/* end callEnilopmart: */
	{
		assert(0);
	}
}
/*	Execute a closed PIC from a linked send, to redispatch based on the rcvr. 
	The receiver, arguments and return address are on the Smalltalk stack. 
	First push the entry-point and finally the register argument(s). Then 
	write back the frame pointers and call the routine that will pop off the 
	register argument(s) and jump to the entry by executing a return 
	instruction.  
	In the simple jit only the receiver gets passed in registers, so only the 
	receiver gets pushed. */
/* CoInterpreter>>#executeCogPIC:fromLinkedSendWithReceiver:andCacheTag: */
void
executeCogPICfromLinkedSendWithReceiverandCacheTag(CogMethod *_cogPIC, sqInt _rcvr, sqInt _cacheTag)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _object;
	char *_sp;
	char *_sp2;
	char *_sp3;
	char *_sp4;

	assertCStackWellAligned();
	assert(isMachineCodeFrame(GIV(framePointer)));
	assertValidExecutionPointersimbarline(unsignedLongAt(GIV(stackPointer)), GIV(framePointer), GIV(stackPointer), 0, __LINE__);
	/* begin push: */
	_object = ((sqInt) _cogPIC ) + (entryOffset());
	unsignedLongAtput((_sp4 = GIV(stackPointer) - BytesPerWord), _object);
	GIV(stackPointer) = _sp4;
	/* end push: */
	{
		if (((_cogPIC->cmNumArgs)) <= (numRegArgs())) {
			/* begin push: */
			unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _cacheTag);
			GIV(stackPointer) = _sp;
			/* end push: */
			switch ((_cogPIC->cmNumArgs)) {
				case 0:
				{
					/* begin callEnilopmart: */
					ceCall0ArgsPIC();
					/* end callEnilopmart: */
				}
				break;
				case 1:
				{
					/* begin callEnilopmart: */
					ceCall1ArgsPIC();
					/* end callEnilopmart: */
				}
				break;
				case 2:
				{
					/* begin callEnilopmart: */
					ceCall2ArgsPIC();
					/* end callEnilopmart: */
				}
				break;
				default:
				{
				}
			}
			error("not reached");
		}
	}
	{
		/* begin push: */
		unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _rcvr);
		GIV(stackPointer) = _sp2;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), _cacheTag);
		GIV(stackPointer) = _sp3;
		/* end push: */
	}
	/* begin callEnilopmart: */
	ceCallCogCodePopReceiverAndClassRegs();
	/* end callEnilopmart: */
	{
		assert(0);
	}
}
/*	Find the compiled method to be run when the current messageSelector is 
	sent to the given classTag, setting the values of newMethod and 
	primitiveIndex.  */
/* CoInterpreter>>#findNewMethodInClassTag: */
static void NoDbgRegParms
findNewMethodInClassTag(sqInt _classTagArg)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classTablePage;
	sqInt _classTag;
	CogMethod *_cogMethod;
	CogMethod *_cogMethod2;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;
	sqInt _methodHeader;
	sqInt _methodHeader2;
	sqInt _referent;
	sqInt _selector;
	sqInt _selector2;

	/* begin findNewMethodInClassTag:ifFound: */
	_classTag = _classTagArg;
	if (inlineLookupInMethodCacheSelclassTag(GIV(messageSelector), _classTag)) {
		{
			/* begin ifAppropriateCompileToNativeCode:selector: */
			_selector2 = GIV(messageSelector);
			/* begin fetchPointer:ofObject: */
			_methodHeader2 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if ((assert((((_methodHeader2 & 7) == 1)) || ((((usqInt) _methodHeader2 ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader2 ) >= (minCogMethodAddress())))), (_methodHeader2 & (smallIntegerTag())) == 0)) {
				_cogMethod2 = ((CogMethod *) _methodHeader2 );
				if (((_cogMethod2->selector)) == GIV(nilObj)) {
					setSelectorOfto(_cogMethod2, _selector2);
				}
			} else {
				if (((assert(((_methodHeader2 & 7) == 1)), (_methodHeader2 >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
					cogselector(GIV(newMethod), _selector2);
				}
 else {
					maybeFlagMethodAsInterpreted(GIV(newMethod));
				}
			}
			/* end ifAppropriateCompileToNativeCode:selector: */
		}
	} else {
		if ((((GIV(messageSelector) & (tagMask())) == 0) && (((long64At(GIV(messageSelector))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) || (_classTag == (isForwardedObjectClassIndexPun()))) {
			if (((GIV(messageSelector) & (tagMask())) == 0) && (((long64At(GIV(messageSelector))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				GIV(messageSelector) = handleForwardedSelectorFaultFor(GIV(messageSelector));
			}
			if (_classTag == (isForwardedObjectClassIndexPun())) {
				_classTag = handleForwardedSendFaultForTag(_classTag);
			}
			if (lookupInMethodCacheSelclassTag(GIV(messageSelector), _classTag)) {
				{
					/* begin ifAppropriateCompileToNativeCode:selector: */
					_selector = GIV(messageSelector);
					/* begin fetchPointer:ofObject: */
					_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if ((assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0)) {
						_cogMethod = ((CogMethod *) _methodHeader );
						if (((_cogMethod->selector)) == GIV(nilObj)) {
							setSelectorOfto(_cogMethod, _selector);
						}
					} else {
						if (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
							cogselector(GIV(newMethod), _selector);
						}
 else {
							maybeFlagMethodAsInterpreted(GIV(newMethod));
						}
					}
					/* end ifAppropriateCompileToNativeCode:selector: */
				}
				goto l7;
			}
		}
		/* begin classAtIndex: */
		assert((_classTag >= 0) && ((_classTag <= (tagMask())) || ((_classTag >= (arrayClassIndexPun())) && (_classTag <= (classIndexMask())))));
		/* begin fetchPointer:ofObject: */
		_fieldIndex2 = ((usqInt) _classTag ) >> (classTableMajorIndexShift());
		_classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (_classTablePage == GIV(nilObj)) {
			GIV(lkupClass) = null;
		} else {
			/* begin fetchPointer:ofObject: */
			_fieldIndex = _classTag & ((1U << (classTableMajorIndexShift())) - 1);
			GIV(lkupClass) = unsignedLongAt((_classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
		}
		/* end classAtIndex: */
		if (((GIV(lkupClass) & (tagMask())) == 0) && (((long64At(GIV(lkupClass))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin followForwarded: */
			assert(isUnambiguouslyForwarder(GIV(lkupClass)));
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((GIV(lkupClass) + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
			while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
			}
			GIV(lkupClass) = _referent;
			/* end followForwarded: */
		}
		lookupMethodInClass(GIV(lkupClass));
		addNewMethodToCache(GIV(lkupClass));
	}
	l7:
	;
	/* end findNewMethodInClassTag:ifFound: */
}
/*	methodObj is a CompiledMethod. If it contains an external primitive, 
	flush the function address and session ID of the CM. Answer the prim 
	index for the benefit of subclass overrides.methodObj is a CompiledMethod containing an external primitive. 
	Flush the function address and session ID of the CM. Override 
	to also flush the machine code call if one exists. */
/* CoInterpreter>>#flushExternalPrimitiveOf: */
void
flushExternalPrimitiveOf(sqInt _methodObj)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _firstBytecode;
	sqInt _header;
	sqInt _header2;
	sqInt _lit;
	sqInt _methodHeader;
	sqInt _primIdx;
	sqInt _primIdx2;

	{
		/* begin methodHeaderOf: */
		assert(isCompiledMethod(_methodObj));
		/* begin fetchPointer:ofObject: */
		_header2 = unsignedLongAt((_methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_header2 & 7) == 1)) {
			_header = _header2;
		} else {
			assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
			assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
			_header = ((((CogMethod *) _header2 ))->methodHeader);
		}
		/* end methodHeaderOf: */
		if (_header & AlternateHeaderHasPrimFlag) {
			_firstBytecode = (_methodObj + ((LiteralStart + ((_header >> 3) & AlternateHeaderNumLiteralsMask)) * BytesPerOop)) + BaseHeaderSize;
			_primIdx2 = (byteAt(_firstBytecode + 1)) + ((sqInt) (((usqInt) (byteAt(_firstBytecode + 2)) ) << 8) );
		} else {
			_primIdx2 = 0;
		}
		if ((_primIdx2 == PrimNumberExternalCall) && (((assert(((_header & 7) == 1)), (_header >> 3) & AlternateHeaderNumLiteralsMask)) > 0)) {
			/* begin fetchPointer:ofObject: */
			_lit = unsignedLongAt((_methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) (0 + LiteralStart) ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if ((((_lit & (tagMask())) == 0) && (((((usqInt) (longAt(_lit)) ) >> (formatShift())) & (formatMask())) == 2)) && ((numSlotsOf(_lit)) == 4)) {
				{
					{
						assert(!(isOopForwarded(_lit)));
						longAtput((_lit + BaseHeaderSize) + (2U << (shiftForWord())), ConstZero);
					}
					{
						assert(!(isOopForwarded(_lit)));
						longAtput((_lit + BaseHeaderSize) + (3U << (shiftForWord())), ConstZero);
					}
				}
			}
		}
		_primIdx = _primIdx2;
	}
	if ((_primIdx == PrimNumberExternalCall) && ((assert(isNonImmediate(_methodObj)), /* begin isCogMethodReference: */ /* begin rawHeaderOf: */ /* begin fetchPointer:ofObject: */ (_methodHeader = unsignedLongAt((_methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ))) /* end fetchPointer:ofObject: */ /* end rawHeaderOf: */, assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0 /* end isCogMethodReference: */))) {
		rewritePrimInvocationInto(cogMethodOf(_methodObj), primitiveExternalCall);
	}
}
/* CoInterpreter>>#followForwardedFieldsInCurrentMethod */
static void
followForwardedFieldsInCurrentMethod(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	CogMethod *_cogMethod;
	sqInt _methodField;

	if (isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) ))) {
		/* begin mframeHomeMethod: */
		_methodField = unsignedLongAt(GIV(framePointer) + FoxMethod);
		_cogMethod = ((CogMethod *) (_methodField & MFMethodMask) );
		/* end mframeHomeMethod: */
		followForwardedObjectFieldstoDepth((_cogMethod->methodObject), 0);
		followForwardedLiteralsIn(_cogMethod);
	} else {
		{
			followForwardedObjectFieldstoDepth(GIV(method), 0);
		}
	}
}
/*	Force an interrupt check ASAP. This version is the 
	entry-point to forceInterruptCheck for the heartbeat 
	timer to allow for repeatable debugging. */
/* CoInterpreter>>#forceInterruptCheckFromHeartbeat */
void
forceInterruptCheckFromHeartbeat(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (!suppressHeartbeatFlag) {
		/* begin checkForLongRunningPrimitive */
		if (GIV(longRunningPrimitiveCheckSemaphore) == null) {
			goto l2;
		}
		if ((GIV(longRunningPrimitiveStartUsecs) > 0) && ((GIV(longRunningPrimitiveCheckMethod) == GIV(newMethod)) && (GIV(longRunningPrimitiveCheckSequenceNumber) == GIV(statCheckForEvents)))) {
			GIV(longRunningPrimitiveStopUsecs) = ioUTCMicroseconds();
			assert(GIV(longRunningPrimitiveStopUsecs) > GIV(longRunningPrimitiveStartUsecs));
			goto l2;
		}
		if (GIV(longRunningPrimitiveStopUsecs) == 0) {
			GIV(longRunningPrimitiveCheckSequenceNumber) = GIV(statCheckForEvents);
			GIV(longRunningPrimitiveCheckMethod) = GIV(newMethod);
			GIV(longRunningPrimitiveStartUsecs) = ioUTCMicroseconds();
			sqLowLevelMFence();
		}
		l2:
		;
		/* end checkForLongRunningPrimitive */
		sqLowLevelMFence();
		if (GIV(deferSmash)) {
			GIV(deferredSmash) = 1;
			sqLowLevelMFence();
		} else {
			forceInterruptCheck();
		}
	}
}
/* CoInterpreter>>#frameHasContext: */
static sqInt NoDbgRegParms
frameHasContext(char *_theFP)
{
	return ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
		 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0);
}
/*	<Integer><Integer> */
/* CoInterpreter>>#frameIsBlockActivation: */
static sqInt NoDbgRegParms
frameIsBlockActivation(char *_theFP)
{
	return ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagIsBlockFlag) != 0
		 : (byteAt((_theFP + FoxIFrameFlags) + 3)) != 0);
}
/* CoInterpreter>>#frameMethodObject: */
static sqInt NoDbgRegParms
frameMethodObject(char *_theFP)
{
	return ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((mframeHomeMethod(_theFP))->methodObject)
		 : unsignedLongAt(_theFP + FoxMethod));
}
/*	See encodeFrameFieldHasContext:numArgs: */
/* CoInterpreter>>#frameNumArgs: */
static sqInt NoDbgRegParms
frameNumArgs(char *_theFP)
{
	return ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
		 : byteAt((_theFP + FoxIFrameFlags) + 1));
}
/* CoInterpreter>>#framePointerAddress */
usqInt
framePointerAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((usqInt) &GIV(framePointer) );
}
/* CoInterpreter>>#frameReceiver: */
static sqInt NoDbgRegParms
frameReceiver(char *_theFP)
{
	return ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? unsignedLongAt(_theFP + FoxMFReceiver)
		 : unsignedLongAt(_theFP + FoxIFReceiver));
}
/* CoInterpreter>>#functionPointerForCompiledMethod:primitiveIndex: */
void (*functionPointerForCompiledMethodprimitiveIndex(sqInt _methodObj, sqInt _primIndex))(void)

{
	static void *_function = (void *)-1;
	void (*_functionPointer)(void);
	void (*_functionPointer2)(void);
	sqInt _index;
	sqInt _lit;

	/* begin functionPointerFor: */
	_functionPointer = ((void (*)(void)) (((_primIndex > MaxPrimitiveIndex)
		 ? 0
		 : primitiveTable[_primIndex])) );
	/* end functionPointerFor: */
	if (_functionPointer == primitiveCalloutToFFI) {
		/* begin functionForPrimitiveCallout */
		if (((sqInt) _function ) == -1) {
			_function = ioLoadFunctionFrom("primitiveCallout", "SqueakFFIPrims");
		}
		return ((void (*)(void)) _function );
		/* end functionForPrimitiveCallout */
	}
	if (_functionPointer == primitiveExternalCall) {
		/* begin functionForPrimitiveExternalCall: */
		setPostCompileHook(recordCallOffsetIn);
		if (!((literalCountOfMethodHeader(methodHeaderOf(_methodObj))) > 0)) {
			return ((void (*)(void)) primitiveExternalCall );
		}
		/* begin fetchPointer:ofObject: */
		_lit = unsignedLongAt((_methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) (0 + LiteralStart) ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (!((((_lit & (tagMask())) == 0) && (((((usqInt) (longAt(_lit)) ) >> (formatShift())) & (formatMask())) == 2)) && ((lengthOfformat(_lit, (((usqInt) (longAt(_lit)) ) >> (formatShift())) & (formatMask()))) == 4))) {
			return ((void (*)(void)) primitiveExternalCall );
		}
		_index = unsignedLongAt((_lit + BaseHeaderSize) + (3U << (shiftForWord())));
		if (!((((_index & 7) == 1)) && ((((_index = _index >> 3)) > 0) && (_index <= MaxExternalPrimitiveTableSize)))) {
			return ((void (*)(void)) primitiveExternalCall );
		}
		_functionPointer2 = externalPrimitiveTable[_index - 1];
		if (_functionPointer2 == 0) {
			return ((void (*)(void)) primitiveExternalCall );
		}
		return _functionPointer2;
		/* end functionForPrimitiveExternalCall: */
	}
	return _functionPointer;
}
/* CoInterpreter>>#getCheckAllocFiller */
sqInt
getCheckAllocFiller(void)
{
	return checkAllocFiller;
}
/*	currentBytecode will be private to the main dispatch loop in the generated 
	code. This method allows the currentBytecode to be retrieved from global 
	variables. Override to answer -1 if we're not in an interpreter frame. */
/* CoInterpreter>>#getCurrentBytecode */
sqInt
getCurrentBytecode(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return (((((((usqInt) GIV(framePointer) ) & (BytesPerWord - 1)) == 0) && ((((usqInt) GIV(framePointer) ) >= ((usqInt) (GIV(stackBasePlus1) - 1) )) && (((usqInt) GIV(framePointer) ) <= ((usqInt) GIV(pages) )))) && (!(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))))
		 ? byteAt(GIV(instructionPointer))
		 : -1);
}
/*	Handle a send fault that may be due to a send to a forwarded object. 
	Unforward the receiver on the stack and answer it. */
/* CoInterpreter>>#handleForwardedSendFaultForReceiver:rcvrStackOffsetFromTop: */
static sqInt NoDbgRegParms
handleForwardedSendFaultForReceiverrcvrStackOffsetFromTop(sqInt _forwardedReceiver, sqInt _rcvrStackIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _rcvr;
	sqInt _referent;

	assert(isOopForwarded(_forwardedReceiver));
	assert((stackValue(_rcvrStackIndex)) == _forwardedReceiver);
	/* begin followForwarded: */
	assert(isUnambiguouslyForwarder(_forwardedReceiver));
	/* begin fetchPointer:ofMaybeForwardedObject: */
	_referent = unsignedLongAt((_forwardedReceiver + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofMaybeForwardedObject: */
	while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
	}
	_rcvr = _referent;
	/* end followForwarded: */
	unsignedLongAtput(GIV(stackPointer) + (_rcvrStackIndex * BytesPerWord), _rcvr);
	followForwardedFrameContentsstackPointer(GIV(framePointer), GIV(stackPointer) + ((_rcvrStackIndex + 1) * BytesPerWord));
	if (isPointers(((isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))
		 ? unsignedLongAt(GIV(framePointer) + FoxMFReceiver)
		 : unsignedLongAt(GIV(framePointer) + FoxIFReceiver)))) {
		followForwardedObjectFieldstoDepth(((isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))
			 ? unsignedLongAt(GIV(framePointer) + FoxMFReceiver)
			 : unsignedLongAt(GIV(framePointer) + FoxIFReceiver)), 0);
	}
	followForwardedFieldsInCurrentMethod();
	return _rcvr;
}
/*	A message send from either an open PIC or an unlinked send has not been 
	understood. Create a message and execute the relevant resulting MNU 
	method. messageSelector is an implicit argument (yuck). */
/* CoInterpreter>>#handleMNU:InMachineCodeTo:classForMessage: */
static sqInt NoDbgRegParms
handleMNUInMachineCodeToclassForMessage(sqInt _selectorIndex, sqInt _rcvr, sqInt _classForMessage)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classForThisMessage;
	CogMethod *_cogMethod;
	sqInt _err;
	sqInt _errSelIdx;
	sqInt _hash;
	sqInt _methodHeader;
	sqInt _selector;
	char *_sp;
	char *_sp2;
	sqInt _top;

	assert(addressCouldBeOop(_rcvr));
	/* begin popStack */
	_top = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	GIV(instructionPointer) = _top;
	/* end popStack */
	createActualMessageTo(_classForMessage);
	/* begin fetchPointer:ofObject: */
	GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) _selectorIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (lookupInMethodCacheSelclassTag(GIV(messageSelector), (assert(addressCouldBeClassObj(GIV(lkupClass))), ((((_hash = (uint32AtPointer(GIV(lkupClass) + 4)) & (identityHashHalfWordMask()))) != 0)
		 ? _hash
		 : ((objCouldBeClassObj(GIV(lkupClass)))
			 ? ((((_err = enterIntoClassTable(GIV(lkupClass)))) != 0)
				 ? -_err
				 : (uint32AtPointer(GIV(lkupClass) + 4)) & (identityHashHalfWordMask()))
			 : -PrimErrBadReceiver))))) {
		/* begin ifAppropriateCompileToNativeCode:selector: */
		_selector = GIV(messageSelector);
		/* begin fetchPointer:ofObject: */
		_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if ((assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0)) {
			_cogMethod = ((CogMethod *) _methodHeader );
			if (((_cogMethod->selector)) == GIV(nilObj)) {
				setSelectorOfto(_cogMethod, _selector);
			}
		} else {
			if (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
				cogselector(GIV(newMethod), _selector);
			}
 else {
				maybeFlagMethodAsInterpreted(GIV(newMethod));
			}
		}
		/* end ifAppropriateCompileToNativeCode:selector: */
	} else {
		_errSelIdx = lookupMethodWithoutMNUProcessingInClass((_classForThisMessage = GIV(lkupClass)));
		if (_errSelIdx != 0) {
			if (_selectorIndex == SelectorDoesNotUnderstand) {
				error("Recursive not understood error encountered");
			}
			/* begin push: */
			unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
			GIV(stackPointer) = _sp;
			/* end push: */
			return handleMNUInMachineCodeToclassForMessage(_errSelIdx, _rcvr, _classForThisMessage);
		}
	}
	if (((GIV(newMethod) & (tagMask())) == 0) && ((((((usqInt) (longAt(GIV(newMethod))) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && (isCogMethodReference(rawHeaderOf(GIV(newMethod)))))) {
		/* begin push: */
		unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
		GIV(stackPointer) = _sp2;
		/* end push: */
		executeCogMethodfromUnlinkedSendWithReceiver(cogMethodOf(GIV(newMethod)), _rcvr);
		{
			assert(0);
		}
	}
	interpretMethodFromMachineCode();
	return (assert(0), null);
}
/*	This is for low-level error reporting. If either of the C stack pointers 
	are pointing into the stack zone then write them back to framePointer 
	and/or stackPointer so that the stack backtrace will be up to date. Write 
	their original values through savedFPP & savedSPP if non-null. */
/* CoInterpreter>>#ifValidWriteBackStack:Pointers:Save:To: */
void
ifValidWriteBackStackPointersSaveTo(void *_theCFP, void *_theCSP, char **_savedFPP, char **_savedSPP)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (_savedFPP != 0) {
		_savedFPP[0] = GIV(framePointer);
	}
	if (_savedSPP != 0) {
		_savedSPP[0] = GIV(stackPointer);
	}
	if (((((usqInt) _theCFP ) & (BytesPerWord - 1)) == 0) && ((((usqInt) _theCFP ) >= ((usqInt) (GIV(stackBasePlus1) - 1) )) && (((usqInt) _theCFP ) <= ((usqInt) GIV(pages) )))) {
		GIV(framePointer) = _theCFP;
	}
	if (((((usqInt) _theCSP ) & (BytesPerWord - 1)) == 0) && ((((usqInt) _theCSP ) >= ((usqInt) (GIV(stackBasePlus1) - 1) )) && (((usqInt) _theCSP ) <= ((usqInt) GIV(pages) )))) {
		GIV(stackPointer) = _theCSP;
	}
}
/* CoInterpreter>>#instructionPointerAddress */
usqInt
instructionPointerAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((usqInt) &GIV(instructionPointer) );
}
/*	Fetch an instance variable from a maybe married context. 
	If the context is still married compute the value of the 
	relevant inst var from the spouse frame's state. 
	 
	If the context is single but has a negative instruction pointer 
	recognise that the instruction pointer is actually into machine 
	code and convert it to the corresponding bytecode pc. */
/* CoInterpreter>>#instVar:ofContext: */
static sqInt NoDbgRegParms
instVarofContext(sqInt _offset, sqInt _aContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_theSP;
	sqInt _value;

	assert(isContext(_aContext));
	assert(_offset <= (ReceiverIndex + (checkStackPointerForMaybeMarriedContext(_aContext))));
	if (!(_offset <= StackPointerIndex)) {
		return unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) _offset ) << (shiftForWord())) ));
	}
	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	_theSP = GIV(stackPointer);
	assert(_theSP < GIV(framePointer));
	assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(GIV(stackPage)->headFP = GIV(framePointer));
		(GIV(stackPage)->headSP = _theSP);
	}
	/* end setHeadFP:andSP:inPage: */
	assert(pageListIsWellFormed());
	/* end writeBackHeadFramePointers */
	if (((((unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_aContext)))) {
		return fetchPointerofMarriedContext(_offset, _aContext);
	}
	_value = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) _offset ) << (shiftForWord())) ));
	if ((_offset == InstructionPointerIndex) && ((((_value & 7) == 1)) && (((int) _value ) < 0))) {
		return mustMapMachineCodePCcontext(_value >> 3, _aContext);
	}
	return _value;
}
/*	This is used for asserts that check that inline cache editing results in 
	valid addresses. 
	In the C VM interpret is presumed to come before any primitives and so it 
	constitutes the lowest address in C code that machine code should be 
	linked. In the simulator 
	we just answer something not low. */
/* CoInterpreter>>#interpretAddress */
usqInt
interpretAddress(void)
{
	return ((usqInt) &interpret );
}
/*	At a rough approximation we may need to allocate up to a couple 
	of page's worth of contexts when switching stack pages, assigning 
	to senders, etc. But the snapshot primitive voids all stack pages. 
	So a safe margin is the size of a large context times the maximum 
	number of frames per page times the number of pages. */
/* CoInterpreter>>#interpreterAllocationReserveBytes */
static sqInt NeverInline
interpreterAllocationReserveBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _maxFramesPerPage;
	sqInt _maxUsedBytesPerPage;

	_maxUsedBytesPerPage = GIV(desiredStackPageBytes) + ((IFrameSlots + 64) * BytesPerWord);
	_maxFramesPerPage = (_maxUsedBytesPerPage / BytesPerWord) / MFrameSlots;
	return ((_maxFramesPerPage * LargeContextSlots) * BytesPerOop) * GIV(numStackPages);
}
/*	Execute a method interpretively from machine code. We assume (require) 
	that newMethod 
	messageSelector, primitiveFunctionPointer and argumentCount have been set 
	in the caller. 
	Once evaluated either continue in the interpreter via a jongjmp or in 
	machine code via an 
	enilopmart (a form of longjmp - a stinking rose by any other name). */
/* CoInterpreter>>#interpretMethodFromMachineCode */
static void
interpretMethodFromMachineCode(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _nArgs;
	char *_savedFramePointer;
	char *_savedStackPointer;
	sqInt _succeeded;

	_nArgs = 0;
	_savedFramePointer = ((char *) 0 );
	_savedStackPointer = ((char *) 0 );
	assertCStackWellAligned();
	assert(validInstructionPointerinFrame(GIV(instructionPointer), GIV(framePointer)));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	(GIV(stackPage)->headFP = GIV(framePointer));
	/* begin executePrimitiveFromInterpreter:ifFail: */
	if (primitiveFunctionPointer != 0) {
		if (((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex) {
			executeQuickPrimitive();
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), 0);
			/* end returnToExecutive: */
			goto l4;
		}
		/* begin slowPrimitiveResponse */
		if (recordPrimTrace()) {
			/* begin fastLogPrim: */
			GIV(primTraceLog)[GIV(primTraceLogIndex)] = GIV(messageSelector);
			primTraceLogIndex(GIV(primTraceLogIndex) + 1);
			/* end fastLogPrim: */
		}
		assert((remapBufferCount()) == 0);
		{
			_nArgs = GIV(argumentCount);
			_savedStackPointer = GIV(stackPointer);
			_savedFramePointer = GIV(framePointer);
		}
		/* begin initPrimCall */
		GIV(primFailCode) = 0;
		/* end initPrimCall */
		/* begin dispatchFunctionPointer: */
		primitiveFunctionPointer();
		/* end dispatchFunctionPointer: */
		assert(maybeLeakCheckExternalPrimCall(GIV(newMethod)));
		/* begin maybeRetryPrimitiveOnFailure */
		if (GIV(primFailCode)) {
			retryPrimitiveOnFailure();
		}
		/* end maybeRetryPrimitiveOnFailure */
		/* begin maybeFailForLastObjectOverwrite */
		if (checkAllocFiller) {
			if (((freeStart0()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart0())) != (freeStart0()))) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrWritePastObject;
				/* end primitiveFailFor: */
			}
		}
		/* end maybeFailForLastObjectOverwrite */
		if (!GIV(primFailCode) && ((GIV(framePointer) == _savedFramePointer) && (!(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))))) {
			if (GIV(stackPointer) != (_savedStackPointer + (_nArgs * BytesPerWord))) {
				flag("Would be nice to make this a message send of e.g. unbalancedPrimitive to the current process or context");
				failUnbalancedPrimitive();
				GIV(stackPointer) = _savedStackPointer;
			}
		}
		if (GIV(nextProfileTick) > 0) {
			checkProfileTick(GIV(newMethod));
		}
		_succeeded = !GIV(primFailCode);
		goto l3;
		l3:
		;
		/* end slowPrimitiveResponse */
		if (_succeeded) {
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), 0);
			/* end returnToExecutive: */
			goto l4;
		}
	}
	{
		activateNewMethod();
		siglongjmp(reenterInterpreter, ReturnToInterpreter);
		{
			assert(0);
		}
	}
	l4:
	;
	/* end executePrimitiveFromInterpreter:ifFail: */
}
/* CoInterpreter>>#isCogMethodReference: */
sqInt
isCogMethodReference(sqInt _methodHeader)
{
	assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress()))));
	return (_methodHeader & (smallIntegerTag())) == 0;
}
/* CoInterpreter>>#isInstructionPointerInInterpreter: */
static sqInt NoDbgRegParms
isInstructionPointerInInterpreter(sqInt _anIP)
{
	return !(((usqInt) ((usqInt) _anIP ) ) < (startOfObjectMemory(getMemoryMap())));
}
/* CoInterpreter>>#isMachineCodeFrame: */
static sqInt NoDbgRegParms
isMachineCodeFrame(char *_theFP)
{
	sqInt _anInstrPointer;

	/* begin isMachineCodeIP: */
	_anInstrPointer = ((usqInt) (unsignedLongAt(_theFP + FoxMethod)) );
	return ((usqInt) _anInstrPointer ) < (startOfObjectMemory(getMemoryMap()));
	/* end isMachineCodeIP: */
}
/* CoInterpreter>>#isMachineCodeIP: */
static sqInt NoDbgRegParms
isMachineCodeIP(sqInt _anInstrPointer)
{
	return ((usqInt) _anInstrPointer ) < (startOfObjectMemory(getMemoryMap()));
}
/*	Lookup selector in rcvr, without doing MNU processing, and answer either a 
	method or an error code if the message was not understood. Used to 
	populate closed PICs. */
/* CoInterpreter>>#lookupMethodWithoutMNUProcessingForSelector:receiver: */
sqInt
lookupMethodWithoutMNUProcessingForSelectorreceiver(sqInt _selector, sqInt _rcvr)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classTag;
	sqInt _erridx;
	sqInt _tagBits;

	if (((_tagBits = _rcvr & (tagMask()))) != 0) {
		_classTag = _tagBits;
	} else {
		/* begin classIndexOf: */
		_classTag = (longAt(_rcvr)) & (classIndexMask());
		/* end classIndexOf: */
	}
	if (!(lookupInMethodCacheSelclassTag(_selector, _classTag))) {
		GIV(messageSelector) = _selector;
		_erridx = lookupMethodWithoutMNUProcessingInClass(classAtIndex(_classTag));
		if (_erridx != 0) {
			assert(_erridx <= (maxLookupNoMNUErrorCode()));
			return _erridx;
		}
	}
	return GIV(newMethod);
}
/*	The prim trace log is a circular buffer of selectors. If there is 
	an entry at primTraceLogIndex - 1 \\ PrimTraceBufferSize it has entries. 
	If there is something at primTraceLogIndex it has wrapped. */
/* CoInterpreter>>#mapPrimTraceLog */
static void
mapPrimTraceLog(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _remainder;
	sqInt _selector;

	if ((GIV(primTraceLog)[((((_remainder = (GIV(primTraceLogIndex) - 1) % PrimTraceLogSize)) < 0)
		 ? _remainder + PrimTraceLogSize
		 : _remainder)]) == 0) {
		return;
	}
	if ((GIV(primTraceLog)[GIV(primTraceLogIndex)]) != 0) {
		for (_i = GIV(primTraceLogIndex); _i < PrimTraceLogSize; _i += 1) {
			_selector = GIV(primTraceLog)[_i];
			if ((_selector != 0) && (((_selector & (tagMask())) == 0) && (shouldRemapObj(_selector)))) {
				GIV(primTraceLog)[_i] = remapObj(_selector);
			}
		}
	}
	for (_i = 0; _i < GIV(primTraceLogIndex); _i += 1) {
		_selector = GIV(primTraceLog)[_i];
		if ((_selector != 0) && (((_selector & (tagMask())) == 0) && (shouldRemapObj(_selector)))) {
			GIV(primTraceLog)[_i] = remapObj(_selector);
		}
	}
}
/*	The trace log is a circular buffer of pairs of entries. If there is 
	an entry at traceLogIndex - 3 \\ TraceBufferSize it has entries. 
	If there is something at traceLogIndex it has wrapped. */
/* CoInterpreter>>#mapTraceLog */
static void
mapTraceLog(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _intOrClass;
	sqInt _limit;
	sqInt _remainder;
	sqInt _selectorOrMethod;

	_limit = ((((_remainder = (GIV(traceLogIndex) - 3) % TraceBufferSize)) < 0)
		 ? _remainder + TraceBufferSize
		 : _remainder);
	if ((GIV(traceLog)[_limit]) == 0) {
		return;
	}
	if ((GIV(traceLog)[GIV(traceLogIndex)]) != 0) {
		_limit = TraceBufferSize - 3;
	}
	for (_i = 0; _i <= _limit; _i += 3) {
		_intOrClass = GIV(traceLog)[_i];
		if (((_intOrClass & (tagMask())) == 0) && (shouldRemapObj(_intOrClass))) {
			GIV(traceLog)[_i] = remapObj(_intOrClass);
		}
		_selectorOrMethod = GIV(traceLog)[_i + 1];
		if (((_selectorOrMethod & (tagMask())) == 0) && (shouldRemapObj(_selectorOrMethod))) {
			GIV(traceLog)[_i + 1] = remapObj(_selectorOrMethod);
		}
	}
}
/* CoInterpreter>>#markActiveMethodsAndReferents */
void
markActiveMethodsAndReferents(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	StackPage *_thePage2;

	/* begin usedStackPagesDo: */
	/* begin allStackPagesDo: */
	for (_i = 0; _i < GIV(numStackPages); _i += 1) {
		/* begin stackPageAt: */
		_thePage2 = stackPageAtpages(_i, GIV(pages));
		/* end stackPageAt: */
		{
			if (!(((_thePage2->baseFP)) == 0)) {
				{
					markCogMethodsAndReferentsOnPage(_thePage2);
				}
			}
		}
	}
	/* end allStackPagesDo: */
	/* end usedStackPagesDo: */
}
/*	The prim trace log is a circular buffer of selectors. If there is 
	an entry at primTraceLogIndex - 1 \\ PrimTraceBufferSize it has entries. 
	If there is something at primTraceLogIndex it has wrapped. */
/* CoInterpreter>>#markAndTracePrimTraceLog */
static void
markAndTracePrimTraceLog(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _remainder;
	sqInt _selector;

	if ((GIV(primTraceLog)[((((_remainder = (GIV(primTraceLogIndex) - 1) % PrimTraceLogSize)) < 0)
		 ? _remainder + PrimTraceLogSize
		 : _remainder)]) == 0) {
		return;
	}
	if ((GIV(primTraceLog)[GIV(primTraceLogIndex)]) != 0) {
		for (_i = GIV(primTraceLogIndex); _i < PrimTraceLogSize; _i += 1) {
			_selector = GIV(primTraceLog)[_i];
			if ((_selector != 0) && ((_selector & (tagMask())) == 0)) {
				markAndTrace(_selector);
			}
		}
	}
	for (_i = 0; _i < GIV(primTraceLogIndex); _i += 1) {
		_selector = GIV(primTraceLog)[_i];
		if ((_selector != 0) && ((_selector & (tagMask())) == 0)) {
			markAndTrace(_selector);
		}
	}
}
/*	The trace log is a circular buffer of pairs of entries. If there is an 
	entry at 
	traceLogIndex - 3 \\ TraceBufferSize it has entries. If there is something 
	at traceLogIndex it has wrapped. */
/* CoInterpreter>>#markAndTraceTraceLog */
static void
markAndTraceTraceLog(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _limit;
	sqInt _oop;
	sqInt _remainder;

	_limit = ((((_remainder = (GIV(traceLogIndex) - 3) % TraceBufferSize)) < 0)
		 ? _remainder + TraceBufferSize
		 : _remainder);
	if ((GIV(traceLog)[_limit]) == 0) {
		return;
	}
	if ((GIV(traceLog)[GIV(traceLogIndex)]) != 0) {
		_limit = TraceBufferSize - 3;
	}
	for (_i = 0; _i <= _limit; _i += 3) {
		_oop = GIV(traceLog)[_i];
		if (!(_oop & (tagMask()))) {
			markAndTrace(_oop);
		}
		_oop = GIV(traceLog)[_i + 1];
		if (!(_oop & (tagMask()))) {
			markAndTrace(_oop);
		}
	}
}
/* CoInterpreter>>#markCogMethodsAndReferentsOnPage: */
static void NoDbgRegParms
markCogMethodsAndReferentsOnPage(StackPage *_thePage)
{
	char *_callerFP;
	char *_theFP;

	assert(!(isFree(_thePage)));
	assert(ifCurrentStackPageHasValidHeadPointers(_thePage));
	_theFP = (_thePage->headFP);
	while (1) {
		if (isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) ))) {
			markMethodAndReferents(((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ));
		}
		if (!(((_callerFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP)))) != 0)) 
			break;
		_theFP = _callerFP;
	}
}
/*	Answer whether marryFrame:SP: copies non-argument temporaries. */
/* CoInterpreter>>#marryFrameCopiesTemps */
sqInt
marryFrameCopiesTemps(void)
{
	return 0;
}
/* CoInterpreter>>#maxLookupNoMNUErrorCode */
sqInt
maxLookupNoMNUErrorCode(void)
{
	return ((SelectorCannotInterpret < SelectorDoesNotUnderstand) ? SelectorDoesNotUnderstand : SelectorCannotInterpret);
}
/*	The flag bit can be used to flag methods that are interpreted, if it has 
	been requested 
	from the image header flags. */
/* CoInterpreter>>#maybeFlagMethodAsInterpreted: */
static void NoDbgRegParms
maybeFlagMethodAsInterpreted(sqInt _aMethod)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _rawHeader;
	sqInt _realHeader;

	if (GIV(flagInterpretedMethods)) {
		/* begin fetchPointer:ofObject: */
		_rawHeader = unsignedLongAt((_aMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		_realHeader = (((assert((((_rawHeader & 7) == 1)) || ((((usqInt) _rawHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _rawHeader ) >= (minCogMethodAddress())))), (_rawHeader & (smallIntegerTag())) == 0))
			 ? ((((CogMethod *) _rawHeader ))->methodHeader)
			 : _rawHeader);
		_realHeader = _realHeader | (((((usqInt) (1U << MethodHeaderFlagBitPosition) ) << 3) | 1));
		if ((assert((((_rawHeader & 7) == 1)) || ((((usqInt) _rawHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _rawHeader ) >= (minCogMethodAddress())))), (_rawHeader & (smallIntegerTag())) == 0)) {
			((((CogMethod *) _rawHeader ))->methodHeader = _realHeader);
		} else {
			{
				assert(!(isOopForwarded(_aMethod)));
				longAtput((_aMethod + BaseHeaderSize) + (0U << (shiftForWord())), _realHeader);
			}
		}
	}
}
/* CoInterpreter>>#maybeMethodHasCogMethod: */
static sqInt NoDbgRegParms
maybeMethodHasCogMethod(sqInt _anOop)
{
	return ((_anOop & (tagMask())) == 0) && ((((((usqInt) (longAt(_anOop)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && (isCogMethodReference(unsignedLongAt((_anOop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) )))));
}
/* CoInterpreter>>#mcprimFunctionForPrimitiveIndex: */
sqInt
mcprimFunctionForPrimitiveIndex(sqInt _primIndex)
{
	if (_primIndex == PrimNumberHashMultiply) {
		return mcprimHashMultiply;
	}
	error("unknown mcprim");
	return null;
}
/* CoInterpreter>>#methodCacheAddress */
void *
methodCacheAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(methodCache);
}
/* CoInterpreter>>#methodHasCogMethod: */
sqInt
methodHasCogMethod(sqInt _aMethodOop)
{
	sqInt _methodHeader;

	assert(isNonImmediate(_aMethodOop));
	/* begin isCogMethodReference: */
	_methodHeader = unsignedLongAt((_aMethodOop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress()))));
	return (_methodHeader & (smallIntegerTag())) == 0;
	/* end isCogMethodReference: */
}
/* CoInterpreter>>#methodNeedsLargeContext: */
sqInt
methodNeedsLargeContext(sqInt _methodObj)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _header;
	sqInt _methodHeader;

	/* begin methodHeaderIndicatesLargeFrame: */
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_methodObj));
	/* begin fetchPointer:ofObject: */
	_header = unsignedLongAt((_methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header & 7) == 1)) {
		_methodHeader = _header;
	} else {
		assert(((usqInt) _header ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_methodHeader = ((((CogMethod *) _header ))->methodHeader);
	}
	/* end methodHeaderOf: */
	return (_methodHeader & LargeContextBit) != 0;
	/* end methodHeaderIndicatesLargeFrame: */
}
/* CoInterpreter>>#methodShouldBeCogged: */
sqInt
methodShouldBeCogged(sqInt _aMethodObj)
{
	if (methodWithHeaderShouldBeCogged(methodHeaderOf(_aMethodObj))) {
		return 1;
	}
	maybeFlagMethodAsInterpreted(_aMethodObj);
	return 0;
}
/*	At the moment jit any method with less than N literals, where N defaults 
	to 60. 
	See e.g. SimpleStackBasedCogit class>>initialize. 
	In my dev image eem 2/22/2009 13:39 
	(30 to: 100 by: 5) collect: 
	[:n| n -> (SystemNavigation default allSelect: [:m| m numLiterals > n]) 
	size] #(30->1681 35->1150 40->765 45->523 50->389 55->289 60->206 
	65->151 70->124 75->99 80->73 85->63 90->54 95->42 100->38). 
	And running the CogVMSimulator with flagging of interpreted methods turned 
	on reveals 
	the following sizes of interpreted methods. 
	| sizes | 
	sizes := Bag new. 
	SystemNavigation default allSelect: [:m| m flag ifTrue: [sizes add: m 
	numLiterals]. false]. 
	sizes sortedElements asArray 
	#(	40->4 41->1 42->2 44->1 45->3 46->1 47->2 48->1 
	50->2 51->1 53->1 55->1 56->1 
	87->1 108->1 171->1) 
	literalCountOfHeader: does not include the header word. */
/* CoInterpreter>>#methodWithHeaderShouldBeCogged: */
static sqInt NoDbgRegParms
methodWithHeaderShouldBeCogged(sqInt _methodHeader)
{
	return ((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile;
}
/* CoInterpreter>>#mframeHomeMethodExport */
CogMethod *
mframeHomeMethodExport(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _methodField;

	/* begin mframeHomeMethod: */
	_methodField = unsignedLongAt(GIV(framePointer) + FoxMethod);
	return ((CogMethod *) (_methodField & MFMethodMask) );
	/* end mframeHomeMethod: */
}
/*	Answer the home method for a machine code frame. From a block frame we 
	find the home method through the block's homeOffset field which is the 
	delta to it. 
	In both cases we need to strip the isBlock and isContext flags from the 
	method field. */
/* CoInterpreter>>#mframeHomeMethod: */
CogMethod *
mframeHomeMethod(char *_theFP)
{
	sqInt _methodField;

	_methodField = unsignedLongAt(_theFP + FoxMethod);
	return ((CogMethod *) (_methodField & MFMethodMask) );
}
/*	<Integer> */
/* CoInterpreter>>#mframeIsBlockActivation: */
static sqInt NoDbgRegParms
mframeIsBlockActivation(char *_theFP)
{
	return ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagIsBlockFlag) != 0;
}
/* CoInterpreter>>#mframeReceiver: */
static sqInt NoDbgRegParms
mframeReceiver(char *_theFP)
{
	return unsignedLongAt(_theFP + FoxMFReceiver);
}
/*	Traverse all stack pages looking for non-zero bytes in the headroom part 
	of each page. 
	Answer the minimum size of unused headroom (zero bytes) in the pages. This 
	is for 
	checking that there is enough headroom allocated in stack pages. */
/* CoInterpreter>>#minimumUnusedHeadroom */
static sqInt
minimumUnusedHeadroom(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _minUnused;
	char *_p;
	StackPage *_thePage;
	int _unused;

	_minUnused = (((stackPageAt(0))->baseAddress)) - (((stackPageAt(0))->lastAddress));
	/* begin allStackPagesDo: */
	for (_i = 0; _i < GIV(numStackPages); _i += 1) {
		/* begin stackPageAt: */
		_thePage = stackPageAtpages(_i, GIV(pages));
		/* end stackPageAt: */
		{
			_p = (_thePage->lastAddress);
			do {
				_p += BytesPerWord;
			} while (((longAtPointer(_p)) == 0) && (_p <= ((_thePage->baseAddress))));
			_unused = (_p - BytesPerWord) - ((_thePage->lastAddress));
			if (_unused < _minUnused) {
				_minUnused = _unused;
			}
		}
	}
	/* end allStackPagesDo: */
	return _minUnused;
}
/* CoInterpreter>>#mMethodClass */
sqInt
mMethodClass(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _literal;
	sqInt _methodPointer;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _offset;

	/* begin methodClassOf: */
	_methodPointer = ((mframeHomeMethod(GIV(framePointer)))->methodObject);
	/* begin followLiteral:ofMethod: */
	_offset = (literalCountOfMethodHeader(methodHeaderOf(_methodPointer))) - 1;
	/* begin followField:ofObject: */
	/* begin fetchPointer:ofObject: */
	_objOop2 = unsignedLongAt((_methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset + LiteralStart) ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_objOop2 & (tagMask())) == 0) && (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		_objOop2 = fixFollowedFieldofObjectwithInitialValue(_offset + LiteralStart, _methodPointer, _objOop2);
	}
	_literal = _objOop2;
	/* end followField:ofObject: */
	/* end followLiteral:ofMethod: */
	return (((_literal != GIV(nilObj)) && (((_literal & (tagMask())) == 0) && (((((usqInt) (longAt(_literal)) ) >> (formatShift())) & (formatMask())) <= 5)))
		 ? (assert((numSlotsOf(_literal)) > ValueIndex), /* begin followField:ofObject: */ /* begin fetchPointer:ofObject: */ (_objOop = unsignedLongAt((_literal + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ))) /* end fetchPointer:ofObject: */, ((((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))
			 ? (_objOop = fixFollowedFieldofObjectwithInitialValue(ValueIndex, _literal, _objOop))
			 : 0), _objOop /* end followField:ofObject: */)
		 : (/* begin nilObject */ GIV(nilObj) /* end nilObject */));
	/* end methodClassOf: */
}
/* CoInterpreter>>#mnuCompilationBreakpointFor: */
void
mnuCompilationBreakpointFor(sqInt selectorOop)
{
	suppressHeartbeatFlag = 1;
	warning("compilation MNU break (heartbeat suppressed)");
}
/*	Lookup the doesNotUnderstand: selector in the class of the argument rcvr. 
	Answer either the matching method (cogged if appropriate), or nil, if not 
	found.  */
/* CoInterpreter>>#mnuMethodOrNilFor: */
static sqInt NoDbgRegParms
mnuMethodOrNilFor(sqInt _rcvr)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _currentClass;
	sqInt _dictionary;
	sqInt _index;
	usqInt _length;
	sqInt _mask;
	sqInt _methodArray;
	sqInt _methodHeader;
	sqInt _mnuMethod;
	sqInt _mnuSelector;
	sqInt _nextSelector;
	usqInt _numSlots;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _objOop3;
	sqInt _tagBits;
	int _wrapAround;

	assert(!(isOopForwarded(_rcvr)));
	if (((_tagBits = _rcvr & (tagMask()))) != 0) {
		/* begin fetchPointer:ofObject: */
		_currentClass = unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
	} else {
		_currentClass = fetchClassOfNonImm(_rcvr);
	}
	/* begin fetchPointer:ofObject: */
	_mnuSelector = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorDoesNotUnderstand ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	while (_currentClass != GIV(nilObj)) {
		_dictionary = unsignedLongAt((_currentClass + BaseHeaderSize) + ((sqInt) (((usqInt) MethodDictionaryIndex ) << (shiftForWord())) ));
		if (_dictionary == GIV(nilObj)) {
			return null;
		}
		/* begin lookupMethodFor:InDictionary: */
		/* begin numSlotsOf: */
		assert((classIndexOf(_dictionary)) > (isForwardedObjectClassIndexPun()));
		_numSlots = byteAt(_dictionary + 7);
		_length = ((_numSlots == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_dictionary - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots);
		/* end numSlotsOf: */
		_mask = (_length - SelectorStart) - 1;
		_index = SelectorStart + (_mask & (((_mnuSelector & (tagMask()))
			 ? _mnuSelector >> 3
			 : (uint32AtPointer(_mnuSelector + 4)) & (identityHashHalfWordMask()))));
		_wrapAround = 0;
		while (1) {
			/* begin fetchPointer:ofObject: */
			_nextSelector = unsignedLongAt((_dictionary + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (_nextSelector == GIV(nilObj)) {
				_mnuMethod = null;
				goto l10;
			}
			if (((_nextSelector & (tagMask())) == 0) && (((long64At(_nextSelector)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				_nextSelector = fixFollowedFieldofObjectwithInitialValue(_index + SelectorStart, _dictionary, _nextSelector);
			}
			if (_nextSelector == _mnuSelector) {
				/* begin followObjField:ofObject: */
				/* begin fetchPointer:ofObject: */
				_objOop = unsignedLongAt((_dictionary + BaseHeaderSize) + ((sqInt) (((usqInt) MethodArrayIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				assert(isNonImmediate(_objOop));
				if (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					_objOop = fixFollowedFieldofObjectwithInitialValue(MethodArrayIndex, _dictionary, _objOop);
				}
				_methodArray = _objOop;
				/* end followObjField:ofObject: */
				/* begin followField:ofObject: */
				/* begin fetchPointer:ofObject: */
				_objOop2 = unsignedLongAt((_methodArray + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - SelectorStart) ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_objOop2 & (tagMask())) == 0) && (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					_objOop2 = fixFollowedFieldofObjectwithInitialValue(_index - SelectorStart, _methodArray, _objOop2);
				}
				_mnuMethod = _objOop2;
				goto l10;
				/* end followField:ofObject: */
			}
			_index += 1;
			if (_index == _length) {
				if (_wrapAround) {
					_mnuMethod = null;
					goto l10;
				}
				_wrapAround = 1;
				_index = SelectorStart;
			}
		}
		_mnuMethod = null;
		l10:
		;
		/* end lookupMethodFor:InDictionary: */
		if (_mnuMethod) {
			if ((!(_mnuMethod & (tagMask()))) && (((((usqInt) (longAt(_mnuMethod)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()))) {
				/* begin fetchPointer:ofObject: */
				_methodHeader = unsignedLongAt((_mnuMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if ((!((assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0))) && (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile)) {
					cogselector(_mnuMethod, _mnuSelector);
				}
			}
			return _mnuMethod;
		}
		/* begin followField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop3 = unsignedLongAt((_currentClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_objOop3 & (tagMask())) == 0) && (((long64At(_objOop3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_objOop3 = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _currentClass, _objOop3);
		}
		_currentClass = _objOop3;
		/* end followField:ofObject: */
	}
	return null;
}
/*	Map the native pc theIP into a bytecode pc integer object and answer it. 
	See contextInstructionPointer:frame: for the explanation. */
/* CoInterpreter>>#mustMapMachineCodePC:context: */
static sqInt NoDbgRegParms
mustMapMachineCodePCcontext(sqInt _theIP, sqInt _aOnceMarriedContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _bcpc;
	CogMethod *_cogMethod;
	CogMethod *_cogMethod2;
	sqInt _maybeClosure;
	sqInt _mcpc;
	sqInt _methodObj;
	sqInt _rawHeader;
	sqInt _startBcpc;
	int _yetToCompact;

	if (_theIP == HasBeenReturnedFromMCPC) {
		return GIV(nilObj);
	}
	followForwardedObjectFieldstoDepth(_aOnceMarriedContext, 0);
	_maybeClosure = unsignedLongAt((_aOnceMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) ClosureIndex ) << (shiftForWord())) ));
	_methodObj = unsignedLongAt((_aOnceMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ));
	assert((((signed) _theIP ) >> 16) == -1);
	_startBcpc = ((literalCountOfMethodHeader(methodHeaderOf(_methodObj))) + LiteralStart) * BytesPerOop;
	/* begin ensureMethodIsCogged:maybeClosure: */
	/* begin fetchPointer:ofObject: */
	_rawHeader = unsignedLongAt((_methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if ((assert((((_rawHeader & 7) == 1)) || ((((usqInt) _rawHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _rawHeader ) >= (minCogMethodAddress())))), (_rawHeader & (smallIntegerTag())) == 0)) {
		_cogMethod = ((CogMethod *) _rawHeader );
		goto l4;
	}
	_yetToCompact = 1;
	while (1) {
		if (_maybeClosure != GIV(nilObj)) {
			_cogMethod2 = cogFullBlockMethodnumCopied(_methodObj, (numSlotsOf(_maybeClosure)) - FullClosureFirstCopiedValueIndex);
		}
 else {
			_cogMethod2 = cogselector(_methodObj, GIV(nilObj));
		}
		if (!((_cogMethod2 == null) && (GIV(cogCompiledCodeCompactionCalledFor) && _yetToCompact))) 
			break;
		_yetToCompact = 0;
		commenceCogCompiledCodeCompaction();
	}
	if (!(asserta(_cogMethod2 != null))) {
		error("could not compile method that should have been compiled");
	}
	_cogMethod = _cogMethod2;
	l4:
	;
	/* end ensureMethodIsCogged:maybeClosure: */
	/* begin bytecodePCFor:cogMethod:startBcpc: */
	assert(_theIP < 0);
	assert(((_cogMethod->cmType)) == CMMethod);
	_mcpc = ((sqInt) _cogMethod ) - _theIP;
	if (((usqInt) _mcpc ) < ((_cogMethod->stackCheckOffset))) {
		_bcpc = _startBcpc;
		goto l2;
	}
	assert((_mcpc >= ((sqInt) _cogMethod )) && (_mcpc <= (((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))));
	_bcpc = bytecodePCForstartBcpcin(_mcpc, _startBcpc, _cogMethod);
	l2:
	;
	/* end bytecodePCFor:cogMethod:startBcpc: */
	assert(_bcpc >= (startPCOfMethod(_methodObj)));
	if ((_bcpc == _startBcpc) && ((_maybeClosure == GIV(nilObj)) && (((_cogMethod->methodHeader)) & AlternateHeaderHasPrimFlag))) {
		_bcpc += 3;
	}
	return ((((usqInt) (_bcpc + 1) ) << 3) | 1);
}
/* CoInterpreter>>#newMethodAddress */
usqInt
newMethodAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((usqInt) &GIV(newMethod) );
}
/*	N.B. nextProfileTick is 64-bits */
/* CoInterpreter>>#nextProfileTickAddress */
usqInt
nextProfileTickAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((usqInt) &GIV(nextProfileTick) );
}
/* CoInterpreter>>#noAssertHeaderOf: */
sqInt
noAssertHeaderOf(sqInt _methodPointer)
{
	sqInt _methodHeader;

	/* begin fetchPointer:ofObject: */
	_methodHeader = unsignedLongAt((_methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	return (((assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0))
		 ? ((((CogMethod *) _methodHeader ))->methodHeader)
		 : _methodHeader);
}
/*	Insulate the stack zone from the effects of a become. 
	All receivers must be unfollowed for two reasons: 
	1. inst var access is direct with no read barrier 
	2. super sends (always to the receiver) have no class check and so don't 
	trap for forwarded receivers. This is an issue for primitives that assume 
	their receiver 
	is valid and don't validate. 
	Super sends require an explicit check to ensure receivers in super sends 
	are unforwarded. 
	e.g. super doSomethingWith: (self become: other) forwards the receiver 
	self pushed on the 
	stack. So we could avoid following non-pointer receivers. But this is too 
	tricky, Instead, we 
	always follow receivers. 
	Methods must be unfollowed since bytecode access is direct with no read 
	barrier. But this only needs to be done if the becomeEffectsFlags indicate 
	that a 
	CompiledMethod was becommed. 
	The scheduler state must be followed, but only if the becomeEffectsFlags 
	indicate that a pointer object was becommed.For VM profilingClear the gcMode var and let the Cogit do its post GC checks. */
/* CoInterpreter>>#postBecomeAction: */
static void NoDbgRegParms
postBecomeAction(sqInt _theBecomeEffectsFlags)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _anArray;
	sqInt _anArray2;
	sqInt _anArray3;
	sqInt _anArray4;
	sqIntptr_t _c;
	sqIntptr_t _c2;
	sqInt _currentObject;
	sqInt _first;
	sqInt _followingWord;
	usqInt _followingWordAddress;
	sqInt _i;
	sqInt _i2;
	sqInt _i3;
	sqInt _i4;
	sqInt _iLimit;
	sqInt _iLimit2;
	sqInt _last;
	sqInt _list;
	sqIntptr_t _m;
	sqInt _next;
	sqInt _obj;
	sqInt _obj2;
	sqInt _obj3;
	sqInt _obj4;
	sqInt _obj5;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _objOop3;
	sqInt _objOop4;
	sqInt _objOop5;
	sqInt _procLists;
	sqInt _referent;
	sqInt _referent2;
	sqInt _referent22;
	sqInt _referent3;
	sqInt _referent32;
	sqInt _referent4;
	sqInt _referent42;
	sqInt _referent5;
	sqInt _referent6;
	sqInt _referent7;
	sqIntptr_t _s;
	sqIntptr_t _s2;
	sqInt _sched;
	sqInt _schedAssoc;
	sqInt _xArray;

	{
		if (_theBecomeEffectsFlags != 0) {
			if (_theBecomeEffectsFlags & BecameCompiledMethodFlag) {
				/* begin followForwardedMethodsInMethodCache */
				for (_i = 0; _i < MethodCacheSize; _i += MethodCacheEntrySize) {
					_c = GIV(methodCache)[_i + MethodCacheClass];
					_s = GIV(methodCache)[_i + MethodCacheSelector];
					_m = GIV(methodCache)[_i + MethodCacheMethod];
					if ((_c != 0) && ((_s != 0) && ((_m != 0) && (((_m & (tagMask())) == 0) && (((long64At(_m)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))))) {
						/* begin followForwarded: */
						assert(isUnambiguouslyForwarder(_m));
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent = unsignedLongAt((_m + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
						while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
							/* begin fetchPointer:ofMaybeForwardedObject: */
							_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
							/* end fetchPointer:ofMaybeForwardedObject: */
						}
						_m = _referent;
						/* end followForwarded: */
						GIV(methodCache)[_i + MethodCacheMethod] = _m;
					}
				}
				/* end followForwardedMethodsInMethodCache */
				/* begin followForwardedMethodsInMethodZone */
				followForwardedMethods();
				/* end followForwardedMethodsInMethodZone */
			}
			if (_theBecomeEffectsFlags & BecameActiveClassFlag) {
				/* begin flushBecommedClassesInMethodCache */
				for (_i2 = 0; _i2 < MethodCacheSize; _i2 += MethodCacheEntrySize) {
					_c2 = GIV(methodCache)[_i2 + MethodCacheClass];
					_s2 = GIV(methodCache)[_i2 + MethodCacheSelector];
					if ((_c2 != 0) && ((_s2 != 0) && (isForwarded(classOrNilAtIndex(_c2))))) {
						{
							GIV(methodCache)[_i2 + MethodCacheClass] = 0;
							GIV(methodCache)[_i2 + MethodCacheSelector] = 0;
						}
					}
				}
				/* end flushBecommedClassesInMethodCache */
				/* begin flushBecommedClassesInMethodZone */
				unlinkSendsLinkedForInvalidClasses();
				/* end flushBecommedClassesInMethodZone */
			}
			if (_theBecomeEffectsFlags & BecamePointerObjectFlag) {
				/* begin followForwardingPointersInScheduler */
				/* begin splObj: */
				/* begin fetchPointer:ofObject: */
				_schedAssoc = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				/* end splObj: */
				if (_schedAssoc == GIV(nilObj)) {
					goto l17;
				}
				assert(!(isForwarded(_schedAssoc)));
				followForwardedObjectFieldstoDepth(_schedAssoc, 1);
				if (_schedAssoc == GIV(nilObj)) {
					goto l17;
				}
				/* begin fetchPointer:ofObject: */
				_sched = unsignedLongAt((_schedAssoc + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				/* begin followObjField:ofObject: */
				/* begin fetchPointer:ofObject: */
				_objOop5 = unsignedLongAt((_sched + BaseHeaderSize) + ((sqInt) (((usqInt) ProcessListsIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				assert(isNonImmediate(_objOop5));
				if (((long64At(_objOop5)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					_objOop5 = fixFollowedFieldofObjectwithInitialValue(ProcessListsIndex, _sched, _objOop5);
				}
				_procLists = _objOop5;
				/* end followObjField:ofObject: */
				for (_i3 = 0, _iLimit = (numSlotsOf(_procLists)) - 1; _i3 <= _iLimit; _i3 += 1) {
					/* begin followObjField:ofObject: */
					/* begin fetchPointer:ofObject: */
					_objOop2 = unsignedLongAt((_procLists + BaseHeaderSize) + ((sqInt) (((usqInt) _i3 ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					assert(isNonImmediate(_objOop2));
					if (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
						_objOop2 = fixFollowedFieldofObjectwithInitialValue(_i3, _procLists, _objOop2);
					}
					_list = _objOop2;
					/* end followObjField:ofObject: */
					/* begin followObjField:ofObject: */
					/* begin fetchPointer:ofObject: */
					_objOop3 = unsignedLongAt((_list + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					assert(isNonImmediate(_objOop3));
					if (((long64At(_objOop3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
						_objOop3 = fixFollowedFieldofObjectwithInitialValue(FirstLinkIndex, _list, _objOop3);
					}
					_first = _objOop3;
					/* end followObjField:ofObject: */
					/* begin followObjField:ofObject: */
					/* begin fetchPointer:ofObject: */
					_objOop4 = unsignedLongAt((_list + BaseHeaderSize) + ((sqInt) (((usqInt) LastLinkIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					assert(isNonImmediate(_objOop4));
					if (((long64At(_objOop4)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
						_objOop4 = fixFollowedFieldofObjectwithInitialValue(LastLinkIndex, _list, _objOop4);
					}
					_last = _objOop4;
					/* end followObjField:ofObject: */
					while (_first != _last) {
						/* begin followObjField:ofObject: */
						/* begin fetchPointer:ofObject: */
						_objOop = unsignedLongAt((_first + BaseHeaderSize) + ((sqInt) (((usqInt) NextLinkIndex ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						assert(isNonImmediate(_objOop));
						if (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
							_objOop = fixFollowedFieldofObjectwithInitialValue(NextLinkIndex, _first, _objOop);
						}
						_next = _objOop;
						/* end followObjField:ofObject: */
						_first = _next;
					}
				}
				l17:
				;
				/* end followForwardingPointersInScheduler */
				/* begin followForwardingPointersInSpecialObjectsArray */
				/* begin followSemaphoreIn:at: */
				_anArray = GIV(specialObjectsOop);
				/* begin fetchPointer:ofObject: */
				_obj2 = unsignedLongAt((_anArray + BaseHeaderSize) + ((sqInt) (((usqInt) TheLowSpaceSemaphore ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((long64At(_obj2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					/* begin followForwarded: */
					assert(isUnambiguouslyForwarder(_obj2));
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent32 = unsignedLongAt((_obj2 + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
					while (((_referent32 & (tagMask())) == 0) && (((long64At(_referent32)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent32 = unsignedLongAt((_referent32 + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
					}
					_obj2 = _referent32;
					/* end followForwarded: */
					/* begin storePointer:ofObject:withValue: */
					assert(!(isForwarded(_anArray)));
					if (((_anArray & (tagMask())) == 0) && ((_anArray & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
						if (((_obj2 & (tagMask())) == 0) && (((_obj2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_obj2 >= ((GIV(memoryMap)->newSpaceStart))))) {
							/* begin possibleOldObjectStoreInto: */
							if (!(((((usqInt) (long64At(_anArray)) ) >> (rememberedBitShift())) & 1) != 0)) {
								remember(GIV(fromOldSpaceRememberedSet), _anArray);
							}
							/* end possibleOldObjectStoreInto: */
						}
					}
					/* begin possiblePermObjectStoreInto:value: */
					if (((((usqInt) (long64At(_anArray)) ) >> (rememberedBitShift())) & 1) != 0) {
						goto l58;
					}
					if (_obj2 & (tagMask())) {
						goto l58;
					}
					if (!(_anArray >= 0x20000000000LL)) {
						goto l58;
					}
					if (_obj2 >= 0x20000000000LL) {
						goto l58;
					}
					if ((_obj2 >= GIV(nilObj)) && (_obj2 <= GIV(trueObj))) {
						goto l58;
					}
					if (!(_obj2 >= (startOfObjectMemory(GIV(memoryMap))))) {
						goto l58;
					}
					remember(getFromPermToNewSpaceRememberedSet(), _anArray);
					l58:
					;
					/* end possiblePermObjectStoreInto:value: */
					unsignedLongAtput((_anArray + BaseHeaderSize) + ((sqInt) (((usqInt) TheLowSpaceSemaphore ) << (shiftForWord())) ), _obj2);
					/* end storePointer:ofObject:withValue: */
				}
				/* end followSemaphoreIn:at: */
				/* begin followSemaphoreIn:at: */
				_anArray2 = GIV(specialObjectsOop);
				/* begin fetchPointer:ofObject: */
				_obj3 = unsignedLongAt((_anArray2 + BaseHeaderSize) + ((sqInt) (((usqInt) TheInterruptSemaphore ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((long64At(_obj3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					/* begin followForwarded: */
					assert(isUnambiguouslyForwarder(_obj3));
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent42 = unsignedLongAt((_obj3 + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
					while (((_referent42 & (tagMask())) == 0) && (((long64At(_referent42)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent42 = unsignedLongAt((_referent42 + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
					}
					_obj3 = _referent42;
					/* end followForwarded: */
					/* begin storePointer:ofObject:withValue: */
					assert(!(isForwarded(_anArray2)));
					if (((_anArray2 & (tagMask())) == 0) && ((_anArray2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
						if (((_obj3 & (tagMask())) == 0) && (((_obj3 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_obj3 >= ((GIV(memoryMap)->newSpaceStart))))) {
							/* begin possibleOldObjectStoreInto: */
							if (!(((((usqInt) (long64At(_anArray2)) ) >> (rememberedBitShift())) & 1) != 0)) {
								remember(GIV(fromOldSpaceRememberedSet), _anArray2);
							}
							/* end possibleOldObjectStoreInto: */
						}
					}
					/* begin possiblePermObjectStoreInto:value: */
					if (((((usqInt) (long64At(_anArray2)) ) >> (rememberedBitShift())) & 1) != 0) {
						goto l53;
					}
					if (_obj3 & (tagMask())) {
						goto l53;
					}
					if (!(_anArray2 >= 0x20000000000LL)) {
						goto l53;
					}
					if (_obj3 >= 0x20000000000LL) {
						goto l53;
					}
					if ((_obj3 >= GIV(nilObj)) && (_obj3 <= GIV(trueObj))) {
						goto l53;
					}
					if (!(_obj3 >= (startOfObjectMemory(GIV(memoryMap))))) {
						goto l53;
					}
					remember(getFromPermToNewSpaceRememberedSet(), _anArray2);
					l53:
					;
					/* end possiblePermObjectStoreInto:value: */
					unsignedLongAtput((_anArray2 + BaseHeaderSize) + ((sqInt) (((usqInt) TheInterruptSemaphore ) << (shiftForWord())) ), _obj3);
					/* end storePointer:ofObject:withValue: */
				}
				/* end followSemaphoreIn:at: */
				/* begin followSemaphoreIn:at: */
				_anArray3 = GIV(specialObjectsOop);
				/* begin fetchPointer:ofObject: */
				_obj4 = unsignedLongAt((_anArray3 + BaseHeaderSize) + ((sqInt) (((usqInt) TheTimerSemaphore ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((long64At(_obj4)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					/* begin followForwarded: */
					assert(isUnambiguouslyForwarder(_obj4));
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent5 = unsignedLongAt((_obj4 + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
					while (((_referent5 & (tagMask())) == 0) && (((long64At(_referent5)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent5 = unsignedLongAt((_referent5 + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
					}
					_obj4 = _referent5;
					/* end followForwarded: */
					/* begin storePointer:ofObject:withValue: */
					assert(!(isForwarded(_anArray3)));
					if (((_anArray3 & (tagMask())) == 0) && ((_anArray3 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
						if (((_obj4 & (tagMask())) == 0) && (((_obj4 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_obj4 >= ((GIV(memoryMap)->newSpaceStart))))) {
							/* begin possibleOldObjectStoreInto: */
							if (!(((((usqInt) (long64At(_anArray3)) ) >> (rememberedBitShift())) & 1) != 0)) {
								remember(GIV(fromOldSpaceRememberedSet), _anArray3);
							}
							/* end possibleOldObjectStoreInto: */
						}
					}
					/* begin possiblePermObjectStoreInto:value: */
					if (((((usqInt) (long64At(_anArray3)) ) >> (rememberedBitShift())) & 1) != 0) {
						goto l31;
					}
					if (_obj4 & (tagMask())) {
						goto l31;
					}
					if (!(_anArray3 >= 0x20000000000LL)) {
						goto l31;
					}
					if (_obj4 >= 0x20000000000LL) {
						goto l31;
					}
					if ((_obj4 >= GIV(nilObj)) && (_obj4 <= GIV(trueObj))) {
						goto l31;
					}
					if (!(_obj4 >= (startOfObjectMemory(GIV(memoryMap))))) {
						goto l31;
					}
					remember(getFromPermToNewSpaceRememberedSet(), _anArray3);
					l31:
					;
					/* end possiblePermObjectStoreInto:value: */
					unsignedLongAtput((_anArray3 + BaseHeaderSize) + ((sqInt) (((usqInt) TheTimerSemaphore ) << (shiftForWord())) ), _obj4);
					/* end storePointer:ofObject:withValue: */
				}
				/* end followSemaphoreIn:at: */
				/* begin followSemaphoreIn:at: */
				_anArray4 = GIV(specialObjectsOop);
				/* begin fetchPointer:ofObject: */
				_obj5 = unsignedLongAt((_anArray4 + BaseHeaderSize) + ((sqInt) (((usqInt) TheFinalizationSemaphore ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((long64At(_obj5)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					/* begin followForwarded: */
					assert(isUnambiguouslyForwarder(_obj5));
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent6 = unsignedLongAt((_obj5 + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
					while (((_referent6 & (tagMask())) == 0) && (((long64At(_referent6)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent6 = unsignedLongAt((_referent6 + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
					}
					_obj5 = _referent6;
					/* end followForwarded: */
					/* begin storePointer:ofObject:withValue: */
					assert(!(isForwarded(_anArray4)));
					if (((_anArray4 & (tagMask())) == 0) && ((_anArray4 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
						if (((_obj5 & (tagMask())) == 0) && (((_obj5 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_obj5 >= ((GIV(memoryMap)->newSpaceStart))))) {
							/* begin possibleOldObjectStoreInto: */
							if (!(((((usqInt) (long64At(_anArray4)) ) >> (rememberedBitShift())) & 1) != 0)) {
								remember(GIV(fromOldSpaceRememberedSet), _anArray4);
							}
							/* end possibleOldObjectStoreInto: */
						}
					}
					/* begin possiblePermObjectStoreInto:value: */
					if (((((usqInt) (long64At(_anArray4)) ) >> (rememberedBitShift())) & 1) != 0) {
						goto l37;
					}
					if (_obj5 & (tagMask())) {
						goto l37;
					}
					if (!(_anArray4 >= 0x20000000000LL)) {
						goto l37;
					}
					if (_obj5 >= 0x20000000000LL) {
						goto l37;
					}
					if ((_obj5 >= GIV(nilObj)) && (_obj5 <= GIV(trueObj))) {
						goto l37;
					}
					if (!(_obj5 >= (startOfObjectMemory(GIV(memoryMap))))) {
						goto l37;
					}
					remember(getFromPermToNewSpaceRememberedSet(), _anArray4);
					l37:
					;
					/* end possiblePermObjectStoreInto:value: */
					unsignedLongAtput((_anArray4 + BaseHeaderSize) + ((sqInt) (((usqInt) TheFinalizationSemaphore ) << (shiftForWord())) ), _obj5);
					/* end storePointer:ofObject:withValue: */
				}
				/* end followSemaphoreIn:at: */
				/* begin splObj: */
				/* begin fetchPointer:ofObject: */
				_xArray = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ExternalObjectsArray ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				/* end splObj: */
				if (((long64At(_xArray)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					/* begin followForwarded: */
					assert(isUnambiguouslyForwarder(_xArray));
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent7 = unsignedLongAt((_xArray + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
					while (((_referent7 & (tagMask())) == 0) && (((long64At(_referent7)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent7 = unsignedLongAt((_referent7 + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
					}
					_xArray = _referent7;
					/* end followForwarded: */
					/* begin splObj:put: */
					/* begin storePointer:ofObject:withValue: */
					assert(!(isForwarded(GIV(specialObjectsOop))));
					if (((GIV(specialObjectsOop) & (tagMask())) == 0) && ((GIV(specialObjectsOop) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
						if (((_xArray & (tagMask())) == 0) && (((_xArray & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_xArray >= ((GIV(memoryMap)->newSpaceStart))))) {
							/* begin possibleOldObjectStoreInto: */
							if (!(((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0)) {
								remember(GIV(fromOldSpaceRememberedSet), GIV(specialObjectsOop));
							}
							/* end possibleOldObjectStoreInto: */
						}
					}
					/* begin possiblePermObjectStoreInto:value: */
					if (((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0) {
						goto l46;
					}
					if (_xArray & (tagMask())) {
						goto l46;
					}
					if (!(GIV(specialObjectsOop) >= 0x20000000000LL)) {
						goto l46;
					}
					if (_xArray >= 0x20000000000LL) {
						goto l46;
					}
					if ((_xArray >= GIV(nilObj)) && (_xArray <= GIV(trueObj))) {
						goto l46;
					}
					if (!(_xArray >= (startOfObjectMemory(GIV(memoryMap))))) {
						goto l46;
					}
					remember(getFromPermToNewSpaceRememberedSet(), GIV(specialObjectsOop));
					l46:
					;
					/* end possiblePermObjectStoreInto:value: */
					unsignedLongAtput((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ExternalObjectsArray ) << (shiftForWord())) ), _xArray);
					/* end storePointer:ofObject:withValue: */
					/* end splObj:put: */
				}
				for (_i4 = 0, _iLimit2 = (numSlotsOf(_xArray)) - 1; _i4 <= _iLimit2; _i4 += 1) {
					/* begin followSemaphoreIn:at: */
					/* begin fetchPointer:ofObject: */
					_obj = unsignedLongAt((_xArray + BaseHeaderSize) + ((sqInt) (((usqInt) _i4 ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (((long64At(_obj)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
						/* begin followForwarded: */
						assert(isUnambiguouslyForwarder(_obj));
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent22 = unsignedLongAt((_obj + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
						while (((_referent22 & (tagMask())) == 0) && (((long64At(_referent22)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
							/* begin fetchPointer:ofMaybeForwardedObject: */
							_referent22 = unsignedLongAt((_referent22 + BaseHeaderSize) + (0U << (shiftForWord())));
							/* end fetchPointer:ofMaybeForwardedObject: */
						}
						_obj = _referent22;
						/* end followForwarded: */
						/* begin storePointer:ofObject:withValue: */
						assert(!(isForwarded(_xArray)));
						if (((_xArray & (tagMask())) == 0) && ((_xArray & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
							if (((_obj & (tagMask())) == 0) && (((_obj & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_obj >= ((GIV(memoryMap)->newSpaceStart))))) {
								/* begin possibleOldObjectStoreInto: */
								if (!(((((usqInt) (long64At(_xArray)) ) >> (rememberedBitShift())) & 1) != 0)) {
									remember(GIV(fromOldSpaceRememberedSet), _xArray);
								}
								/* end possibleOldObjectStoreInto: */
							}
						}
						/* begin possiblePermObjectStoreInto:value: */
						if (((((usqInt) (long64At(_xArray)) ) >> (rememberedBitShift())) & 1) != 0) {
							goto l61;
						}
						if (_obj & (tagMask())) {
							goto l61;
						}
						if (!(_xArray >= 0x20000000000LL)) {
							goto l61;
						}
						if (_obj >= 0x20000000000LL) {
							goto l61;
						}
						if ((_obj >= GIV(nilObj)) && (_obj <= GIV(trueObj))) {
							goto l61;
						}
						if (!(_obj >= (startOfObjectMemory(GIV(memoryMap))))) {
							goto l61;
						}
						remember(getFromPermToNewSpaceRememberedSet(), _xArray);
						l61:
						;
						/* end possiblePermObjectStoreInto:value: */
						unsignedLongAtput((_xArray + BaseHeaderSize) + ((sqInt) (((usqInt) _i4 ) << (shiftForWord())) ), _obj);
						/* end storePointer:ofObject:withValue: */
					}
					/* end followSemaphoreIn:at: */
				}
				/* end followForwardingPointersInSpecialObjectsArray */
			}
			if (_theBecomeEffectsFlags & (BecamePointerObjectFlag + BecameCompiledMethodFlag)) {
				/* begin followForwardingPointersInProfileState */
				if (((long64At(GIV(profileProcess))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					/* begin followForwarded: */
					assert(isUnambiguouslyForwarder(GIV(profileProcess)));
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent4 = unsignedLongAt((GIV(profileProcess) + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
					while (((_referent4 & (tagMask())) == 0) && (((long64At(_referent4)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent4 = unsignedLongAt((_referent4 + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
					}
					GIV(profileProcess) = _referent4;
					/* end followForwarded: */
				}
				if (((long64At(GIV(profileMethod))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					/* begin followForwarded: */
					assert(isUnambiguouslyForwarder(GIV(profileMethod)));
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent2 = unsignedLongAt((GIV(profileMethod) + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
					while (((_referent2 & (tagMask())) == 0) && (((long64At(_referent2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent2 = unsignedLongAt((_referent2 + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
					}
					GIV(profileMethod) = _referent2;
					/* end followForwarded: */
				}
				if (((long64At(GIV(profileProcess))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					/* begin followForwarded: */
					assert(isUnambiguouslyForwarder(GIV(profileSemaphore)));
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent3 = unsignedLongAt((GIV(profileSemaphore) + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
					while (((_referent3 & (tagMask())) == 0) && (((long64At(_referent3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent3 = unsignedLongAt((_referent3 + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
					}
					GIV(profileSemaphore) = _referent3;
					/* end followForwarded: */
				}
				/* end followForwardingPointersInProfileState */
			}
			if (_theBecomeEffectsFlags & BecamePermanentObject) {
				/* begin followForwardingPointersInPermSpace */
				/* begin allPermSpaceNonForwardedObjectsDo: */
				/* begin allPermSpaceObjectsDo: */
				_currentObject = (GIV(memoryMap)->permSpaceStart);
				while (!(_currentObject == GIV(permSpaceFreeStart))) {
					if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
						{
							if (!(((long64At(_currentObject)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
								{
									followForwardedObjectFieldstoDepth(_currentObject, 0);
								}
							}
						}
					}
					/* begin objectAfter:limit: */
					_followingWordAddress = addressAfter(_currentObject);
					if (oopisGreaterThanOrEqualTo(_followingWordAddress, GIV(permSpaceFreeStart))) {
						_currentObject = GIV(permSpaceFreeStart);
						goto l63;
					}
					flag("endianness");
					_followingWord = unsignedLongAt(_followingWordAddress);
					_currentObject = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
						 ? _followingWordAddress + BaseHeaderSize
						 : _followingWordAddress);
					l63:
					;
					/* end objectAfter:limit: */
				}
				/* end allPermSpaceObjectsDo: */
				/* end allPermSpaceNonForwardedObjectsDo: */
				recreateFromPermSpaceRememberedSet();
				/* end followForwardingPointersInPermSpace */
			}
		}
		followForwardingPointersInStackZone(_theBecomeEffectsFlags);
	}
	if (_theBecomeEffectsFlags & OldBecameNewFlag) {
		addAllToYoungReferrers();
	}
	cogitPostGCAction(GIV(gcMode));
	/* begin nilUncoggableMethods */
	GIV(lastCoggableInterpretedBlockMethod) = (GIV(lastUncoggableInterpretedBlockMethod) = null);
	/* end nilUncoggableMethods */
	GIV(gcMode) = 0;
}
/*	Signal the gc semaphore, and inform the display subsystem if the display 
	bitmap has moved.Attempt to shrink free memory, signal the gc semaphore and let the Cogit 
	do its post GC thang */
/* CoInterpreter>>#postGCAction: */
static void NoDbgRegParms
postGCAction(sqInt _gcModeArg)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	assert(_gcModeArg == GIV(gcMode));
	{
		signalSemaphoreWithIndex(GIV(gcSemaphoreIndex));
	}
	cogitPostGCAction(_gcModeArg);
	/* begin nilUncoggableMethods */
	GIV(lastCoggableInterpretedBlockMethod) = (GIV(lastUncoggableInterpretedBlockMethod) = null);
	/* end nilUncoggableMethods */
	GIV(gcMode) = 0;
}
/*	Need to write back the frame pointers unless all pages are free (as in 
	snapshot) Need to write back the frame pointers unless all pages are free (as in 
	snapshot). Need to set gcMode var (to avoid passing the flag through a lot 
	of the updating code) */
/* CoInterpreter>>#preGCAction: */
static void NoDbgRegParms
preGCAction(sqInt _gcModeArg)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	char *_theSP;
	sqInt _traceType;

	{
		if (GIV(stackPage) != 0) {
			/* begin writeBackHeadFramePointers */
			assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
			assert(GIV(stackPage) == (mostRecentlyUsedPage()));
			assert(!(isFree(GIV(stackPage))));
			/* begin setHeadFP:andSP:inPage: */
			_theSP = GIV(stackPointer);
			assert(_theSP < GIV(framePointer));
			assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
			assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
			{
				(GIV(stackPage)->headFP = GIV(framePointer));
				(GIV(stackPage)->headSP = _theSP);
			}
			/* end setHeadFP:andSP:inPage: */
			assert(pageListIsWellFormed());
			/* end writeBackHeadFramePointers */
		}
		if (_gcModeArg == GCModeFull) {
			/* begin flushMethodCache */
			for (_i = 1; _i <= MethodCacheSize; _i += 1) {
				GIV(methodCache)[_i] = 0;
			}
			GIV(lastMethodCacheProbeWrite) = 0;
			/* end flushMethodCache */
		}
	}
	GIV(gcMode) = _gcModeArg;
	if (recordEventTrace()) {
		_traceType = ((_gcModeArg == GCModeFull)
			 ? TraceFullGC
			 : TraceIncrementalGC);
		/* begin recordTrace:thing:source: */
		GIV(traceLog)[GIV(traceLogIndex)] = _traceType;
		GIV(traceLog)[GIV(traceLogIndex) + 1] = _traceType;
		GIV(traceLog)[GIV(traceLogIndex) + 2] = 0;
		GIV(traceLogIndex) = (GIV(traceLogIndex) + 3) % TraceBufferSize;
		/* end recordTrace:thing:source: */
	}
	if (recordPrimTrace()) {
		_traceType = ((_gcModeArg == GCModeFull)
			 ? TraceFullGC
			 : TraceIncrementalGC);
		/* begin fastLogPrim: */
		GIV(primTraceLog)[GIV(primTraceLogIndex)] = _traceType;
		primTraceLogIndex(GIV(primTraceLogIndex) + 1);
		/* end fastLogPrim: */
	}
}
/* CoInterpreter>>#primErrTable */
sqInt
primErrTable(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) PrimErrTableIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/* CoInterpreter>>#primFailCodeAddress */
usqInt
primFailCodeAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((usqInt) &GIV(primFailCode) );
}
/*	This is used for asserts that check that inline cache editing results in 
	valid addresses. 
	In the C VM interpret is presumed to come before any primitives and so it 
	constitutes the lowest address in C code that machine code should be 
	linked, but optimizing 
	compilers change things around. In the simulator we just answer something 
	not low. */
/* CoInterpreter>>#primitiveFailAddress */
usqInt
primitiveFailAddress(void)
{
	return ((usqInt) &primitiveFail );
}
/* CoInterpreter>>#primTraceLogAddress */
void *
primTraceLogAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(primTraceLog);
}
/*	N.B. primTraceLogIndex is 8-bits */
/* CoInterpreter>>#primTraceLogIndexAddress */
usqInt
primTraceLogIndexAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((usqInt) &GIV(primTraceLogIndex) );
}
/* CoInterpreter>>#printCogMethod: */
void
printCogMethod(CogMethod *_cogMethod)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _firstBytecode;
	sqInt _primitive;
	sqInt _s;

	_address = ((sqInt) _cogMethod );
	{
		printHex(_address);
		print(" <-> ");
		printHex(_address + ((_cogMethod->blockSize)));
	}
	if (((_cogMethod->cmType)) == CMMethod) {
		{
			print(": method: ");
			printHex((_cogMethod->methodObject));
		}
		if (((_cogMethod->methodHeader)) & AlternateHeaderHasPrimFlag) {
			_firstBytecode = (((_cogMethod->methodObject)) + ((LiteralStart + ((((_cogMethod->methodHeader)) >> 3) & AlternateHeaderNumLiteralsMask)) * BytesPerOop)) + BaseHeaderSize;
			_primitive = (byteAt(_firstBytecode + 1)) + ((sqInt) (((usqInt) (byteAt(_firstBytecode + 2)) ) << 8) );
		} else {
			_primitive = 0;
		}
		if (_primitive != 0) {
			{
				print(" prim ");
				printNum(_primitive);
			}
		}
	}
	if (((_cogMethod->cmType)) == CMPolymorphicIC) {
		{
			print(": Closed PIC N: ");
			printHex((_cogMethod->cPICNumCases));
		}
	}
	if (((_cogMethod->cmType)) == CMMegamorphicIC) {
		print(": Open PIC ");
	}
	{
		print(" selector: ");
		printHex((_cogMethod->selector));
	}
	if (((_cogMethod->selector)) == GIV(nilObj)) {
		if ((((_cogMethod->cmType)) == CMMethod) && (((_s = maybeSelectorOfMethod((_cogMethod->methodObject)))) != null)) {
			{
				print(" (nil: ");
				printStringOf(_s);
				print(")");
			}
		} else {
			print(" (nil)");
		}
	} else {
		{
			/* begin space */
			printChar(' ');
			/* end space */
			printStringOf((_cogMethod->selector));
		}
	}
	/* begin cr */
	print("\n");
	/* end cr */
}
/* CoInterpreter>>#printFrameFlagsForFP: */
static void NoDbgRegParms
printFrameFlagsForFP(char *_theFP)
{
	char *_address;
	sqInt _it;

	if (isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) ))) {
		_address = _theFP + FoxMethod;
		_it = (longAt(_address)) & 7;
	} else {
		_address = _theFP + FoxIFrameFlags;
		_it = longAt(_address);
	}
	{
		/* begin printHexPtr: */
		printHex(oopForPointer(_address));
		/* end printHexPtr: */
		print(((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ": mcfrm flags: "
			 : ":intfrm flags: "));
		printHex(_it);
	}
	if (_it != 0) {
		{
			printChar('=');
			printNum(_it);
		}
	}
	{
		print("  numArgs: ");
		printNum(((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
			 : byteAt((_theFP + FoxIFrameFlags) + 1)));
		print(((((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
			 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0))
			 ? " hasContext"
			 : " noContext"));
		print(((((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagIsBlockFlag) != 0
			 : (byteAt((_theFP + FoxIFrameFlags) + 3)) != 0))
			 ? " isBlock"
			 : " notBlock"));
		/* begin cr */
		print("\n");
		/* end cr */
	}
}
/* CoInterpreter>>#printFrameMethodFor: */
static void NoDbgRegParms
printFrameMethodFor(char *_theFP)
{
	char *_address;
	CogMethod *_homeMethod;
	sqInt _it;
	sqInt _methodField;
	sqInt _obj;

	_address = _theFP + FoxMethod;
	_it = longAt(_address);
	{
		printHex(((sqInt) _address ));
		printChar(':');
	}
	{
		print("      method: ");
		printHex(_it);
	}
	/* begin tab */
	printChar('	');
	/* end tab */
	if ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) ))) && (((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagIsBlockFlag) != 0)) {
		/* begin mframeHomeMethod: */
		_methodField = unsignedLongAt(_theFP + FoxMethod);
		_homeMethod = ((CogMethod *) (_methodField & MFMethodMask) );
		/* end mframeHomeMethod: */
		{
			print("hm: ");
			printHex(((sqInt) _homeMethod ));
			/* begin tab */
			printChar('	');
			/* end tab */
		}
	}
	_obj = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((mframeHomeMethod(_theFP))->methodObject)
		 : unsignedLongAt(_theFP + FoxMethod));
	shortPrintOop(_obj);
}
/* CoInterpreter>>#printFrame:WithSP: */
sqInt
printFrameWithSP(char *_theFP, char *_theSP)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_addr;
	CogMethod *_cogMethod;
	sqInt _header;
	sqInt _header2;
	CogMethod *_homeMethod;
	sqInt _i;
	char * _limit;
	sqInt _methodField;
	usqInt _numArgs;
	sqInt _numTemps;
	char * _stackStart;
	sqInt _theMethod;
	usqInt _theMethodEnd;
	sqInt _topThing;

	if (!(((((usqInt) _theFP ) & (BytesPerWord - 1)) == 0) && ((((usqInt) _theFP ) >= ((usqInt) (GIV(stackBasePlus1) - 1) )) && (((usqInt) _theFP ) <= ((usqInt) GIV(pages) ))))) {
		{
			/* begin printHexPtr: */
			printHex(oopForPointer(_theFP));
			/* end printHexPtr: */
			print(" is not in the stack zone?!");
			/* begin cr */
			print("\n");
			/* end cr */
		}
		return null;
	}
	if (isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) ))) {
		_cogMethod = ((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) );
		/* begin mframeHomeMethod: */
		_methodField = unsignedLongAt(_theFP + FoxMethod);
		_homeMethod = ((CogMethod *) (_methodField & MFMethodMask) );
		/* end mframeHomeMethod: */
		_theMethod = ((sqInt) _homeMethod );
		_theMethodEnd = ((sqInt) _homeMethod ) + ((_homeMethod->blockSize));
		_numArgs = (_cogMethod->cmNumArgs);
		_numTemps = (((usqInt) ((_homeMethod->methodHeader)) ) >> MethodHeaderTempCountShift) & 0x3F;
	} else {
		_theMethod = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((mframeHomeMethod(_theFP))->methodObject)
			 : unsignedLongAt(_theFP + FoxMethod));
		_theMethodEnd = _theMethod + (((numSlotsOf(_theMethod)) << (shiftForWord())) + BaseHeaderSize);
		_numArgs = byteAt((_theFP + FoxIFrameFlags) + 1);
		/* begin temporaryCountOfMethodHeader: */
		/* begin methodHeaderOf: */
		assert(isCompiledMethod(_theMethod));
		/* begin fetchPointer:ofObject: */
		_header2 = unsignedLongAt((_theMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_header2 & 7) == 1)) {
			_header = _header2;
		} else {
			assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
			assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
			_header = ((((CogMethod *) _header2 ))->methodHeader);
		}
		/* end methodHeaderOf: */
		_numTemps = (((usqInt) _header ) >> MethodHeaderTempCountShift) & 0x3F;
		/* end temporaryCountOfMethodHeader: */
	}
	shortPrintFrame(_theFP);
	if ((unsignedLongAt(_theFP + FoxSavedFP)) == 0) {
		printFrameOopat("(caller ctxt", (_theFP + (frameStackedReceiverOffsetNumArgs(((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
			 : byteAt((_theFP + FoxIFrameFlags) + 1))))) + (2 * BytesPerWord));
		printFrameOopat("(saved ctxt", (_theFP + (frameStackedReceiverOffsetNumArgs(((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
			 : byteAt((_theFP + FoxIFrameFlags) + 1))))) + (1 * BytesPerWord));
	}
	printFrameOopat("rcvr/clsr", (_theFP + FoxCallerSavedIP) + ((_numArgs + 1) * BytesPerWord));
	for (_i = _numArgs; _i >= 1; _i += -1) {
		printFrameOopindexat("arg", _numArgs - _i, (_theFP + FoxCallerSavedIP) + (_i * BytesPerWord));
	}
	printFrameThingatextraString("caller ip", _theFP + FoxCallerSavedIP, (((longAt(_theFP + FoxCallerSavedIP)) == (ceReturnToInterpreterPC()))
		 ? "ceReturnToInterpreter"
		 : 0));
	printFrameThingat("saved fp", _theFP + FoxSavedFP);
	printFrameMethodFor(_theFP);
	printFrameOopat("context", _theFP + FoxThisContext);
	printFrameFlagsForFP(_theFP);
	if (!(isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))) {
		printFrameThingatextra("saved ip", _theFP + FoxIFSavedIP, (((unsignedLongAt(_theFP + FoxIFSavedIP)) == 0)
			 ? 0
			 : (((unsignedLongAt(_theFP + FoxIFSavedIP)) - _theMethod) + 2) - BaseHeaderSize));
	}
	printFrameOopat("receiver", ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? _theFP + FoxMFReceiver
		 : _theFP + FoxIFReceiver));
	_topThing = unsignedLongAt(_theSP);
	_limit = _theSP;
	if ((_topThing >= _theMethod) && (_topThing <= _theMethodEnd)) {
		_limit += BytesPerWord;
	}
	_stackStart = (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? _theFP + FoxMFReceiver
		 : _theFP + FoxIFReceiver)) - BytesPerWord;
	for (_i = 1; _i <= (_numTemps - _numArgs); _i += 1) {
		printFrameOopat("temp", _stackStart - (_i * BytesPerWord));
	}
	for (_addr = _stackStart; _addr >= _limit; _addr += -BytesPerWord) {
		printFrameOopat("stck", _addr);
	}
	if ((_topThing >= _theMethod) && (_topThing <= _theMethodEnd)) {
		printFrameThingatextra("frame ip", _theSP, ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? _topThing - _theMethod
			 : ((_topThing - _theMethod) + 2) - BaseHeaderSize));
	}
	return 0;
}
/* CoInterpreter>>#printLogEntryAt: */
static void NoDbgRegParms
printLogEntryAt(sqInt _i)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char * traceSources[] = {
		"?", "m", "i", "callbackEnter", "callbackLeave", "enterCritical", "exitCritical",
		"resume", "signal", "suspend", "wait", "yield", "eventcheck"
	};
	sqInt _intOrClass;
	sqInt _selectorMethodOrProcess;
	sqInt _source;

	_intOrClass = GIV(traceLog)[_i];
	_selectorMethodOrProcess = GIV(traceLog)[_i + 1];
	_source = GIV(traceLog)[_i + 2];
	if (_source <= TraceIsFromInterpreter) {
		{
			print(traceSources[_source]);
			/* begin space */
			printChar(' ');
			/* end space */
		}
	}
	if (((_intOrClass & 7) == 1)) {
		if (_intOrClass == TraceStackOverflow) {
			print("stack overflow");
		}
		if (_intOrClass == TraceContextSwitch) {
			{
				print("context switch from ");
				printHex(_selectorMethodOrProcess);
			}
		}
		if (_intOrClass == TraceBlockActivation) {
			{
				print(" [] in ");
				printHex(_selectorMethodOrProcess);
			}
		}
		if (_intOrClass == TraceBlockCreation) {
			{
				print("create [] ");
				printHex(_selectorMethodOrProcess);
			}
		}
		if (_intOrClass == TraceIncrementalGC) {
			print("incrementalGC");
		}
		if (_intOrClass == TraceFullGC) {
			print("fullGC");
		}
		if (_intOrClass == TraceCodeCompaction) {
			print("compactCode");
		}
		if (_intOrClass == TraceVMCallback) {
			print("callback");
		}
		if (_intOrClass == TraceVMCallbackReturn) {
			print("return from callback");
		}
	} else {
		{
			/* begin space */
			printChar(' ');
			/* end space */
			printNameOfClasscount(_intOrClass, 5);
			print(">>");
			printStringOf(_selectorMethodOrProcess);
		}
	}
	if (_source > TraceIsFromInterpreter) {
		{
			/* begin space */
			printChar(' ');
			/* end space */
			print(traceSources[_source]);
		}
	}
	/* begin cr */
	print("\n");
	/* end cr */
}
/* CoInterpreter>>#printMethodCacheFor: */
void
printMethodCacheFor(sqInt _thing)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqIntptr_t _c;
	sqInt _i;
	sqIntptr_t _m;
	int _n;
	sqIntptr_t _p;
	sqIntptr_t _s;

	_n = 0;
	for (_i = 0; _i < MethodCacheSize; _i += MethodCacheEntrySize) {
		_s = GIV(methodCache)[_i + MethodCacheSelector];
		_c = GIV(methodCache)[_i + MethodCacheClass];
		_m = GIV(methodCache)[_i + MethodCacheMethod];
		_p = GIV(methodCache)[_i + MethodCachePrimFunction];
		if (((_thing == -1) || ((_s == _thing) || ((_c == _thing) || ((_p == _thing) || ((_m == _thing) || ((addressCouldBeObj(_m)) && ((((_m & (tagMask())) == 0) && ((((((usqInt) (longAt(_m)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && (isCogMethodReference(unsignedLongAt((_m + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) )))))) && (((sqInt) (cogMethodOf(_m)) ) == _thing)))))))) && (((_s & (tagMask())) || (addressCouldBeObj(_s))) && ((_c != 0) && ((addressCouldBeClassObj(_c)) || (addressCouldBeClassObj(classAtIndex(_c))))))) {
			_n += 1;
			{
				printNum(_i);
				/* begin space */
				printChar(' ');
				/* end space */
				printHexnp(_i);
				/* begin cr */
				print("\n");
				/* end cr */
				/* begin tab */
				printChar('	');
				/* end tab */
			}
			if (((((usqInt) (longAt(_s)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())) {
				vm_printf("%" PRIxSQPTR " %.*s\n", _s, (int)(numBytesOf(_s)), (char *)firstIndexableField(_s));
			} else {
				shortPrintOop(_s);
			}
			/* begin tab */
			printChar('	');
			/* end tab */
			if (addressCouldBeClassObj(_c)) {
				shortPrintOop(_c);
			} else {
				{
					printNum(_c);
					/* begin space */
					printChar(' ');
					/* end space */
					printHexnp(_c);
					/* begin space */
					printChar(' ');
					/* end space */
					shortPrintOop(classAtIndex(_c));
				}
			}
			{
				/* begin tab */
				printChar('	');
				/* end tab */
				shortPrintOop(_m);
				/* begin tab */
				printChar('	');
				/* end tab */
			}
			if (_p > 1024) {
				printHexnp(_p);
			}
 else {
				printNum(_p);
			}
			/* begin cr */
			print("\n");
			/* end cr */
		}
	}
	if (_n > 1) {
		{
			printNum(_n);
			/* begin cr */
			print("\n");
			/* end cr */
		}
	}
}
/* CoInterpreter>>#printPrimLogEntryAt: */
static sqInt NoDbgRegParms
printPrimLogEntryAt(sqInt _i)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _intOrSelector;
	sqInt _referent;
	sqInt _target;

	_intOrSelector = GIV(primTraceLog)[_i];
	if (_intOrSelector & (tagMask())) {
		if (_intOrSelector == TraceIncrementalGC) {
			print("**IncrementalGC**");
			return null;
		}
		if (_intOrSelector == TraceFullGC) {
			print("**FullGC**");
			return null;
		}
		if (_intOrSelector == TraceCodeCompaction) {
			print("**CompactCode**");
			return null;
		}
		if (_intOrSelector == TraceStackOverflow) {
			print("**StackOverflow**");
			return null;
		}
		if (_intOrSelector == TracePrimitiveFailure) {
			print("**PrimitiveFailure**");
			return null;
		}
		if (_intOrSelector == TracePrimitiveRetry) {
			print("**PrimitiveRetry**");
			return null;
		}
		print("???");
	} else {
		if (_intOrSelector == 0) {
			{
				printNum(_i);
				print("!!!");
			}
		} else {
			/* begin safePrintStringOf: */
			if (((_intOrSelector & (tagMask())) == 0) && (((long64At(_intOrSelector)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin followForwarded: */
				assert(isUnambiguouslyForwarder(_intOrSelector));
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent = unsignedLongAt((_intOrSelector + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
				while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
				}
				_target = _referent;
				/* end followForwarded: */
			} else {
				_target = _intOrSelector;
			}
			printStringOf(_target);
			goto l5;
			l5:
			;
			/* end safePrintStringOf: */
		}
	}
	return 0;
}
/* CoInterpreter>>#quickPrimitiveConstantFor: */
sqInt
quickPrimitiveConstantFor(sqInt _aQuickPrimitiveIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	switch (_aQuickPrimitiveIndex) {
		case 257:
		{
			return GIV(trueObj);
		}
		case 258:
		{
			return GIV(falseObj);
		}
		case 259:
		{
			return GIV(nilObj);
		}
		case 260:
		{
			return ConstMinusOne;
		}
		case 261:
		{
			return ConstZero;
		}
		case 262:
		{
			return ConstOne;
		}
		case 263:
		{
			return ConstTwo;
		}
		default:
		error("Case not found and no otherwise clause");
		return -1;
	}
}
/* CoInterpreter>>#quickPrimitiveGeneratorFor: */
sqInt (*quickPrimitiveGeneratorFor(sqInt _aQuickPrimitiveIndex))(void)

{
	switch (_aQuickPrimitiveIndex) {
		case 256:
		{
			return genQuickReturnSelf;
		}
		case 257:
		case 258:
		case 259:
		case 260:
		case 261:
		case 262:
		case 263:
		{
			return genQuickReturnConst;
		}
		default:
		{
			return genQuickReturnInstVar;
		}
	}
}
/* CoInterpreter>>#quickPrimitiveInstVarIndexFor: */
sqInt
quickPrimitiveInstVarIndexFor(sqInt _primIndex)
{
	return _primIndex - 264;
}
/*	Since methods may be updated while forwarding during become, make the 
	assert accomodate this. */
/* CoInterpreter>>#rawHeaderOf:put: */
void
rawHeaderOfput(sqInt _methodOop, sqInt _cogMethodOrMethodHeader)
{
	assert(isCompiledMethodHeader(headerWhileForwardingOf(_methodOop)));
	{
		assert(!(isOopForwarded(_methodOop)));
		longAtput((_methodOop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ), _cogMethodOrMethodHeader);
	}
}
/*	Report the stack page size and minimum unused headroom to stdout. */
/* CoInterpreter>>#reportMinimumUnusedHeadroom */
void
reportMinimumUnusedHeadroom(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	vm_printf("stack page bytes %lld available headroom %lld minimum unused headroom %lld\n", ((unsigned long long) (stackPageByteSize()) ), ((unsigned long long) (((stackPageByteSize()) - (((GIV(desiredStackPageBytes) < (((stackPageByteSize()) - ((IFrameSlots + 64) * BytesPerWord)) - (osCogStackPageHeadroom()))) ? GIV(desiredStackPageBytes) : ((stackPageByteSize()) - ((IFrameSlots + 64) * BytesPerWord)) - (osCogStackPageHeadroom())))) - ((IFrameSlots + 64) * BytesPerWord)) ), ((unsigned long long) (minimumUnusedHeadroom()) ));
}
/*	Return to the current frame, either by entering machine code, or 
	longjmp-ing back to the 
	interpreter or simply returning, depending on where we are. To know 
	whether to return or 
	enter machine code we have to know from whence we came. We could have come 
	from the interpreter, either directly or via a machine code primitive. We 
	could have come from 
	machine code. The instructionPointer tells us where from. If it is above 
	startOfMemory we're 
	in the interpreter. If it is below, then we are in machine-code unless it 
	is ceReturnToInterpreterPC, 
	in which case we're in a machine-code primitive called from the 
	interpreter.  */
/* CoInterpreter>>#returnToExecutive:postContextSwitch: */
static sqInt NoDbgRegParms
returnToExecutivepostContextSwitch(sqInt _inInterpreter, sqInt _switchedContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aMethodObj;
	CogMethod *_cogMethod;
	sqInt _fullyInInterpreter;
	sqInt _retValue;
	char *_sp;
	char *_sp2;
	sqInt _top;

	assertCStackWellAligned();
	if (isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) ))) {
		assertValidExecutionPointersimbarline(GIV(instructionPointer), GIV(framePointer), GIV(stackPointer), 0, __LINE__);
		if (_switchedContext) {
			_cogMethod = ((CogMethod *) ((unsignedLongAt(GIV(framePointer) + FoxMethod)) & MFMethodMask) );
			assert((((usqIntptr_t) GIV(instructionPointer) ) > (minCogMethodAddress())) && (((usqIntptr_t) GIV(instructionPointer) ) < (maxCogMethodAddress())));
			if ((((usqIntptr_t) GIV(instructionPointer) ) != (((sqInt) _cogMethod ) + ((_cogMethod->stackCheckOffset)))) && (isSendReturnPC(GIV(instructionPointer)))) {
				assert(addressCouldBeOop(stackTop()));
				/* begin popStack */
				_top = unsignedLongAt(GIV(stackPointer));
				GIV(stackPointer) += BytesPerWord;
				_retValue = _top;
				/* end popStack */
			} else {
				/* begin mframeReceiver: */
				_retValue = unsignedLongAt(GIV(framePointer) + FoxMFReceiver);
				/* end mframeReceiver: */
			}
		} else {
			/* begin mframeReceiver: */
			_retValue = unsignedLongAt(GIV(framePointer) + FoxMFReceiver);
			/* end mframeReceiver: */
		}
		/* begin push: */
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
		GIV(stackPointer) = _sp;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _retValue);
		GIV(stackPointer) = _sp2;
		/* end push: */
		/* begin callEnilopmart: */
		ceEnterCogCodePopReceiverReg();
		/* end callEnilopmart: */
		{
			assert(0);
		}
	}
	/* begin setMethod: */
	_aMethodObj = unsignedLongAt(GIV(framePointer) + FoxMethod);
	assert(((usqInt) _aMethodObj ) >= (startOfObjectMemory(getMemoryMap())));
	{
		GIV(method) = _aMethodObj;
		assert(isOopCompiledMethod(GIV(method)));
	}
	/* end setMethod: */
	_fullyInInterpreter = _inInterpreter;
	if (((usqIntptr_t) GIV(instructionPointer) ) == (ceReturnToInterpreterPC())) {
		GIV(instructionPointer) = ((usqIntptr_t) (unsignedLongAt(GIV(framePointer) + FoxIFSavedIP)) );
		_fullyInInterpreter = 0;
	}
	assertValidExecutionPointersimbarline(GIV(instructionPointer), GIV(framePointer), GIV(stackPointer), 1, __LINE__);
	if (!_fullyInInterpreter) {
		siglongjmp(reenterInterpreter, ReturnToInterpreter);
		{
			assert(0);
		}
	}
	return null;
}
/*	We have made a context switch, either when interpreting or from machine 
	code. Effectively return to the current frame, either by entering machine 
	code, or 
	longjmp-ing back to the interpreter or simply returning, depending on 
	where we are. */
/* CoInterpreter>>#return:toExecutive: */
static sqInt NoDbgRegParms
returntoExecutive(sqInt _returnValue, sqInt _inInterpreter)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aMethodObj;
	char *_sp;
	char *_sp2;
	char *_sp3;

	assertCStackWellAligned();
	if (isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) ))) {
		assertValidExecutionPointersimbarline(GIV(instructionPointer), GIV(framePointer), GIV(stackPointer), 0, __LINE__);
		/* begin push: */
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
		GIV(stackPointer) = _sp;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _returnValue);
		GIV(stackPointer) = _sp2;
		/* end push: */
		/* begin callEnilopmart: */
		ceEnterCogCodePopReceiverReg();
		/* end callEnilopmart: */
		{
			assert(0);
		}
	}
	/* begin push: */
	unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), _returnValue);
	GIV(stackPointer) = _sp3;
	/* end push: */
	/* begin setMethod: */
	_aMethodObj = unsignedLongAt(GIV(framePointer) + FoxMethod);
	assert(((usqInt) _aMethodObj ) >= (startOfObjectMemory(getMemoryMap())));
	{
		GIV(method) = _aMethodObj;
		assert(isOopCompiledMethod(GIV(method)));
	}
	/* end setMethod: */
	assertValidExecutionPointersimbarline(GIV(instructionPointer), GIV(framePointer), GIV(stackPointer), 1, __LINE__);
	if (((usqIntptr_t) GIV(instructionPointer) ) == (ceReturnToInterpreterPC())) {
		/* begin iframeSavedIP: */
		GIV(instructionPointer) = unsignedLongAt(GIV(framePointer) + FoxIFSavedIP);
		/* end iframeSavedIP: */
	}
	if (_inInterpreter) {
		return null;
	}
	siglongjmp(reenterInterpreter, ReturnToInterpreter);
	return (assert(0), null);
}
/*	Rewrite an existing entry in the method cache with a new primitive 
	function address. 
	Used by primitiveExternalCall to make direct calls to found external 
	prims, or quickly 
	fail not found external prims.Rewrite an existing entry in the method cache with a new primitive 
	function address. 
	Used by primitiveExternalCall to make direct calls to found external 
	prims, or quickly 
	fail not found external prims. 
	Override to do the same to the machine code call. If methodObj has a 
	cogged dual 
	rewrite the primitive call in it to call localPrimAddress. Used to update 
	calls through 
	primitiveExternalCall to directly call the target function or to revert to 
	calling primitiveExternalCall after a flush. */
/* CoInterpreter>>#rewriteMethodCacheEntryForExternalPrimitiveToFunction: */
static void NoDbgRegParms
rewriteMethodCacheEntryForExternalPrimitiveToFunction(void (*_localPrimAddress)(void))
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if ((assert(isNonImmediate(GIV(newMethod))), isCogMethodReference(unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ))))) {
		rewritePrimInvocationInto(cogMethodOf(GIV(newMethod)), ((_localPrimAddress == 0)
			 ? ((void (*)(void)) primitiveFail )
			 : _localPrimAddress));
	}
	{
		if ((GIV(methodCache)[GIV(lastMethodCacheProbeWrite) + MethodCacheMethod]) == GIV(newMethod)) {
			GIV(methodCache)[GIV(lastMethodCacheProbeWrite) + MethodCachePrimFunction] = ((sqIntptr_t) _localPrimAddress );
		}
	}
}
/* CoInterpreter>>#setDesiredCogCodeSize: */
void
setDesiredCogCodeSize(sqInt _dccs)
{
	desiredCogCodeSize = _dccs;
}
/* CoInterpreter>>#stackLimitAddress */
usqInt
stackLimitAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return (usqInt)&GIV(stackLimit);
}
/*	Return a minimum amount of headroom for each stack page (in bytes). 
	In the interpreter we don't actually need any headroom. In a JIT the stack 
	has to have room for interrupt handlers which will run on the stack. 
	Defer to the platform for this one. */
/* CoInterpreter>>#stackPageHeadroom */
static sqInt
stackPageHeadroom(void)
{
	return osCogStackPageHeadroom();
}
/* CoInterpreter>>#stackPointerAddress */
usqInt
stackPointerAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((usqInt) &GIV(stackPointer) );
}
/*	Handle the cannot return response for a base frame return to an invalid 
	context. Build a new base frame for the context in the cannot resume state 
	ready for the 
	send of cannotReturn:. 
	 
	Since we have returned from the base frame of the page the context is 
	effectively widowed. 
	But its sender needs to be contextToReturnTo, and its pc needs to be the 
	HasBeenReturnedFromMCPC marker. So bereave it (as a side-effect of 
	isWidowedContext:), assign contextToReturnTo to 
	sender, and rebuild its frame, which will have the ceCannotResumePC as its 
	pc. Finally push 
	returnValue and set instructionPointer to ceCannotResumePC in preparation 
	for the send. */
/* CoInterpreter>>#tearDownAndRebuildFrameForCannotReturnBaseFrameReturnFrom:to:returnValue: */
static void NoDbgRegParms
tearDownAndRebuildFrameForCannotReturnBaseFrameReturnFromtoreturnValue(sqInt _contextToReturnFrom, sqInt _contextToReturnTo, sqInt _returnValue)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	StackPage *_newPage;

	assert((GIV(stackPage) != 0) && (isFree(GIV(stackPage))));
	isWidowedContext(_contextToReturnFrom);
	assert(!(isMarriedOrWidowedContext(_contextToReturnFrom)));
	{
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_contextToReturnFrom)));
		if (((_contextToReturnFrom & (tagMask())) == 0) && ((_contextToReturnFrom & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_contextToReturnTo & (tagMask())) == 0) && (((_contextToReturnTo & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_contextToReturnTo >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_contextToReturnFrom)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _contextToReturnFrom);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_contextToReturnFrom)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l2;
		}
		if (_contextToReturnTo & (tagMask())) {
			goto l2;
		}
		if (!(_contextToReturnFrom >= 0x20000000000LL)) {
			goto l2;
		}
		if (_contextToReturnTo >= 0x20000000000LL) {
			goto l2;
		}
		if ((_contextToReturnTo >= GIV(nilObj)) && (_contextToReturnTo <= GIV(trueObj))) {
			goto l2;
		}
		if (!(_contextToReturnTo >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l2;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _contextToReturnFrom);
		l2:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_contextToReturnFrom + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), _contextToReturnTo);
		/* end storePointer:ofObject:withValue: */
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_contextToReturnFrom)));
		if (((_contextToReturnFrom & (tagMask())) == 0) && ((_contextToReturnFrom & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((HasBeenReturnedFromMCPCOop & (tagMask())) == 0) && (((HasBeenReturnedFromMCPCOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (HasBeenReturnedFromMCPCOop >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_contextToReturnFrom)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _contextToReturnFrom);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_contextToReturnFrom)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l4;
		}
		if (HasBeenReturnedFromMCPCOop & (tagMask())) {
			goto l4;
		}
		if (!(_contextToReturnFrom >= 0x20000000000LL)) {
			goto l4;
		}
		{
			goto l4;
		}
		if ((HasBeenReturnedFromMCPCOop >= GIV(nilObj)) && (HasBeenReturnedFromMCPCOop <= GIV(trueObj))) {
			goto l4;
		}
		if (!(HasBeenReturnedFromMCPCOop >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l4;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _contextToReturnFrom);
		l4:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_contextToReturnFrom + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), HasBeenReturnedFromMCPCOop);
		/* end storePointer:ofObject:withValue: */
	}
	_newPage = makeBaseFrameFor(_contextToReturnFrom);
	assert(GIV(stackPage) == _newPage);
	/* begin setStackPageAndLimit: */
	assert(_newPage != 0);
	GIV(stackPage) = _newPage;
	if (GIV(stackLimit) != ((char *) ((usqInt) -1 ) )) {
		GIV(stackLimit) = (GIV(stackPage)->stackLimit);
	}
	markStackPageMostRecentlyUsed(_newPage);
	/* end setStackPageAndLimit: */
	/* begin setStackPointersFromPage: */
	GIV(stackPointer) = (_newPage->headSP);
	GIV(framePointer) = (_newPage->headFP);
	/* end setStackPointersFromPage: */
	assert((stackTop()) == (ceCannotResumePC()));
	unsignedLongAtput(GIV(stackPointer), _returnValue);
	GIV(instructionPointer) = ceCannotResumePC();
}
/* CoInterpreter>>#updateStackZoneReferencesToCompiledCodePreCompaction */
void
updateStackZoneReferencesToCompiledCodePreCompaction(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_callerFP;
	sqInt _i;
	sqInt _theFlags;
	char *_theFP;
	usqInt _theIP;
	char *_theIPPtr;
	CogMethod *_theMethod;
	sqInt _theMethodField;
	StackPage *_thePage2;

	/* begin usedStackPagesDo: */
	/* begin allStackPagesDo: */
	for (_i = 0; _i < GIV(numStackPages); _i += 1) {
		/* begin stackPageAt: */
		_thePage2 = stackPageAtpages(_i, GIV(pages));
		/* end stackPageAt: */
		{
			if (!(((_thePage2->baseFP)) == 0)) {
				{
					_theIPPtr = (_thePage2->headSP);
					_theFP = (_thePage2->headFP);
					while (1) {
						if (isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) ))) {
							_theMethodField = unsignedLongAt(_theFP + FoxMethod);
							_theFlags = _theMethodField & MFMethodFlagsMask;
							_theMethod = ((CogMethod *) (_theMethodField - _theFlags) );
							_theIP = ((usqInt) (unsignedLongAt(_theIPPtr)) );
							if ((_theIP != (ceCannotResumePC())) && ((_theIP >= ((usqInt) _theMethod )) && (_theIP < (((usqInt) _theMethod ) + ((_theMethod->blockSize)))))) {
								unsignedLongAtput(_theIPPtr, _theIP + ((_theMethod->objectHeader)));
							}
							unsignedLongAtput(_theFP + FoxMethod, _theMethodField + ((_theMethod->objectHeader)));
						}
						if (!(((_callerFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP)))) != 0)) 
							break;
						_theIPPtr = _theFP + FoxCallerSavedIP;
						_theFP = _callerFP;
					}
				}
			}
		}
	}
	/* end allStackPagesDo: */
	/* end usedStackPagesDo: */
}
/*	Note that we accept anInstrPointer pointing to a callPrimitiveBytecode 
	at the start of a method that contains a primitive. This because methods 
	like Context(Part)>>reset have to be updated to skip the callPrimtiive 
	bytecode otherwise.-1 for pre-increment in fetchNextBytecode */
/* CoInterpreter>>#validInstructionPointer:inMethod:framePointer: */
sqInt
validInstructionPointerinMethodframePointer(usqInt _instrPointer, usqInt _aMethod, char *_fp)
{
	sqInt _anInstrPointer;
	CogMethod *_cogMethod;
	sqInt _header;
	usqInt _theInstrPointer;

	if (_instrPointer == (ceCannotResumePC())) {
		/* begin isMachineCodeIP: */
		_anInstrPointer = ((usqInt) (unsignedLongAt(_fp + FoxMethod)) );
		return ((usqInt) _anInstrPointer ) < (startOfObjectMemory(getMemoryMap()));
		/* end isMachineCodeIP: */
	}
	if (_instrPointer == (ceReturnToInterpreterPC())) {
		if (isMachineCodeIP(((usqInt) (unsignedLongAt(_fp + FoxMethod)) ))) {
			return 0;
		}
		/* begin iframeSavedIP: */
		_theInstrPointer = unsignedLongAt(_fp + FoxIFSavedIP);
		/* end iframeSavedIP: */
	} else {
		_theInstrPointer = _instrPointer;
		/* begin fetchPointer:ofObject: */
		_header = unsignedLongAt((_aMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((assert((((_header & 7) == 1)) || ((((usqInt) _header ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _header ) >= (minCogMethodAddress())))), (_header & (smallIntegerTag())) == 0)) && (_theInstrPointer < (startOfObjectMemory(getMemoryMap())))) {
			_cogMethod = ((CogMethod *) _header );
			return (_theInstrPointer >= (_header + (sizeof(CogMethod)))) && (_theInstrPointer < (_header + ((_cogMethod->blockSize))));
		}
	}
	{
		return (_theInstrPointer >= (((_aMethod + (lastPointerOf(_aMethod))) + BytesPerOop) - 1)) && (_theInstrPointer < ((_aMethod + (numBytesOfBytes(_aMethod))) + BaseHeaderSize));
	}
	return 0;
}
/* CoInterpreter>>#varBaseAddress */
usqInt
varBaseAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((usqInt) &GIV(stackPointer) ) - 64;
}
/*	Make sure that all VM state that affects the heap contents is voided so 
	that the heap is 
	ready to be snapshotted. If flushExtPrims is true, flush references to 
	external primitives in methods. Answer the activeContext that should be 
	stored in the snapshot.Make sure that all VM state that affects the heap contents is voided so 
	that the heap is 
	ready to be snapshotted. If flushExtPrims is true, flush references to 
	external primitives in methods. Answer the activeContext that should be 
	stored in the snapshot. */
/* CoInterpreter>>#voidVMStateForSnapshotFlushingExternalPrimitivesIf: */
static sqInt NoDbgRegParms
voidVMStateForSnapshotFlushingExternalPrimitivesIf(sqInt _flushExtPrims)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeContext;
	sqInt _activeContext2;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _fmt;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	GIV(instructionPointer) = 0;
	{
		_activeContext2 = divorceAllFrames();
		/* begin bereaveAllMarriedContextsForSnapshotFlushingExternalPrimitivesIf: */
		/* begin allObjectsDo: */
		/* begin allNewSpaceObjectsDo: */
		/* begin allNewSpaceEntitiesDo: */
		_prevPrevObj = (_prevObj = null);
		assert((((pastSpace()).start)) < (((eden()).start)));
		/* begin objectStartingAt: */
		_address = ((pastSpace()).start);
		_numSlots = byteAt(_address + 7);
		_objOop2 = ((_numSlots == (numSlotsMask()))
			 ? _address + BaseHeaderSize
			 : _address);
		/* end objectStartingAt: */
		_limit = GIV(pastSpaceStart);
		while (oopisLessThan(_objOop2, _limit)) {
			{
				assert(isEnumerableObjectNoAssert(_objOop2));
				{
					_fmt = (((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask());
					if ((_fmt == (indexablePointersFormat())) && (((longAt(_objOop2)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
						makeContextSnapshotSafe(_objOop2);
					}
					if (_flushExtPrims && (_fmt >= (firstCompiledMethodFormat()))) {
						flushExternalPrimitiveOf(_objOop2);
					}
				}
			}
			_prevPrevObj = _prevObj;
			_prevObj = _objOop2;
			/* begin objectAfter:limit: */
			_followingWordAddress = addressAfter(_objOop2);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
				_objOop2 = _limit;
				goto l2;
			}
			flag("endianness");
			_followingWord = unsignedLongAt(_followingWordAddress);
			_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress + BaseHeaderSize
				 : _followingWordAddress);
			l2:
			;
			/* end objectAfter:limit: */
		}
		/* begin objectStartingAt: */
		_address2 = ((eden()).start);
		_numSlots2 = byteAt(_address2 + 7);
		_objOop2 = ((_numSlots2 == (numSlotsMask()))
			 ? _address2 + BaseHeaderSize
			 : _address2);
		/* end objectStartingAt: */
		while (oopisLessThan(_objOop2, GIV(freeStart))) {
			{
				assert(isEnumerableObjectNoAssert(_objOop2));
				{
					_fmt = (((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask());
					if ((_fmt == (indexablePointersFormat())) && (((longAt(_objOop2)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
						makeContextSnapshotSafe(_objOop2);
					}
					if (_flushExtPrims && (_fmt >= (firstCompiledMethodFormat()))) {
						flushExternalPrimitiveOf(_objOop2);
					}
				}
			}
			_prevPrevObj = _prevObj;
			_prevObj = _objOop2;
			/* begin objectAfter:limit: */
			_followingWordAddress2 = addressAfter(_objOop2);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
				_objOop2 = GIV(freeStart);
				goto l3;
			}
			flag("endianness");
			_followingWord2 = unsignedLongAt(_followingWordAddress2);
			_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress2 + BaseHeaderSize
				 : _followingWordAddress2);
			l3:
			;
			/* end objectAfter:limit: */
		}
		/* end allNewSpaceEntitiesDo: */
		/* end allNewSpaceObjectsDo: */
		/* begin allOldSpaceObjectsDo: */
		/* begin allOldSpaceObjectsFrom:do: */
		/* begin allOldSpaceEntitiesFrom:do: */
		assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
		_prevPrevObj2 = (_prevObj2 = null);
		_objOop22 = GIV(nilObj);
		while (1) {
			assert((_objOop22 % (allocationUnit())) == 0);
			if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
				break;
			assert((uint64AtPointer(_objOop22)) != 0);
			{
				if (isEnumerableObject(_objOop22)) {
					{
						_fmt = (((usqInt) (longAt(_objOop22)) ) >> (formatShift())) & (formatMask());
						if ((_fmt == (indexablePointersFormat())) && (((longAt(_objOop22)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
							makeContextSnapshotSafe(_objOop22);
						}
						if (_flushExtPrims && (_fmt >= (firstCompiledMethodFormat()))) {
							flushExternalPrimitiveOf(_objOop22);
						}
					}
				}
			}
			_prevPrevObj2 = _prevObj2;
			_prevObj2 = _objOop22;
			/* begin objectAfter:limit: */
			_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			_followingWordAddress4 = addressAfter(_objOop22);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
				_objOop22 = _limit2;
				goto l7;
			}
			flag("endianness");
			_followingWord4 = unsignedLongAt(_followingWordAddress4);
			_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress4 + BaseHeaderSize
				 : _followingWordAddress4);
			l7:
			;
			/* end objectAfter:limit: */
		}
		/* end allOldSpaceEntitiesFrom:do: */
		/* end allOldSpaceObjectsFrom:do: */
		/* end allOldSpaceObjectsDo: */
		/* begin allPermSpaceObjectsDo: */
		_currentObject = (GIV(memoryMap)->permSpaceStart);
		while (!(_currentObject == GIV(permSpaceFreeStart))) {
			if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
				{
					_fmt = (((usqInt) (longAt(_currentObject)) ) >> (formatShift())) & (formatMask());
					if ((_fmt == (indexablePointersFormat())) && (((longAt(_currentObject)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
						makeContextSnapshotSafe(_currentObject);
					}
					if (_flushExtPrims && (_fmt >= (firstCompiledMethodFormat()))) {
						flushExternalPrimitiveOf(_currentObject);
					}
				}
			}
			/* begin objectAfter:limit: */
			_followingWordAddress3 = addressAfter(_currentObject);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
				_currentObject = GIV(permSpaceFreeStart);
				goto l6;
			}
			flag("endianness");
			_followingWord3 = unsignedLongAt(_followingWordAddress3);
			_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress3 + BaseHeaderSize
				 : _followingWordAddress3);
			l6:
			;
			/* end objectAfter:limit: */
		}
		/* end allPermSpaceObjectsDo: */
		/* end allObjectsDo: */
		/* end bereaveAllMarriedContextsForSnapshotFlushingExternalPrimitivesIf: */
		_activeContext = _activeContext2;
	}
	voidCogCompiledCode();
	return _activeContext;
}
/* CoInterpreter>>#whereIs: */
char *
whereIs(sqInt _anOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_somewhere;

	{
		_somewhere = whereIsMaybeCodeThing(_anOop);
		if (!(_somewhere == null)) {
			return _somewhere;
		}
	}
	{
		char *_where;

		{
			/* begin whereIsMaybeHeapThing: */
			if ((oopisLessThan(_anOop, (GIV(memoryMap)->newSpaceEnd))) && (oopisGreaterThanOrEqualTo(_anOop, (GIV(memoryMap)->newSpaceStart)))) {
				if (oopisGreaterThanOrEqualToandLessThan(_anOop, ((eden()).start), GIV(freeStart))) {
					_where = " is in eden";
					goto l3;
				}
				if (oopisGreaterThanOrEqualToandLessThan(_anOop, ((futureSpace()).start), futureSurvivorStart())) {
					_where = " is in future space";
					goto l3;
				}
				if (oopisGreaterThanOrEqualToandLessThan(_anOop, ((pastSpace()).start), GIV(pastSpaceStart))) {
					_where = " is in past space";
					goto l3;
				}
				_where = " is in new space";
				goto l3;
			}
			if (oopisGreaterThanOrEqualToandLessThan(_anOop, (GIV(memoryMap)->oldSpaceStart), (GIV(memoryMap)->oldSpaceEnd))) {
				if (segmentContainingObj(_anOop)) {
					_where = " is in old space";
					goto l3;
				}
				_where = " is between old space segments";
				goto l3;
			}
			if (oopisGreaterThanOrEqualToandLessThan(_anOop, (GIV(memoryMap)->permSpaceStart), (GIV(memoryMap)->permSpaceEnd))) {
				_where = " is in permanent space";
				goto l3;
			}
			_where = null;
			l3:
			;
			/* end whereIsMaybeHeapThing: */
			if (!(_where == null)) {
				return _where;
			}
		}
		{
			/* begin whereIsMaybeStackThing: */
			if (oopisGreaterThanOrEqualToandLessThan(_anOop, GIV(stackBasePlus1) - 1, GIV(pages))) {
				_where = " is in the stack zone";
				goto l2;
			}
			_where = null;
			l2:
			;
			/* end whereIsMaybeStackThing: */
			if (!(_where == null)) {
				return _where;
			}
		}
		return " is no where obvious";
	}
	return 0;
}
/*	Either widow the context or map its pc to a bytecode one. 
	Used to implement primitiveVoidVMStateForMethod.for debugging & saving space */
/* CoInterpreter>>#widowOrForceToBytecodePC: */
static void NoDbgRegParms NeverInline
widowOrForceToBytecodePC(sqInt _ctxt)
{
	if ((((unsignedLongAt((_ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
		if (!(isWidowedContext(_ctxt))) {
			assert(!(isMachineCodeFrame(frameOfMarriedContext(_ctxt))));
		}
	} else {
		ensureContextHasBytecodePC(_ctxt);
	}
}
/*	Machine code primitive for hash multiply. c.f. primitiveHashMultiply. 
	mcprims consume receiver and arguments as parameters and answer the 
	result on success, or set the primitive error code and answer 0 on 
	failure. Implement 28-bit hashMultiply for SmallInteger and LargePositiveInteger 
	receivers.  */
/* CoInterpreterPrimitives>>#mcprimHashMultiply: */
sqInt
mcprimHashMultiply(sqInt _receiverArg)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _ccIndex;
	sqInt _classOop;
	sqInt _ok;
	sqInt _value;

	if (((_receiverArg & 7) == 1)) {
		_value = _receiverArg >> 3;
	} else {
		/* begin is:instanceOf:compactClassIndex: */
		_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
		if (_receiverArg & (tagMask())) {
			_ok = 0;
			goto l3;
		}
		/* begin isClassOfNonImm:equalTo:compactClassIndex: */
		assert(!(isImmediate(_receiverArg)));
		/* begin classIndexOf: */
		_ccIndex = (longAt(_receiverArg)) & (classIndexMask());
		/* end classIndexOf: */
		{
			_ok = ClassLargePositiveIntegerCompactIndex == _ccIndex;
			goto l3;
		}
		/* end isClassOfNonImm:equalTo:compactClassIndex: */
		l3:
		;
		/* end is:instanceOf:compactClassIndex: */
		if (!_ok) {
			GIV(primFailCode) = PrimErrBadReceiver;
			return 0;
		}
		_value = SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_receiverArg + BaseHeaderSize) + (0U << 2)));
	}
	return ((((usqInt) ((_value * HashMultiplyConstant) & 0xFFFFFFF) ) << 3) | 1);
}
/*	Answer the contents of the code zone as an array of pair-wise element, 
	address in ascending 
	address order. Answer a string for a runtime routine or abstract label 
	(beginning, end, etc), 
	a CompiledMethod for a CMMethod, or a selector (presumably a Symbol) for a 
	PIC. If there is an argument and it is true, then collect inner 
	information about the CogMethod. */
/* CoInterpreterPrimitives>>#primitiveCollectCogCodeConstituents */
static void
primitiveCollectCogCodeConstituents(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _constituents;
	char *_sp;
	sqInt _withDetails;

	if (GIV(argumentCount) == 0) {
		_withDetails = 0;
	} else {
		_withDetails = unsignedLongAt(GIV(stackPointer));
		if (!((_withDetails == GIV(trueObj)) || (_withDetails == GIV(falseObj)))) {
			GIV(primFailCode) = PrimErrBadArgument;
			return;
		}
		_withDetails = _withDetails == GIV(trueObj);
	}
	_constituents = cogCodeConstituents(_withDetails);
	if (!_constituents) {
		GIV(primFailCode) = PrimErrNoMemory;
		return;
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _constituents);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Lift the veil from a context and answer an integer describing its interior 
	state. Used for e.g. VM tests so they can verify they're testing what they 
	think they're testing. 
	0 implies a vanilla heap context. 
	Bit 0 = is or was married to a frame 
	Bit 1 = is still married to a frame 
	Bit 2 = frame is executing machine code 
	Bit 3 = has machine code pc (as opposed to nil or a bytecode pc) 
	Bit 4 = method is currently compiled to machine code */
/* CoInterpreterPrimitives>>#primitiveContextXray */
static void
primitiveContextXray(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _context;
	int _flags;
	sqInt _pc;
	sqInt _senderOop;
	char *_sp;
	char *_theFP;
	sqInt _theMethod;

	_context = unsignedLongAt(GIV(stackPointer));
	_pc = unsignedLongAt((_context + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ));
	if ((((unsignedLongAt((_context + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
		if (checkIsStillMarriedContextcurrentFP(_context, GIV(framePointer))) {
			/* begin frameOfMarriedContext: */
			/* begin fetchPointer:ofObject: */
			_senderOop = unsignedLongAt((_context + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			{
				assert(((_senderOop & 7) == 1));
				_theFP = pointerForOop(_senderOop - 1);
			}
			/* end frameOfMarriedContext: */
			if (isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) ))) {
				_flags = 7;
			} else {
				_flags = 3;
			}
		} else {
			_flags = 1;
		}
	} else {
		_flags = 0;
	}
	if ((((_pc & 7) == 1)) && ((_pc >> 3) < 0)) {
		_flags = _flags | 8;
	}
	_theMethod = unsignedLongAt((_context + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ));
	if (((_theMethod & (tagMask())) == 0) && ((((((usqInt) (longAt(_theMethod)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && (isCogMethodReference(unsignedLongAt((_theMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) )))))) {
		_flags = _flags | 16;
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), ((((usqInt) _flags ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	The receiver is a compiledMethod. Clear all entries in the method lookup 
	cache that refer to this method, presumably because it has been redefined, 
	overridden or removed.The receiver is a compiledMethod. Clear all entries in the method lookup 
	cache that 
	refer to this method, presumably because it has been redefined, overridden 
	or removed. 
	Override to flush appropriate machine code caches also. */
/* CoInterpreterPrimitives>>#primitiveFlushCacheByMethod */
static void
primitiveFlushCacheByMethod(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _oldMethod;
	int _probe;

	{
		/* begin flushMethodCacheForMethod: */
		_oldMethod = unsignedLongAt(GIV(stackPointer));
		_probe = 0;
		for (_i = 1; _i <= MethodCacheEntries; _i += 1) {
			if ((GIV(methodCache)[_probe + MethodCacheMethod]) == _oldMethod) {
				GIV(methodCache)[_probe + MethodCacheSelector] = 0;
			}
			_probe += MethodCacheEntrySize;
		}
		flushExternalPrimitiveOf(_oldMethod);
		/* end flushMethodCacheForMethod: */
	}
	unlinkSendsToandFreeIf(unsignedLongAt(GIV(stackPointer)), 0);
}
/*	The receiver is a message selector. Clear all entries in the method lookup 
	cache with this selector, presumably because an associated method has been 
	redefined. Override to also flush machine code caches. */
/* CoInterpreterPrimitives>>#primitiveFlushCacheBySelector */
static void
primitiveFlushCacheBySelector(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	int _probe;
	sqInt _selector;

	_selector = unsignedLongAt(GIV(stackPointer));
	_probe = 0;
	for (_i = 1; _i <= MethodCacheEntries; _i += 1) {
		if ((GIV(methodCache)[_probe + MethodCacheSelector]) == _selector) {
			GIV(methodCache)[_probe + MethodCacheSelector] = 0;
		}
		_probe += MethodCacheEntrySize;
	}
	{
		fetchPointerofObject(16 * 2, splObj(SpecialSelectors));
		fetchPointerofObject(17 * 2, splObj(SpecialSelectors));
	}
	unlinkSendsOfisMNUSelector(_selector, _selector == (unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorDoesNotUnderstand ) << (shiftForWord())) ))));
}
/* CoInterpreterPrimitives>>#primitiveFunctionPointerAddress */
usqInt
primitiveFunctionPointerAddress(void)
{
	return ((usqInt) &primitiveFunctionPointer );
}
/*	Primitive. Install the semaphore to be used for collecting long-running 
	primitives,  
	or nil if no semaphore should be used. */
/* CoInterpreterPrimitives>>#primitiveLongRunningPrimitiveSemaphore */
EXPORT(sqInt)
primitiveLongRunningPrimitiveSemaphore(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeContext;
	int _flushState;
	sqInt _sema;
	char *_sp;

	if (GIV(argumentCount) != 1) {
		return (GIV(primFailCode) = PrimErrBadNumArgs);
	}
	_sema = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	if (_sema == GIV(nilObj)) {
		_flushState = GIV(longRunningPrimitiveCheckSemaphore) != null;
		GIV(longRunningPrimitiveCheckSemaphore) = null;
	} else {
		_flushState = GIV(longRunningPrimitiveCheckSemaphore) == null;
		if (!(((_sema & (tagMask())) == 0) && (((longAt(_sema)) & (classIndexMask())) == (rawHashBitsOf(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassSemaphore ) << (shiftForWord())) ))))))) {
			return (GIV(primFailCode) = PrimErrBadArgument);
		}
		GIV(longRunningPrimitiveCheckSemaphore) = _sema;
	}
	if (_flushState) {
		/* begin push: */
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
		GIV(stackPointer) = _sp;
		/* end push: */
		_activeContext = voidVMStateForSnapshotFlushingExternalPrimitivesIf(0);
		marryContextInNewStackPageAndInitializeInterpreterRegisters(_activeContext);
		assert((((stackValue(0)) == (nilObject())) && (GIV(longRunningPrimitiveCheckSemaphore) == null)) || (((stackValue(0)) == GIV(longRunningPrimitiveCheckSemaphore)) && (isSemaphoreOop(_sema))));
	}
	voidLongRunningPrimitive("install");
	/* begin pop: */
	GIV(stackPointer) += 1 * BytesPerWord;
	/* end pop: */
	if (_flushState) {
		siglongjmp(reenterInterpreter, ReturnToInterpreter);
	}
	return 0;
}
/* CoInterpreterPrimitives>>#primitiveMethodPCData */
EXPORT(sqInt)
primitiveMethodPCData(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classObj;
	sqInt _classObj2;
	sqInt _cm;
	CogMethod *_cogMethod;
	sqInt _data;
	sqInt _data2;
	sqInt _methodHeader;
	sqInt _methodReceiver;
	sqInt _nEntries;
	sqInt _nSlots;
	char *_sp;

	if (GIV(argumentCount) != 0) {
		return (GIV(primFailCode) = PrimErrBadNumArgs);
	}
	_methodReceiver = unsignedLongAt(GIV(stackPointer));
	_data = 0;
	if ((assert(isNonImmediate(_methodReceiver)), isCogMethodReference(unsignedLongAt((_methodReceiver + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ))))) {
		/* begin pcDataFor: */
		/* begin cogMethodOf: */
		/* begin fetchPointer:ofObject: */
		_methodHeader = unsignedLongAt((_methodReceiver + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert((isNonImmediate(_methodHeader)) && (((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))));
		_cogMethod = ((CogMethod *) _methodHeader );
		/* end cogMethodOf: */
		_cm = (_cogMethod->methodObject);
		_nSlots = (((byteSizeOf(_cm)) - (((literalCountOfMethodHeader(methodHeaderOf(_cm))) + LiteralStart) * BytesPerOop)) * 2) + ((8 * 2) / BytesPerOop);
		/* begin instantiateClass:indexableSize: */
		_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ));
		_data2 = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, _nSlots, 0, 0);
		/* end instantiateClass:indexableSize: */
		if (!_data2) {
			_data = -1;
			goto l3;
		}
		_nEntries = mapPCDataForinto(_cogMethod, _data2);
		if (_nEntries == 0) {
			_data = 0;
			goto l3;
		}
		if (_nEntries < _nSlots) {
			shortentoIndexableSize(_data2, _nEntries);
		}
		_data = _data2;
		l3:
		;
		/* end pcDataFor: */
		if (_data == -1) {
			return (GIV(primFailCode) = PrimErrNoMemory);
		}
	}
	if (_data == 0) {
		/* begin instantiateClass:indexableSize: */
		_classObj2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ));
		_data = instantiateClassindexableSizeisPinnedisOldSpace(_classObj2, 0, 0, 0);
		/* end instantiateClass:indexableSize: */
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), _data);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	return 0;
}
/* CoInterpreterPrimitives>>#primitiveMethodProfilingData */
EXPORT(void)
primitiveMethodProfilingData(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classObj;
	sqInt _classObj2;
	sqInt _cm;
	CogMethod *_cogMethod;
	sqInt _data;
	sqInt _data2;
	sqInt _methodHeader;
	sqInt _methodReceiver;
	sqInt _nEntries;
	sqInt _nSlots;
	char *_sp;

	if (GIV(argumentCount) != 0) {
		GIV(primFailCode) = PrimErrBadNumArgs;
		return;
	}
	_methodReceiver = unsignedLongAt(GIV(stackPointer));
	_data = 0;
	if ((assert(isNonImmediate(_methodReceiver)), isCogMethodReference(unsignedLongAt((_methodReceiver + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ))))) {
		/* begin profilingDataFor: */
		/* begin cogMethodOf: */
		/* begin fetchPointer:ofObject: */
		_methodHeader = unsignedLongAt((_methodReceiver + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert((isNonImmediate(_methodHeader)) && (((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))));
		_cogMethod = ((CogMethod *) _methodHeader );
		/* end cogMethodOf: */
		_cm = (_cogMethod->methodObject);
		_nSlots = ((byteSizeOf(_cm)) - (((literalCountOfMethodHeader(methodHeaderOf(_cm))) + LiteralStart) * BytesPerOop)) + ((8 * 2) / BytesPerOop);
		/* begin instantiateClass:indexableSize: */
		_classObj2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ));
		_data2 = instantiateClassindexableSizeisPinnedisOldSpace(_classObj2, _nSlots, 0, 0);
		/* end instantiateClass:indexableSize: */
		if (!_data2) {
			_data = -1;
			goto l4;
		}
		_nEntries = profilingDataForinto(_cogMethod, _data2);
		if (_nEntries == 0) {
			_data = 0;
			goto l4;
		}
		if (_nEntries < _nSlots) {
			shortentoIndexableSize(_data2, _nEntries);
		}
		_data = _data2;
		l4:
		;
		/* end profilingDataFor: */
		if (_data == -1) {
			GIV(primFailCode) = PrimErrNoMemory;
			return;
		}
	}
	if (_data == 0) {
		/* begin instantiateClass:indexableSize: */
		_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ));
		_data = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, 0, 0, 0);
		/* end instantiateClass:indexableSize: */
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), _data);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Lift the veil from a method and answer an integer describing the interior 
	state of its machine code. 
	Used for e.g. VM tests so they can verify they're testing what they think 
	they're testing. 
	0 implies a vanilla method. 
	Bit 0 = method might be compiled to machine code 
	Bit 1 = method is currently compiled to machine code 
	Bit 2 = is compiled frameless. 
	Bit 3 = method refers to young object. 
	Bit 4 = method too big to be jitted (more than 64k of code, or needs more 
	than 1.5Mb of stack space to compile) 
	Bit 5 = method contains unknown/unjittable bytecode 
	Bit 6 = method should not be jitted because it contains a primitive not to 
	be called from machine code (unused) */
/* CoInterpreterPrimitives>>#primitiveMethodXray */
static void
primitiveMethodXray(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _alreadyCogged;
	sqInt _aMethodOop;
	sqInt _anOop;
	CogMethod *_cogMethod;
	int _flags;
	sqInt _methodHeader;
	char *_sp;
	char *_theSP;

	if (methodWithHeaderShouldBeCogged(methodHeaderOf(unsignedLongAt(GIV(stackPointer))))) {
		/* begin maybeMethodHasCogMethod: */
		_anOop = unsignedLongAt(GIV(stackPointer));
		_alreadyCogged = ((_anOop & (tagMask())) == 0) && ((((((usqInt) (longAt(_anOop)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && (isCogMethodReference(unsignedLongAt((_anOop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) )))));
		/* end maybeMethodHasCogMethod: */
		_flags = 1;
		if (_alreadyCogged) {
			_flags += 2;
		} else {
			_cogMethod = cogselector(unsignedLongAt(GIV(stackPointer)), GIV(nilObj));
			if ((_cogMethod == null) && GIV(cogCompiledCodeCompactionCalledFor)) {
				/* begin writeBackHeadFramePointers */
				assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
				assert(GIV(stackPage) == (mostRecentlyUsedPage()));
				assert(!(isFree(GIV(stackPage))));
				/* begin setHeadFP:andSP:inPage: */
				_theSP = GIV(stackPointer);
				assert(_theSP < GIV(framePointer));
				assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
				assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
				{
					(GIV(stackPage)->headFP = GIV(framePointer));
					(GIV(stackPage)->headSP = _theSP);
				}
				/* end setHeadFP:andSP:inPage: */
				assert(pageListIsWellFormed());
				/* end writeBackHeadFramePointers */
				commenceCogCompiledCodeCompaction();
				_cogMethod = cogselector(unsignedLongAt(GIV(stackPointer)), GIV(nilObj));
			}
			switch (((sqInt) _cogMethod )) {
				case MethodTooBig:
				{
					_flags += 16;
				}
				break;
				case EncounteredUnknownBytecode:
				{
					_flags += 32;
				}
				break;
				case ShouldNotJIT:
				{
					_flags += 64;
				}
				break;
				default:
				{
					assert(!((((sqInt) _cogMethod ) >= MaxNegativeErrorCode) && (((sqInt) _cogMethod ) <= NotFullyInitialized)));
				}
			}
		}
		if (maybeMethodHasCogMethod(unsignedLongAt(GIV(stackPointer)))) {
			/* begin cogMethodOf: */
			_aMethodOop = unsignedLongAt(GIV(stackPointer));
			/* begin fetchPointer:ofObject: */
			_methodHeader = unsignedLongAt((_aMethodOop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			assert((isNonImmediate(_methodHeader)) && (((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))));
			_cogMethod = ((CogMethod *) _methodHeader );
			/* end cogMethodOf: */
			if (((_cogMethod->stackCheckOffset)) == 0) {
				_flags += 4;
			}
			if ((_cogMethod->cmRefersToYoung)) {
				_flags += 8;
			}
			if (!_alreadyCogged) {
				safeFreeMethod(_cogMethod);
			}
		}
	} else {
		_flags = 0;
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), ((((usqInt) _flags ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* CoInterpreterPrimitives>>#primitiveMinimumUnusedHeadroom */
EXPORT(void)
primitiveMinimumUnusedHeadroom(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _oop;
	char *_sp;

	/* begin methodReturnValue: */
	_oop = ((((usqInt) (minimumUnusedHeadroom()) ) << 3) | 1);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	/* end methodReturnValue: */
}
/*	Defined for CompiledMethods only */
/* CoInterpreterPrimitives>>#primitiveObjectAt */
static void
primitiveObjectAt(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _index;
	sqInt _integerPointer;
	sqInt _oop;
	sqInt _rawHeader;
	sqInt _realHeader;
	char *_sp;
	sqInt _thisReceiver;

	/* begin stackIntegerValue: */
	_integerPointer = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_index = _integerPointer >> 3;
		goto l3;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_index = 0;
		goto l3;
	}
	/* end checkedIntegerValueOf: */
	l3:
	;
	/* end stackIntegerValue: */
	if (GIV(primFailCode)) {
		GIV(primFailCode) = PrimErrBadArgument;
		return;
	}
	_thisReceiver = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* begin fetchPointer:ofObject: */
	_rawHeader = unsignedLongAt((_thisReceiver + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	_realHeader = (((assert((((_rawHeader & 7) == 1)) || ((((usqInt) _rawHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _rawHeader ) >= (minCogMethodAddress())))), (_rawHeader & (smallIntegerTag())) == 0))
		 ? ((((CogMethod *) _rawHeader ))->methodHeader)
		 : _rawHeader);
	if (!((_index > 0) && (_index <= (((assert(((_realHeader & 7) == 1)), (_realHeader >> 3) & AlternateHeaderNumLiteralsMask)) + LiteralStart)))) {
		GIV(primFailCode) = PrimErrBadIndex;
		return;
	}
	/* begin pop:thenPush: */
	_oop = ((_index == 1)
		 ? _realHeader
		 : unsignedLongAt((_thisReceiver + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << (shiftForWord())) )));
	unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Store a literal into a CompiledMethod at the given index. Defined for 
	CompiledMethods only. */
/* CoInterpreterPrimitives>>#primitiveObjectAtPut */
static void
primitiveObjectAtPut(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _index;
	sqInt _newValue;
	sqInt _rawHeader;
	sqInt _realHeader;
	char *_sp;
	sqInt _thisReceiver;

	_newValue = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if ((_index & (smallIntegerTag())) == 0) {
		GIV(primFailCode) = PrimErrBadArgument;
		return;
	}
	_index = _index >> 3;
	_thisReceiver = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	if (
#    if IMMUTABILITY
			(/* begin isImmutable: */ ((((usqInt) (longAt(_thisReceiver)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#    else /* IMMUTABILITY */
			0
#    endif /* IMMUTABILITY */
			) {
		GIV(primFailCode) = PrimErrNoModification;
		return;
	}
	/* begin fetchPointer:ofObject: */
	_rawHeader = unsignedLongAt((_thisReceiver + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	_realHeader = (((assert((((_rawHeader & 7) == 1)) || ((((usqInt) _rawHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _rawHeader ) >= (minCogMethodAddress())))), (_rawHeader & (smallIntegerTag())) == 0))
		 ? ((((CogMethod *) _rawHeader ))->methodHeader)
		 : _rawHeader);
	if (!((_index > 0) && (_index <= (((assert(((_realHeader & 7) == 1)), (_realHeader >> 3) & AlternateHeaderNumLiteralsMask)) + LiteralStart)))) {
		GIV(primFailCode) = PrimErrBadIndex;
		return;
	}
	if (_index == 1) {
		if (((_newValue & (smallIntegerTag())) == 0) || (((assert(((_newValue & 7) == 1)), (_newValue >> 3) & AlternateHeaderNumLiteralsMask)) != ((assert(((_realHeader & 7) == 1)), (_realHeader >> 3) & AlternateHeaderNumLiteralsMask)))) {
			GIV(primFailCode) = PrimErrBadArgument;
			return;
		}
		if ((assert((((_rawHeader & 7) == 1)) || ((((usqInt) _rawHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _rawHeader ) >= (minCogMethodAddress())))), (_rawHeader & (smallIntegerTag())) == 0)) {
			setHeaderOopOfto(((CogMethod *) _rawHeader ), _newValue);
		} else {
			{
				assert(!(isOopForwarded(_thisReceiver)));
				longAtput((_thisReceiver + BaseHeaderSize) + (0U << (shiftForWord())), _newValue);
			}
		}
	} else {
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_thisReceiver)));
		if (((_thisReceiver & (tagMask())) == 0) && ((_thisReceiver & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_newValue & (tagMask())) == 0) && (((_newValue & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_newValue >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_thisReceiver)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _thisReceiver);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_thisReceiver)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l4;
		}
		if (_newValue & (tagMask())) {
			goto l4;
		}
		if (!(_thisReceiver >= 0x20000000000LL)) {
			goto l4;
		}
		if (_newValue >= 0x20000000000LL) {
			goto l4;
		}
		if ((_newValue >= GIV(nilObj)) && (_newValue <= GIV(trueObj))) {
			goto l4;
		}
		if (!(_newValue >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l4;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _thisReceiver);
		l4:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_thisReceiver + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << (shiftForWord())) ), _newValue);
		/* end storePointer:ofObject:withValue: */
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((3 - 1) * BytesPerWord)), _newValue);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Primitive. Install the semaphore to be used for profiling,  
	or nil if no semaphore should be used. 
	See also primitiveProfileStart. */
/* CoInterpreterPrimitives>>#primitiveProfileSemaphore */
EXPORT(sqInt)
primitiveProfileSemaphore(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeContext;
	int _flushState;
	sqInt _sema;
	char *_sp;

	if (GIV(argumentCount) != 1) {
		return (GIV(primFailCode) = PrimErrBadNumArgs);
	}
	_sema = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	if (_sema == GIV(nilObj)) {
		_flushState = GIV(profileSemaphore) != GIV(nilObj);
	} else {
		_flushState = GIV(profileSemaphore) == GIV(nilObj);
		if (!(((_sema & (tagMask())) == 0) && (((longAt(_sema)) & (classIndexMask())) == (rawHashBitsOf(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassSemaphore ) << (shiftForWord())) ))))))) {
			return (GIV(primFailCode) = PrimErrBadArgument);
		}
	}
	GIV(profileSemaphore) = _sema;
	if (_flushState) {
		/* begin push: */
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
		GIV(stackPointer) = _sp;
		/* end push: */
		_activeContext = voidVMStateForSnapshotFlushingExternalPrimitivesIf(0);
		marryContextInNewStackPageAndInitializeInterpreterRegisters(_activeContext);
		assert((((stackValue(0)) == (nilObject())) && (GIV(profileSemaphore) == (nilObject()))) || (((stackValue(0)) == GIV(profileSemaphore)) && (isSemaphoreOop(_sema))));
	}
	GIV(profileProcess) = (GIV(profileMethod) = GIV(nilObj));
	/* begin pop: */
	GIV(stackPointer) += 1 * BytesPerWord;
	/* end pop: */
	if (_flushState) {
		siglongjmp(reenterInterpreter, ReturnToInterpreter);
	}
	return 0;
}
/*	Synchronously signal the semaphore. 
	This may change the active process as a result.We may be about to switch process, either to an interpreted frame or a 
	machine code frame. To know whether to return or enter machine code 
	we have to know from whence we came. We could have come from the 
	interpreter, either directly or via a machine code primitive. We could 
	have come from machine code. The instructionPointer tells us where from: */
/* CoInterpreterPrimitives>>#primitiveSignal */
static void
primitiveSignal(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _inInterpreter;

	_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	if (synchronousSignal(unsignedLongAt(GIV(stackPointer)))) {
		/* begin forProcessPrimitiveReturnToExecutivePostContextSwitch: */
		if (GIV(nextProfileTick) > 0) {
			checkProfileTick(GIV(newMethod));
		}
		returnToExecutivepostContextSwitch(_inInterpreter, 1);
		/* end forProcessPrimitiveReturnToExecutivePostContextSwitch: */
	}
}
/*	Save a normal snapshot under the same name as it was loaded 
	unless it has been renamed by the last primitiveImageName. 
	 
	Override to jump to the interpreter because the machine code zone is now 
	void.  */
/* CoInterpreterPrimitives>>#primitiveSnapshot */
static void
primitiveSnapshot(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeContext;
	sqInt _activeProc;
	SpurImageHeaderStruct _header;
	SpurImageHeaderStruct _header2;
	sqInt _header3;
	sqInt _i;
	extern char _imageName[];
	sqInt _integerPointer;
	sqInt _methodHeader;
	sqInt _newFormatToUse;
	sqInt _numArgs;
	sqInt _numTemps;
	sqInt _object;
	sqInt _object2;
	sqInt _object3;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _oop;
	sqInt _rcvr;
	sqInt _rcvr2;
	sqInt _savedTenuringThreshold;
	sqInt _shouldSkipStoreBytecode;
	size_t _sizeToWrite;
	char *_sp;
	char *_sp2;
	char *_sp22;
	char *_sp23;
	char *_sp3;
	char *_sp32;
	char *_sp4;
	char *_sp42;
	char *_sp5;
	char *_sp6;
	char *_sp7;
	char *_sp8;
	sqInt _stackIndex;
	int _stackModified;
	sqInt _threshold;
	sqInt _valuePointer;

	/* begin snapshot */
	if (GIV(argumentCount) > 1) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadNumArgs;
		/* end primitiveFailFor: */
		activateNewMethod();
		goto l28;
	}
	_newFormatToUse = 0;
	_rcvr = 0;
	if (GIV(argumentCount) == 1) {
		/* begin stackIntegerValue: */
		_integerPointer = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
		/* begin checkedIntegerValueOf: */
		if (((_integerPointer & 7) == 1)) {
			_newFormatToUse = _integerPointer >> 3;
			goto l15;
		} else {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			_newFormatToUse = 0;
			goto l15;
		}
		/* end checkedIntegerValueOf: */
		l15:
		;
		/* end stackIntegerValue: */
		if ((_newFormatToUse >= 3) && (_newFormatToUse <= 4)) {
			/* begin setFormatToUse: */
			GIV(formatToUse) = _newFormatToUse;
			/* end setFormatToUse: */
		} else {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			activateNewMethod();
			goto l28;
		}
	}
	_stackModified = 0;
	/* begin push: */
	unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
	GIV(stackPointer) = _sp3;
	/* end push: */
	_activeContext = voidVMStateForSnapshotFlushingExternalPrimitivesIf(1);
	/* begin memoryActiveProcess */
	/* begin fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	_activeProc = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end memoryActiveProcess */
	/* begin storePointer:ofObject:withValue: */
	assert(!(isForwarded(_activeProc)));
	if (((_activeProc & (tagMask())) == 0) && ((_activeProc & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((_activeContext & (tagMask())) == 0) && (((_activeContext & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_activeContext >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_activeProc)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _activeProc);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(_activeProc)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l12;
	}
	if (_activeContext & (tagMask())) {
		goto l12;
	}
	if (!(_activeProc >= 0x20000000000LL)) {
		goto l12;
	}
	if (_activeContext >= 0x20000000000LL) {
		goto l12;
	}
	if ((_activeContext >= GIV(nilObj)) && (_activeContext <= GIV(trueObj))) {
		goto l12;
	}
	if (!(_activeContext >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l12;
	}
	remember(getFromPermToNewSpaceRememberedSet(), _activeProc);
	l12:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((_activeProc + BaseHeaderSize) + ((sqInt) (((usqInt) SuspendedContextIndex ) << (shiftForWord())) ), _activeContext);
	/* end storePointer:ofObject:withValue: */
	GIV(tempOop) = _activeContext;
	logDebug("Garbage Collect for Snapshot");
	/* begin garbageCollectForSnapshot */
	/* begin flushNewSpace */
	/* begin getRawTenuringThreshold */
	_savedTenuringThreshold = GIV(tenureThreshold);
	/* end getRawTenuringThreshold */
	/* begin setRawTenuringThreshold: */
	_threshold = ((sqInt) ((GIV(memoryMap)->newSpaceEnd)) );
	GIV(tenureThreshold) = _threshold;
	/* end setRawTenuringThreshold: */
	scavengingGCTenuringIf(TenureByAge);
	/* begin setRawTenuringThreshold: */
	GIV(tenureThreshold) = _savedTenuringThreshold;
	/* end setRawTenuringThreshold: */
	assert(((GIV(fromOldSpaceRememberedSet)->rememberedSetSize)) == 0);
	assert(GIV(pastSpaceStart) == (((pastSpace()).start)));
	assert(GIV(freeStart) == (((eden()).start)));
	/* end flushNewSpace */
	flag("If we wanted to shrink the rememberedSet prior to snapshot this is the place to do it.");
	/* begin biasForSnapshot */
	GIV(biasForGC) = 0;
	/* end biasForSnapshot */
	fullGC();
	/* begin biasForGC */
	GIV(biasForGC) = 1;
	/* end biasForGC */
	prepareForSnapshot();
	/* begin checkFreeSpace: */
	assert(bitsSetInFreeSpaceMaskForAllFreeLists());
	assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
	if ((checkForLeaks & (GCModeFreeSpace | GCModeFull)) == (GCModeFreeSpace | GCModeFull)) {
		runLeakCheckerForFreeSpace(GCModeFreeSpace);
	}
	/* end checkFreeSpace: */
	/* end garbageCollectForSnapshot */
	_activeContext = GIV(tempOop);
	GIV(tempOop) = 0;
	if (!GIV(primFailCode)) {
		/* begin quickFetchInteger:ofObject: */
		/* begin fetchPointer:ofObject: */
		_oop = unsignedLongAt((_activeContext + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert(((_oop & 7) == 1));
		_stackIndex = _oop >> 3;
		/* end quickFetchInteger:ofObject: */
		if (GIV(argumentCount) == 1) {
			_stackIndex -= 1;
			/* begin storeInteger:ofObject:withValue: */
			if ((((((usqInt) _stackIndex ) >> 60) + 1) & 15) <= 1) {
				/* begin storePointerUnchecked:ofObject:withValue: */
				assert(!(isOopForwarded(_activeContext)));
				longAtput((_activeContext + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ), ((((usqInt) _stackIndex ) << 3) | 1));
				/* end storePointerUnchecked:ofObject:withValue: */
			} else {
				/* begin primitiveFail */
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
				/* end primitiveFail */
			}
			/* end storeInteger:ofObject:withValue: */
		}
		/* begin fetchPointer:ofObject: */
		_rcvr = unsignedLongAt((_activeContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((_stackIndex + CtxtTempFrameStart) - 1) ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* begin storePointerUnchecked:ofObject:withValue: */
		_valuePointer = GIV(trueObj);
		assert(!(isOopForwarded(_activeContext)));
		longAtput((_activeContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((_stackIndex + CtxtTempFrameStart) - 1) ) << (shiftForWord())) ), _valuePointer);
		/* end storePointerUnchecked:ofObject:withValue: */
		_stackModified = 1;
		/* begin writeImageFileIO */
		/* begin simulationOnly: */
		/* end simulationOnly: */
		/* begin writeImageFile:fromHeader: */
		/* begin newHeader */
		/* begin simulationOnly: */
		/* end simulationOnly: */
		(_header2.imageFormat = 68021);
		(_header2.imageHeaderSize = 128);
		/* begin imageSizeToWrite */
		assert(newSpaceIsEmpty());
		_sizeToWrite = (totalBytesInNonEmptySegments()) + (totalBytesInPermanentSpace());
		/* end imageSizeToWrite */
		(_header2.dataSize = _sizeToWrite);
		(_header2.hdrOldSpaceSize = oldSpaceSizeToWrite());
		(_header2.oldBaseAddr = ((getMemoryMap())->oldSpaceStart));
		(_header2.initialSpecialObjectsOop = GIV(specialObjectsOop));
		(_header2.hdrLastHash = GIV(lastHash));
		(_header2.headerFlags = (((((VMBIGENDIAN)
			 ? 0
			 : 2)) + (((GIV(preemptionYields))
			 ? 0
			 : 16))) + ((GIV(imageHeaderFlags) | 211) - 211)) + (((GIV(flagInterpretedMethods))
			 ? 8
			 : 0)));
		(_header2.extraVMMemory = ((!extraVMMemory)
			 ? 0
			 : extraVMMemory));
		(_header2.hdrNumStackPages = desiredNumStackPages);
		(_header2.hdrCogCodeSize = (desiredCogCodeSize + 0x3FF) / 1024);
		(_header2.hdrEdenBytes = desiredEdenBytes);
		(_header2.imageVersion = GIV(imageVersionNumber));
		(_header2.hdrMaxExtSemTabSize = ((GIV(maxExtSemTabSizeSet))
			 ? ioGetMaxExtSemTableSize()
			 : 0));
		(_header2.firstSegSize = firstSegmentBytes());
		(_header2.freeOldSpaceInImage = GIV(totalFreeOldSpace));
		_header = _header2;
		/* end newHeader */
		if (hasToUseComposedFormat()) {
			CIW_writeImageFilefromHeader(_imageName, _header);
			goto l21;
		}
 else {
			SIW_writeImageFilefromHeader(_imageName, _header);
			goto l21;
		}
		l21:
		;
		/* end writeImageFile:fromHeader: */
		/* end writeImageFileIO */
		/* begin storePointerUnchecked:ofObject:withValue: */
		assert(!(isOopForwarded(_activeContext)));
		longAtput((_activeContext + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ), ((((usqInt) (_stackIndex - 1) ) << 3) | 1));
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	postSnapshot();
	marryContextInNewStackPageAndInitializeInterpreterRegisters(_activeContext);
	if (!GIV(primFailCode)) {
		/* begin push: */
		_object = GIV(falseObj);
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
		GIV(stackPointer) = _sp;
		/* end push: */
	} else {
		if (_stackModified) {
			/* begin push: */
			unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _rcvr);
			GIV(stackPointer) = _sp2;
			/* end push: */
			if (GIV(argumentCount) == 1) {
				/* begin pushInteger: */
				/* begin push: */
				unsignedLongAtput((_sp4 = GIV(stackPointer) - BytesPerWord), ((((usqInt) _newFormatToUse ) << 3) | 1));
				GIV(stackPointer) = _sp4;
				/* end push: */
				/* end pushInteger: */
			}
		}
		/* begin activateNewMethodInterpreted */
		/* begin push: */
		unsignedLongAtput((_sp8 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
		GIV(stackPointer) = _sp8;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp23 = GIV(stackPointer) - BytesPerWord), GIV(framePointer));
		GIV(stackPointer) = _sp23;
		/* end push: */
		GIV(framePointer) = GIV(stackPointer);
		/* begin setupFrameForNewMethodInterpreted */
		/* begin methodHeaderOf: */
		assert(isCompiledMethod(GIV(newMethod)));
		/* begin fetchPointer:ofObject: */
		_header3 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_header3 & 7) == 1)) {
			_methodHeader = _header3;
		} else {
			assert(((usqInt) _header3 ) < ((GIV(memoryMap)->newSpaceStart)));
			assert((((((CogMethod *) _header3 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
			_methodHeader = ((((CogMethod *) _header3 ))->methodHeader);
		}
		/* end methodHeaderOf: */
		_numTemps = (((usqInt) _methodHeader ) >> MethodHeaderTempCountShift) & 0x3F;
		/* begin argumentCountOfMethodHeader: */
		_numArgs = (((usqInt) _methodHeader ) >> MethodHeaderArgCountShift) & 15;
		/* end argumentCountOfMethodHeader: */
		_rcvr2 = unsignedLongAt(GIV(stackPointer) + ((_numArgs + 2) * BytesPerWord));
		assert(!(isOopForwarded(_rcvr2)));
		/* begin setupFrameFixedPartForNewMethodInterpreted:withHeader:withContext:isBlock:withNumArgs:withReceiver: */
		/* begin push: */
		unsignedLongAtput((_sp22 = GIV(stackPointer) - BytesPerWord), GIV(newMethod));
		GIV(stackPointer) = _sp22;
		/* end push: */
		/* begin setMethod:methodHeader: */
		/* begin setMethod: */
		assert(((usqInt) GIV(newMethod) ) >= (startOfObjectMemory(getMemoryMap())));
		{
			GIV(method) = GIV(newMethod);
			assert(isOopCompiledMethod(GIV(method)));
		}
		/* end setMethod: */
		assert((methodHeaderOf(GIV(method))) == _methodHeader);
		/* end setMethod:methodHeader: */
		/* begin push: */
		unsignedLongAtput((_sp32 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
		GIV(stackPointer) = _sp32;
		/* end push: */
		/* begin push: */
		/* begin encodeFrameFieldHasContext:isBlock:numArgs: */
		_object2 = ((VMBIGENDIAN)
			 ? ((1 + ((sqInt) (((usqInt) _numArgs ) << ((BytesPerWord * 8) - 8)) )) + (((GIV(nilObj) != GIV(nilObj))
				 ? 1ULL << ((BytesPerWord * 8) - 16)
				 : 0))) + 0
			 : ((1 + ((sqInt) (((usqInt) _numArgs ) << 8) )) + (((GIV(nilObj) != GIV(nilObj))
				 ? 1U << 16
				 : 0))) + 0);
		/* end encodeFrameFieldHasContext:isBlock:numArgs: */
		unsignedLongAtput((_sp42 = GIV(stackPointer) - BytesPerWord), _object2);
		GIV(stackPointer) = _sp42;
		/* end push: */
		{
			/* begin push: */
			unsignedLongAtput((_sp6 = GIV(stackPointer) - BytesPerWord), 0);
			GIV(stackPointer) = _sp6;
			/* end push: */
		}
		/* begin push: */
		unsignedLongAtput((_sp5 = GIV(stackPointer) - BytesPerWord), _rcvr2);
		GIV(stackPointer) = _sp5;
		/* end push: */
		/* end setupFrameFixedPartForNewMethodInterpreted:withHeader:withContext:isBlock:withNumArgs:withReceiver: */
		GIV(instructionPointer) = pointerForOop(((GIV(newMethod) + ((LiteralStart + ((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask))) * BytesPerOop)) + BaseHeaderSize) - 1);
		for (_i = _numArgs + 1; _i <= _numTemps; _i += 1) {
			/* begin push: */
			_object3 = GIV(nilObj);
			unsignedLongAtput((_sp7 = GIV(stackPointer) - BytesPerWord), _object3);
			GIV(stackPointer) = _sp7;
			/* end push: */
		}
		if (methodHeaderHasPrimitive(_methodHeader)) {
			GIV(instructionPointer) += 3;
			if (GIV(primFailCode) != 0) {
				_shouldSkipStoreBytecode = reapAndResetErrorCodeToheader(GIV(framePointer), _methodHeader);
				if (_shouldSkipStoreBytecode) {
					GIV(instructionPointer) += 2;
				}
			}
		}
		assert((frameNumArgs(GIV(framePointer))) == GIV(argumentCount));
		assert(!(frameIsBlockActivation(GIV(framePointer))));
		assert(!(frameHasContext(GIV(framePointer))));
		/* end setupFrameForNewMethodInterpreted */
		/* end activateNewMethodInterpreted */
	}
	l28:
	;
	/* end snapshot */
	if ((unsignedLongAt(GIV(framePointer) + FoxMethod)) == GIV(newMethod)) {
		GIV(instructionPointer) -= 1;
	}
	siglongjmp(reenterInterpreter, ReturnToInterpreter);
	{
		assert(0);
	}
}
/*	Primitive. Terminate up the context stack from the receiver up to but not 
	including the argument, if previousContext is on my Context stack. Make 
	previousContext my 
	sender. This prim has to shadow the code in ContextPart>terminateTo: to be 
	correct.  
	Override to ensure the caller's saved ip is correct, i.e. if an 
	interpreter frame it may 
	have to move to iframeSavedIP. */
/* CoInterpreterPrimitives>>#primitiveTerminateTo */
static void
primitiveTerminateTo(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aContextOrNil;
	sqInt _callerContextOrNil;
	sqInt _callerContextOrNil2;
	char *_callerFP;
	char *_callerFP2;
	char *_callerFP3;
	char *_contextsFP;
	usqInt _contextsIP;
	char *_contextsSP;
	sqInt _currentCtx;
	char *_fp;
	char *_fp2;
	char *_fp3;
	char *_frameAbove;
	char *_newFP;
	char *_newSP;
	sqInt _nextCntx;
	sqInt _numArgs;
	StackPage *_pageToStopOn;
	sqInt _senderOop;
	sqInt _senderOop2;
	sqInt _senderOop3;
	sqInt _senderOop4;
	sqInt _senderOop5;
	sqInt _senderOop6;
	char *_source;
	sqInt _stackedReceiverOffset;
	char *_theFP;
	char *_theFP2;
	StackPage *_thePage;
	StackPage *_thePage2;
	StackPage *_thePage3;
	char *_theSP;
	sqInt _thisCtx;
	sqInt _valuePointer;
	sqInt _valuePointer2;

	_contextsFP = ((char *) 0 );
	_aContextOrNil = unsignedLongAt(GIV(stackPointer));
	if (!((_aContextOrNil == GIV(nilObj)) || (((_aContextOrNil & (tagMask())) == 0) && (((longAt(_aContextOrNil)) & (classIndexMask())) == ClassMethodContextCompactIndex)))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return;
		/* end primitiveFail */
	}
	_thisCtx = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (_thisCtx == _aContextOrNil) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return;
		/* end primitiveFail */
	}
	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	_theSP = GIV(stackPointer);
	assert(_theSP < GIV(framePointer));
	assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(GIV(stackPage)->headFP = GIV(framePointer));
		(GIV(stackPage)->headSP = _theSP);
	}
	/* end setHeadFP:andSP:inPage: */
	assert(pageListIsWellFormed());
	/* end writeBackHeadFramePointers */
	if ((_aContextOrNil != GIV(nilObj)) && (((((unsignedLongAt((_aContextOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_aContextOrNil))))) {
		/* begin frameOfMarriedContext: */
		/* begin fetchPointer:ofObject: */
		_senderOop = unsignedLongAt((_aContextOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		{
			assert(((_senderOop & 7) == 1));
			_contextsFP = pointerForOop(_senderOop - 1);
		}
		/* end frameOfMarriedContext: */
		/* begin stackPageFor: */
		/* begin stackPageAt: */
		_pageToStopOn = stackPageAtpages((assert((((char *) _contextsFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _contextsFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_contextsFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
		/* end stackPageAt: */
		/* end stackPageFor: */
	} else {
		_pageToStopOn = 0;
	}
	if (((((unsignedLongAt((_thisCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_thisCtx)))) {
		/* begin frameOfMarriedContext: */
		/* begin fetchPointer:ofObject: */
		_senderOop3 = unsignedLongAt((_thisCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		{
			assert(((_senderOop3 & 7) == 1));
			_theFP = pointerForOop(_senderOop3 - 1);
		}
		/* end frameOfMarriedContext: */
		if ((_theFP == GIV(framePointer)) && (_pageToStopOn == GIV(stackPage))) {
			assertValidStackedInstructionPointersInline(GIV(stackPage), __LINE__);
			if ((pointerForOop(unsignedLongAt(_theFP + FoxSavedFP))) != _contextsFP) {
				/* begin frameStackedReceiverOffsetNumArgs: */
				_numArgs = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
					 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
					 : byteAt((_theFP + FoxIFrameFlags) + 1));
				_stackedReceiverOffset = (FoxCallerSavedIP + BytesPerWord) + ((sqInt) (((usqInt) _numArgs ) << (shiftForWord())) );
				/* end frameStackedReceiverOffsetNumArgs: */
				/* begin findFrameAbove:inPage: */
				_fp = (_pageToStopOn->headFP);
				if (_fp == _contextsFP) {
					_frameAbove = 0;
					goto l22;
				}
				while (((_callerFP = pointerForOop(unsignedLongAt(_fp + FoxSavedFP)))) != 0) {
					if (_callerFP == _contextsFP) {
						_frameAbove = _fp;
						goto l22;
					}
					_fp = _callerFP;
				}
				error("did not find theFP in stack page");
				_frameAbove = 0;
				l22:
				;
				/* end findFrameAbove:inPage: */
				_contextsIP = ((usqInt) (pointerForOop(unsignedLongAt(_frameAbove + FoxCallerSavedIP))) );
				assert(((((usqInt) _contextsIP ) >= (startOfObjectMemory(getMemoryMap()))) || (_contextsIP == (ceReturnToInterpreterPC()))) == (!(isMachineCodeFrame(_contextsFP))));
				{
					assert(!(isBaseFrame(_frameAbove)));
					_newSP = (_frameAbove + (frameStackedReceiverOffset(_frameAbove))) + BytesPerWord;
				}
				_newFP = (_newSP - _stackedReceiverOffset) - BytesPerWord;
				for (_source = _theFP + _stackedReceiverOffset; _source >= GIV(stackPointer); _source += -BytesPerWord) {
					_newSP -= BytesPerWord;
					unsignedLongAtput(_newSP, unsignedLongAt(_source));
				}
				unsignedLongAtput(_newFP + FoxSavedFP, _contextsFP);
				if ((isMachineCodeIP(((usqInt) (unsignedLongAt(_newFP + FoxMethod)) ))) && (_contextsIP >= (startOfObjectMemory(getMemoryMap())))) {
					/* begin iframeSavedIP:put: */
					assert(!(isMachineCodeFrame(_contextsFP)));
					unsignedLongAtput(_contextsFP + FoxIFSavedIP, _contextsIP);
					/* end iframeSavedIP:put: */
					_contextsIP = ceReturnToInterpreterPC();
				}
				unsignedLongAtput(_newFP + FoxCallerSavedIP, _contextsIP);
				assert(isContext(_thisCtx));
				/* begin storePointerUnchecked:ofObject:withValue: */
				assert(!(isOopForwarded(_thisCtx)));
				longAtput((_thisCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), (assert(((oopForPointer(_newFP)) & (BytesPerWord - 1)) == 0), (oopForPointer(_newFP)) + (smallIntegerTag())));
				/* end storePointerUnchecked:ofObject:withValue: */
				/* begin storePointerUnchecked:ofObject:withValue: */
				assert(!(isOopForwarded(_thisCtx)));
				longAtput((_thisCtx + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), (assert(((oopForPointer(_contextsFP)) & (BytesPerWord - 1)) == 0), (oopForPointer(_contextsFP)) + (smallIntegerTag())));
				/* end storePointerUnchecked:ofObject:withValue: */
				GIV(framePointer) = _newFP;
				GIV(stackPointer) = _newSP;
			}
			/* begin pop: */
			GIV(stackPointer) += 1 * BytesPerWord;
			/* end pop: */
			assertValidStackedInstructionPointersInline(GIV(stackPage), __LINE__);
			assert(GIV(stackPage) == (mostRecentlyUsedPage()));
			return;
		}
		assertValidStackedInstructionPointers(__LINE__);
		_theFP = ensureIsBaseFrame(_theFP);
		/* begin frameCallerContext: */
		assert(isBaseFrame(_theFP));
		/* begin stackPageFor: */
		/* begin stackPageAt: */
		_thePage2 = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
		/* end stackPageAt: */
		/* end stackPageFor: */
		_callerContextOrNil = unsignedLongAt((_thePage2->baseAddress));
		assert(addressCouldBeObj(_callerContextOrNil));
		assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
		_currentCtx = _callerContextOrNil;
		/* end frameCallerContext: */
		if ((_aContextOrNil != GIV(nilObj)) && (((((unsignedLongAt((_aContextOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_aContextOrNil))))) {
			/* begin frameOfMarriedContext: */
			/* begin fetchPointer:ofObject: */
			_senderOop2 = unsignedLongAt((_aContextOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			{
				assert(((_senderOop2 & 7) == 1));
				_contextsFP = pointerForOop(_senderOop2 - 1);
			}
			/* end frameOfMarriedContext: */
			/* begin stackPageFor: */
			/* begin stackPageAt: */
			_pageToStopOn = stackPageAtpages((assert((((char *) _contextsFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _contextsFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_contextsFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
			/* end stackPageAt: */
			/* end stackPageFor: */
		} else {
			_pageToStopOn = 0;
		}
	} else {
		_currentCtx = unsignedLongAt((_thisCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
	}
	assertValidStackedInstructionPointers(__LINE__);
	if (contexthasSender(_thisCtx, _aContextOrNil)) {
		while (!((_currentCtx == _aContextOrNil) || (_currentCtx == GIV(nilObj)))) {
			assert(isContext(_currentCtx));
			if ((((unsignedLongAt((_currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
				/* begin frameOfMarriedContext: */
				/* begin fetchPointer:ofObject: */
				_senderOop5 = unsignedLongAt((_currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				{
					assert(((_senderOop5 & 7) == 1));
					_theFP = pointerForOop(_senderOop5 - 1);
				}
				/* end frameOfMarriedContext: */
				/* begin stackPageFor: */
				/* begin stackPageAt: */
				_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
				/* end stackPageAt: */
				/* end stackPageFor: */
				if (_thePage == GIV(stackPage)) {
					/* begin findFrameAbove:inPage: */
					_fp2 = (_thePage->headFP);
					if (_fp2 == _theFP) {
						_frameAbove = 0;
						goto l25;
					}
					while (((_callerFP2 = pointerForOop(unsignedLongAt(_fp2 + FoxSavedFP)))) != 0) {
						if (_callerFP2 == _theFP) {
							_frameAbove = _fp2;
							goto l25;
						}
						_fp2 = _callerFP2;
					}
					error("did not find theFP in stack page");
					_frameAbove = 0;
					l25:
					;
					/* end findFrameAbove:inPage: */
					assert(_frameAbove != 0);
					_frameAbove = ensureIsBaseFrame(_frameAbove);
					if ((_aContextOrNil != GIV(nilObj)) && (((((unsignedLongAt((_aContextOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_aContextOrNil))))) {
						/* begin frameOfMarriedContext: */
						/* begin fetchPointer:ofObject: */
						_senderOop4 = unsignedLongAt((_aContextOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						{
							assert(((_senderOop4 & 7) == 1));
							_contextsFP = pointerForOop(_senderOop4 - 1);
						}
						/* end frameOfMarriedContext: */
						/* begin stackPageFor: */
						/* begin stackPageAt: */
						_pageToStopOn = stackPageAtpages((assert((((char *) _contextsFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _contextsFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_contextsFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
						/* end stackPageAt: */
						/* end stackPageFor: */
					} else {
						_pageToStopOn = 0;
					}
				} else {
					if (_thePage == _pageToStopOn) {
						/* begin findFrameAbove:inPage: */
						_fp3 = (_thePage->headFP);
						if (_fp3 == _contextsFP) {
							_frameAbove = 0;
							goto l26;
						}
						while (((_callerFP3 = pointerForOop(unsignedLongAt(_fp3 + FoxSavedFP)))) != 0) {
							if (_callerFP3 == _contextsFP) {
								_frameAbove = _fp3;
								goto l26;
							}
							_fp3 = _callerFP3;
						}
						error("did not find theFP in stack page");
						_frameAbove = 0;
						l26:
						;
						/* end findFrameAbove:inPage: */
						if (_frameAbove != 0) {
							_contextsSP = ((assert(!(isBaseFrame(_frameAbove))), (_frameAbove + (frameStackedReceiverOffset(_frameAbove))) + BytesPerWord)) - BytesPerWord;
							unsignedLongAtput(_contextsSP, pointerForOop(unsignedLongAt(_frameAbove + FoxCallerSavedIP)));
							/* begin setHeadFP:andSP:inPage: */
							assert(_contextsSP < _contextsFP);
							assert((_contextsSP < ((_thePage->baseAddress))) && (_contextsSP > (((_thePage->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
							assert((_contextsFP < ((_thePage->baseAddress))) && (_contextsFP > (((_thePage->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
							{
								(_thePage->headFP = _contextsFP);
								(_thePage->headSP = _contextsSP);
							}
							/* end setHeadFP:andSP:inPage: */
						}
						_currentCtx = _aContextOrNil;
					} else {
						/* begin frameCallerContext: */
						_theFP2 = (_thePage->baseFP);
						assert(isBaseFrame(_theFP2));
						/* begin stackPageFor: */
						/* begin stackPageAt: */
						_thePage3 = stackPageAtpages((assert((((char *) _theFP2 ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP2 ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP2, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
						/* end stackPageAt: */
						/* end stackPageFor: */
						_callerContextOrNil2 = unsignedLongAt((_thePage3->baseAddress));
						assert(addressCouldBeObj(_callerContextOrNil2));
						assert((_callerContextOrNil2 == (nilObject())) || (isContext(_callerContextOrNil2)));
						_currentCtx = _callerContextOrNil2;
						/* end frameCallerContext: */
						freeStackPageNoAssert(_thePage);
					}
				}
			} else {
				_nextCntx = unsignedLongAt((_currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
				/* begin markContextAsDead: */
				assert(isContext(_currentCtx));
				{
					/* begin storePointerUnchecked:ofObject:withValue: */
					_valuePointer = GIV(nilObj);
					assert(!(isOopForwarded(_currentCtx)));
					longAtput((_currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), _valuePointer);
					/* end storePointerUnchecked:ofObject:withValue: */
					/* begin storePointerUnchecked:ofObject:withValue: */
					_valuePointer2 = GIV(nilObj);
					assert(!(isOopForwarded(_currentCtx)));
					longAtput((_currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), _valuePointer2);
					/* end storePointerUnchecked:ofObject:withValue: */
				}
				/* end markContextAsDead: */
				_currentCtx = _nextCntx;
			}
		}
	}
	assert(pageListIsWellFormed());
	if ((((unsignedLongAt((_thisCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
		assert(checkIsStillMarriedContextcurrentFP(_thisCtx, GIV(framePointer)));
		assert(isBaseFrame(frameOfMarriedContext(_thisCtx)));
		/* begin frameOfMarriedContext: */
		/* begin fetchPointer:ofObject: */
		_senderOop6 = unsignedLongAt((_thisCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		{
			assert(((_senderOop6 & 7) == 1));
			_theFP = pointerForOop(_senderOop6 - 1);
		}
		/* end frameOfMarriedContext: */
		/* begin frameCallerContext:put: */
		assert((_aContextOrNil == (nilObject())) || (isContext(_aContextOrNil)));
		assert(isBaseFrame(_theFP));
		assert(((_theFP + (frameStackedReceiverOffset(_theFP))) + (2 * BytesPerWord)) == (((stackPageFor(_theFP))->baseAddress)));
		{
			assert((longAt((_theFP + (frameStackedReceiverOffset(_theFP))) + BytesPerWord)) == (frameContext(_theFP)));
		}
		longAtput((_theFP + (frameStackedReceiverOffsetNumArgs(((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
			 : byteAt((_theFP + FoxIFrameFlags) + 1))))) + (2 * BytesPerWord), _aContextOrNil);
		/* end frameCallerContext:put: */
	} else {
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_thisCtx)));
		if (((_thisCtx & (tagMask())) == 0) && ((_thisCtx & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_aContextOrNil & (tagMask())) == 0) && (((_aContextOrNil & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_aContextOrNil >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_thisCtx)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _thisCtx);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_thisCtx)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l28;
		}
		if (_aContextOrNil & (tagMask())) {
			goto l28;
		}
		if (!(_thisCtx >= 0x20000000000LL)) {
			goto l28;
		}
		if (_aContextOrNil >= 0x20000000000LL) {
			goto l28;
		}
		if ((_aContextOrNil >= GIV(nilObj)) && (_aContextOrNil <= GIV(trueObj))) {
			goto l28;
		}
		if (!(_aContextOrNil >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l28;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _thisCtx);
		l28:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_thisCtx + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), _aContextOrNil);
		/* end storePointer:ofObject:withValue: */
	}
	/* begin pop: */
	GIV(stackPointer) += 1 * BytesPerWord;
	/* end pop: */
	assertValidStackedInstructionPointers(__LINE__);
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
}
/*	Void all internal VM state in the stack and machine code zones 
	 
	Override to jump to the interpreter because the machine code zone is now 
	void.  */
/* CoInterpreterPrimitives>>#primitiveVoidVMState */
static void
primitiveVoidVMState(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeContext;
	char *_sp;

	/* begin push: */
	unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
	GIV(stackPointer) = _sp;
	/* end push: */
	_activeContext = voidVMStateForSnapshotFlushingExternalPrimitivesIf(0);
	marryContextInNewStackPageAndInitializeInterpreterRegisters(_activeContext);
	siglongjmp(reenterInterpreter, ReturnToInterpreter);
	{
		assert(0);
	}
}
/*	The receiver (or first argument) must be a compiledMethod. The optional 
	(or second) argument must be a 
	boolean. Clear all VM state associated with the method, including any 
	machine code, or machine code pcs 
	in context objects. If the optional boolean argument is false do not scan 
	the heap looking for contexts. */
/* CoInterpreterPrimitives>>#primitiveVoidVMStateForMethod */
static void
primitiveVoidVMStateForMethod(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeContext;
	sqInt _address;
	sqInt _address2;
	CogMethod *_cogMethod;
	sqInt _currentObject;
	sqInt _divorcedSome;
	int _divorcedSome2;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	sqInt _hasCogMethod;
	sqInt _i;
	sqInt _i2;
	usqInt _limit;
	sqInt _limit2;
	sqInt _methodHeader;
	sqInt _methodHeader2;
	sqInt _methodObj;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _obj;
	sqInt _object;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;
	int _probe;
	sqInt _scanHeapForContexts;
	sqInt _senderOop;
	char *_sp;
	char *_sp2;
	char *_theFP;
	char *_theFrame;
	StackPage *_thePage;
	StackPage *_thePage2;
	char *_theSP;
	char *_theSP2;
	sqInt _top;
	sqInt _top2;

	_scanHeapForContexts = 1;
	if (GIV(argumentCount) == 0) {
		_methodObj = unsignedLongAt(GIV(stackPointer));
	} else {
		_methodObj = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
		/* begin booleanValueOf: */
		_obj = unsignedLongAt(GIV(stackPointer));
		if (_obj == GIV(trueObj)) {
			_scanHeapForContexts = 1;
			goto l2;
		}
		if (_obj == GIV(falseObj)) {
			_scanHeapForContexts = 0;
			goto l2;
		}
		/* begin success: */
		{
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
		}
		/* end success: */
		_scanHeapForContexts = null;
		l2:
		;
		/* end booleanValueOf: */
		if (GIV(primFailCode)) {
			GIV(primFailCode) = PrimErrBadArgument;
			return;
		}
	}
	if (GIV(argumentCount) > 1) {
		GIV(primFailCode) = PrimErrBadNumArgs;
		return;
	}
	/* begin flushMethodCacheForMethod: */
	_probe = 0;
	for (_i = 1; _i <= MethodCacheEntries; _i += 1) {
		if ((GIV(methodCache)[_probe + MethodCacheMethod]) == _methodObj) {
			GIV(methodCache)[_probe + MethodCacheSelector] = 0;
		}
		_probe += MethodCacheEntrySize;
	}
	flushExternalPrimitiveOf(_methodObj);
	/* end flushMethodCacheForMethod: */
	/* begin ensureFrameIsMarried:SP: */
	_theFP = GIV(framePointer);
	_theSP = GIV(stackPointer);
	if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
		 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0)) {
		assert(isContext(frameContext(_theFP)));
		_activeContext = unsignedLongAt(_theFP + FoxThisContext);
		goto l10;
	}
	_activeContext = marryFrameSP(_theFP, _theSP);
	l10:
	;
	/* end ensureFrameIsMarried:SP: */
	/* begin ensurePushedInstructionPointer */
	if (!(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())))) {
		/* begin iframeSavedIP:put: */
		assert(!(isMachineCodeFrame(GIV(framePointer))));
		unsignedLongAtput(GIV(framePointer) + FoxIFSavedIP, GIV(instructionPointer));
		/* end iframeSavedIP:put: */
		/* begin push: */
		_object = ceReturnToInterpreterPC();
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
		GIV(stackPointer) = _sp;
		/* end push: */
	} else {
		/* begin push: */
		unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
		GIV(stackPointer) = _sp2;
		/* end push: */
	}
	/* end ensurePushedInstructionPointer */
	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	_theSP2 = GIV(stackPointer);
	assert(_theSP2 < GIV(framePointer));
	assert((_theSP2 < ((GIV(stackPage)->baseAddress))) && (_theSP2 > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(GIV(stackPage)->headFP = GIV(framePointer));
		(GIV(stackPage)->headSP = _theSP2);
	}
	/* end setHeadFP:andSP:inPage: */
	assert(pageListIsWellFormed());
	/* end writeBackHeadFramePointers */
	if ((assert(isNonImmediate(_methodObj)), /* begin isCogMethodReference: */ (_methodHeader = unsignedLongAt((_methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ))), assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_hasCogMethod = (_methodHeader & (smallIntegerTag())) == 0) /* end isCogMethodReference: */)) {
		/* begin divorceMachineCodeFramesWithMethod: */
		/* begin cogMethodOf: */
		/* begin fetchPointer:ofObject: */
		_methodHeader2 = unsignedLongAt((_methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert((isNonImmediate(_methodHeader2)) && (((usqInt) _methodHeader2 ) < (startOfObjectMemory(getMemoryMap()))));
		_cogMethod = ((CogMethod *) _methodHeader2 );
		/* end cogMethodOf: */
		do {
			if (GIV(stackPage) != 0) {
				markStackPageMostRecentlyUsed(GIV(stackPage));
			}
			/* begin divorceSomeMachineCodeFramesWithMethod: */
			_divorcedSome2 = 0;
			/* begin usedStackPagesDo: */
			/* begin allStackPagesDo: */
			for (_i2 = 0; _i2 < GIV(numStackPages); _i2 += 1) {
				/* begin stackPageAt: */
				_thePage2 = stackPageAtpages(_i2, GIV(pages));
				/* end stackPageAt: */
				{
					if (!(((_thePage2->baseFP)) == 0)) {
						{
							markStackPageMostRecentlyUsed(GIV(stackPage));
							if (divorceAMachineCodeFrameWithCogMethodin(_cogMethod, _thePage2)) {
								_divorcedSome2 = 1;
							}
						}
					}
				}
			}
			/* end allStackPagesDo: */
			/* end usedStackPagesDo: */
			_divorcedSome = _divorcedSome2;
			/* end divorceSomeMachineCodeFramesWithMethod: */
		} while (_divorcedSome);
		/* end divorceMachineCodeFramesWithMethod: */
	}
	if (_scanHeapForContexts) {
		/* begin ensureAllContextsWithMethodHaveBytecodePCs: */
		/* begin allObjectsDo: */
		/* begin allNewSpaceObjectsDo: */
		/* begin allNewSpaceEntitiesDo: */
		_prevPrevObj = (_prevObj = null);
		assert((((pastSpace()).start)) < (((eden()).start)));
		/* begin objectStartingAt: */
		_address = ((pastSpace()).start);
		_numSlots = byteAt(_address + 7);
		_objOop2 = ((_numSlots == (numSlotsMask()))
			 ? _address + BaseHeaderSize
			 : _address);
		/* end objectStartingAt: */
		_limit = GIV(pastSpaceStart);
		while (oopisLessThan(_objOop2, _limit)) {
			{
				assert(isEnumerableObjectNoAssert(_objOop2));
				{
					if ((((longAt(_objOop2)) & (classIndexMask())) == ClassMethodContextCompactIndex) && ((unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ))) == _methodObj)) {
						widowOrForceToBytecodePC(_objOop2);
					}
				}
			}
			_prevPrevObj = _prevObj;
			_prevObj = _objOop2;
			/* begin objectAfter:limit: */
			_followingWordAddress = addressAfter(_objOop2);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
				_objOop2 = _limit;
				goto l17;
			}
			flag("endianness");
			_followingWord = unsignedLongAt(_followingWordAddress);
			_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress + BaseHeaderSize
				 : _followingWordAddress);
			l17:
			;
			/* end objectAfter:limit: */
		}
		/* begin objectStartingAt: */
		_address2 = ((eden()).start);
		_numSlots2 = byteAt(_address2 + 7);
		_objOop2 = ((_numSlots2 == (numSlotsMask()))
			 ? _address2 + BaseHeaderSize
			 : _address2);
		/* end objectStartingAt: */
		while (oopisLessThan(_objOop2, GIV(freeStart))) {
			{
				assert(isEnumerableObjectNoAssert(_objOop2));
				{
					if ((((longAt(_objOop2)) & (classIndexMask())) == ClassMethodContextCompactIndex) && ((unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ))) == _methodObj)) {
						widowOrForceToBytecodePC(_objOop2);
					}
				}
			}
			_prevPrevObj = _prevObj;
			_prevObj = _objOop2;
			/* begin objectAfter:limit: */
			_followingWordAddress2 = addressAfter(_objOop2);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
				_objOop2 = GIV(freeStart);
				goto l20;
			}
			flag("endianness");
			_followingWord2 = unsignedLongAt(_followingWordAddress2);
			_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress2 + BaseHeaderSize
				 : _followingWordAddress2);
			l20:
			;
			/* end objectAfter:limit: */
		}
		/* end allNewSpaceEntitiesDo: */
		/* end allNewSpaceObjectsDo: */
		/* begin allOldSpaceObjectsDo: */
		/* begin allOldSpaceObjectsFrom:do: */
		/* begin allOldSpaceEntitiesFrom:do: */
		assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
		_prevPrevObj2 = (_prevObj2 = null);
		_objOop22 = GIV(nilObj);
		while (1) {
			assert((_objOop22 % (allocationUnit())) == 0);
			if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
				break;
			assert((uint64AtPointer(_objOop22)) != 0);
			{
				if (isEnumerableObject(_objOop22)) {
					{
						if ((((longAt(_objOop22)) & (classIndexMask())) == ClassMethodContextCompactIndex) && ((unsignedLongAt((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ))) == _methodObj)) {
							widowOrForceToBytecodePC(_objOop22);
						}
					}
				}
			}
			_prevPrevObj2 = _prevObj2;
			_prevObj2 = _objOop22;
			/* begin objectAfter:limit: */
			_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			_followingWordAddress4 = addressAfter(_objOop22);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
				_objOop22 = _limit2;
				goto l18;
			}
			flag("endianness");
			_followingWord4 = unsignedLongAt(_followingWordAddress4);
			_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress4 + BaseHeaderSize
				 : _followingWordAddress4);
			l18:
			;
			/* end objectAfter:limit: */
		}
		/* end allOldSpaceEntitiesFrom:do: */
		/* end allOldSpaceObjectsFrom:do: */
		/* end allOldSpaceObjectsDo: */
		/* begin allPermSpaceObjectsDo: */
		_currentObject = (GIV(memoryMap)->permSpaceStart);
		while (!(_currentObject == GIV(permSpaceFreeStart))) {
			if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
				{
					if ((((longAt(_currentObject)) & (classIndexMask())) == ClassMethodContextCompactIndex) && ((unsignedLongAt((_currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ))) == _methodObj)) {
						widowOrForceToBytecodePC(_currentObject);
					}
				}
			}
			/* begin objectAfter:limit: */
			_followingWordAddress3 = addressAfter(_currentObject);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
				_currentObject = GIV(permSpaceFreeStart);
				goto l21;
			}
			flag("endianness");
			_followingWord3 = unsignedLongAt(_followingWordAddress3);
			_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress3 + BaseHeaderSize
				 : _followingWordAddress3);
			l21:
			;
			/* end objectAfter:limit: */
		}
		/* end allPermSpaceObjectsDo: */
		/* end allObjectsDo: */
		/* end ensureAllContextsWithMethodHaveBytecodePCs: */
	}
	if (_hasCogMethod) {
		unlinkSendsToandFreeIf(_methodObj, 1);
	}
	if (!(((((unsignedLongAt((_activeContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_activeContext))))) {
		/* begin zeroStackPage */
		assert((GIV(stackPage) == 0) || ((((GIV(stackPage)->headFP)) == GIV(framePointer)) && (((GIV(stackPage)->headSP)) == GIV(stackPointer))));
		GIV(stackPage) = 0;
		/* end zeroStackPage */
		marryContextInNewStackPageAndInitializeInterpreterRegisters(_activeContext);
		/* begin popStack */
		_top = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		/* end popStack */
		assert((_methodObj == (stackTop())) || ((GIV(argumentCount) > 0) && (_methodObj == (stackValue(1)))));
		/* begin pop: */
		GIV(stackPointer) += GIV(argumentCount) * BytesPerWord;
		/* end pop: */
		siglongjmp(reenterInterpreter, ReturnToInterpreter);
		{
			assert(0);
		}
	}
	/* begin frameOfMarriedContext: */
	/* begin fetchPointer:ofObject: */
	_senderOop = unsignedLongAt((_activeContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	{
		assert(((_senderOop & 7) == 1));
		_theFrame = pointerForOop(_senderOop - 1);
	}
	/* end frameOfMarriedContext: */
	/* begin stackPageFor: */
	/* begin stackPageAt: */
	_thePage = stackPageAtpages((assert((((char *) _theFrame ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFrame ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFrame, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
	/* end stackPageAt: */
	/* end stackPageFor: */
	assert(((_thePage->headFP)) == _theFrame);
	/* begin setStackPageAndLimit: */
	assert(_thePage != 0);
	GIV(stackPage) = _thePage;
	if (GIV(stackLimit) != ((char *) ((usqInt) -1 ) )) {
		GIV(stackLimit) = (GIV(stackPage)->stackLimit);
	}
	markStackPageMostRecentlyUsed(_thePage);
	/* end setStackPageAndLimit: */
	/* begin setStackPointersFromPage: */
	GIV(stackPointer) = (_thePage->headSP);
	GIV(framePointer) = (_thePage->headFP);
	/* end setStackPointersFromPage: */
	/* begin popStack */
	_top2 = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	GIV(instructionPointer) = _top2;
	/* end popStack */
	assert((_methodObj == (stackTop())) || ((GIV(argumentCount) > 0) && (_methodObj == (stackValue(1)))));
	/* begin pop: */
	GIV(stackPointer) += GIV(argumentCount) * BytesPerWord;
	/* end pop: */
}
/* ComposedImageReader>>#CIR_readPermanentSpaceFromImageFile:header: */
static size_t NoDbgRegParms
CIR_readPermanentSpaceFromImageFileheader(sqInt _imageFileName, SpurImageHeaderStruct aHeader)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aCharacter;
	sqInt _aValue;
	char _buffer[255];
	char _buffer2[255];
	char _buffer3[255];
	sqInt _bytes;
	size_t _bytesRead;
	size_t _dataSize;
	char _fieldName[255];
	long long _fieldValue;
	sqImageFile _file;
	sqImageFile _file2;
	sqInt _fn;
	sqInt _fullFileName;
	char _lineBuffer[1024];
	char _lineBuffer2[1024];
	ComposedMetadataStruct _metadata;
	ComposedMetadataStruct *_metadataPointer;
	void *_newBase;
	void *_oldBase;
	ComposedMetadataStruct _permSpaceMetadata;
	sqInt _startingAddress;
	char _structName[255];

	_fieldValue = 0;
	_fn = 0;
	if (!(fileExists((/* begin simulationOnly: */ /* end simulationOnly: */ /* begin permSpaceFileName:inImage:into:bufferSize: */ (snprintf(_buffer, 0xFF, "%s/%s", ((char *) _imageFileName ), ((char *) "permSpace.ston" )), _buffer) /* end permSpaceFileName:inImage:into:bufferSize: */)))) {
		return 0;
	}
	/* begin readPermanentSpaceMetadataFromImage: */
	/* begin readMetadataFromFileName: */
	/* begin simulationOnly: */
	/* end simulationOnly: */
	_file2 = sqImageFileOpen((/* begin simulationOnly: */ /* end simulationOnly: */ /* begin permSpaceFileName:inImage:into:bufferSize: */ snprintf(_buffer3, 0xFF, "%s/%s", ((char *) _imageFileName ), ((char *) "permSpace.ston" )), _buffer3 /* end permSpaceFileName:inImage:into:bufferSize: */), "r");
	_metadataPointer = &_metadata;
	/* begin readSTONFrom:into: */
	/* begin readHeadSTONFrom:into: */
	/* begin simulationOnly: */
	/* end simulationOnly: */
	readLineFromintoofSize(_file2, _lineBuffer, 1024);
	sscanf(contentsOf(_lineBuffer), "%s {\n", _structName);
	/* begin simulationOnly: */
	/* end simulationOnly: */
	/* end readHeadSTONFrom:into: */
	/* begin readFieldsSTONFrom:into: */
	/* begin simulationOnly: */
	/* end simulationOnly: */
	{
		(_metadataPointer->startAddress = 0);
		(_metadataPointer->dataSize = 0);
	}
	do {
		readLineFromintoofSize(_file2, _lineBuffer2, 1024);
		sscanf(contentsOf(_lineBuffer2), fieldFormat(), _fieldName, ((sqInt*) &_fieldValue ));
		{
			if ((strcmp("startAddress", contentsOf(_fieldName))) == 0) {
				(_metadataPointer->startAddress = contentsOf(_fieldValue));
			}
			if ((strcmp("dataSize", contentsOf(_fieldName))) == 0) {
				(_metadataPointer->dataSize = contentsOf(_fieldValue));
			}
		}
		/* begin endOfSTON: */
		_aCharacter = fgetc(_file2);
		ungetc(_aCharacter, _file2);
		/* end endOfSTON: */
	} while (!((_aCharacter == -1) || (_aCharacter == '}')));
	/* end readFieldsSTONFrom:into: */
	/* end readSTONFrom:into: */
	sqImageFileClose(_file2);
	_permSpaceMetadata = _metadata;
	/* end readMetadataFromFileName: */
	/* end readPermanentSpaceMetadataFromImage: */
	_oldBase = (_permSpaceMetadata.startAddress);
	_dataSize = (_permSpaceMetadata.dataSize);
	if (!(ensureAtLeastPermSpaceOf(getMemoryMap(), _dataSize))) {
		error("Could not allocate PermSpace");
	}
	_newBase = ((getMemoryMap())->permSpaceStart);
	if (_newBase != _oldBase) {
		logError("Expecting Base %p Got %p", _oldBase, _newBase);
		unableToReadImageError();
	}
	/* begin readDataFromFileName:startingAt:bytes: */
	{
		/* begin simulationOnly: */
		/* end simulationOnly: */
		{
			snprintf(_buffer2, 0xFF, "%s/%s", ((char *) _imageFileName ), ((char *) "permSpace.data" ));
			_fullFileName = _buffer2;
		}
	}
	_startingAddress = ((sqInt) (pointerForOop(_newBase)) );
	_file = sqImageFileOpen(_fullFileName, "rb");
	if (_dataSize > 0) {
		_bytes = sqImageFileRead(_startingAddress, sizeof(char), _dataSize, _file);
	} else {
		_bytes = 0;
	}
	sqImageFileClose(_file);
	_bytesRead = _bytes;
	/* end readDataFromFileName:startingAt:bytes: */
	/* begin setPermSpaceFreeStart: */
	_aValue = ((sqInt) ((((getMemoryMap())->permSpaceStart)) + _dataSize) );
	GIV(permSpaceFreeStart) = _aValue;
	/* end setPermSpaceFreeStart: */
	if (_bytesRead != _dataSize) {
		logError("Expecting %lld Got %lld", _dataSize, _bytesRead);
		unableToReadImageError();
	}
	return _bytesRead;
}
/* ComposedImageReader>>#CIR_readSegmentsFromImageFile:header: */
static size_t NoDbgRegParms
CIR_readSegmentsFromImageFileheader(sqInt _imageFileName, SpurImageHeaderStruct aHeader)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aCharacter;
	char _buffer[255];
	char _buffer2[255];
	char _buffer3[255];
	sqInt _bytes;
	size_t _bytesRead;
	char _fieldName[255];
	long long _fieldValue;
	sqImageFile _file;
	sqImageFile _file2;
	sqInt _fileName;
	sqInt _fn;
	sqInt _fullFileName;
	sqInt _fullFileName2;
	char _lineBuffer[1024];
	char _lineBuffer2[1024];
	ComposedMetadataStruct _metadata;
	ComposedMetadataStruct *_metadataPointer;
	sqInt _newBase;
	sqInt _oldBase;
	SpurSegmentInfo *_segInfo2;
	int _segmentIndex;
	ComposedMetadataStruct _segmentMetadata;
	size_t _segmentSize;
	sqInt _startingAddress;
	char _structName[255];
	size_t _totalBytesRead;

	/* begin prepareSegmentsToRead */
	/* begin clearSegments */
	GIV(numSegments) = 0;
	_fieldValue = 0;
	_fn = 0;
	/* end clearSegments */
	allocateOrExtendSegmentInfos();
	/* end prepareSegmentsToRead */
	_segmentIndex = 0;
	_totalBytesRead = 0;
	_newBase = ((getMemoryMap())->oldSpaceStart);
	do {
		/* begin readSegmentMetadata:fromImage: */
		/* begin readMetadataFromFileName: */
		/* begin segmentMetadataFile:inImage: */
		/* begin simulationOnly: */
		/* end simulationOnly: */
		/* begin segmentFileName:withExtension:inImage:into:bufferSize: */
		{
			snprintf(_buffer3, 0xFF, "%s/seg%d%s", ((char *) _imageFileName ), ((int) _segmentIndex ), ".ston");
			_fullFileName2 = _buffer3;
		}
		/* end segmentFileName:withExtension:inImage:into:bufferSize: */
		/* end segmentMetadataFile:inImage: */
		/* begin simulationOnly: */
		/* end simulationOnly: */
		_file2 = sqImageFileOpen(_fullFileName2, "r");
		_metadataPointer = &_metadata;
		/* begin readSTONFrom:into: */
		/* begin readHeadSTONFrom:into: */
		/* begin simulationOnly: */
		/* end simulationOnly: */
		readLineFromintoofSize(_file2, _lineBuffer, 1024);
		sscanf(contentsOf(_lineBuffer), "%s {\n", _structName);
		/* begin simulationOnly: */
		/* end simulationOnly: */
		/* end readHeadSTONFrom:into: */
		/* begin readFieldsSTONFrom:into: */
		/* begin simulationOnly: */
		/* end simulationOnly: */
		{
			(_metadataPointer->startAddress = 0);
			(_metadataPointer->dataSize = 0);
		}
		do {
			readLineFromintoofSize(_file2, _lineBuffer2, 1024);
			sscanf(contentsOf(_lineBuffer2), fieldFormat(), _fieldName, ((sqInt*) &_fieldValue ));
			{
				if ((strcmp("startAddress", contentsOf(_fieldName))) == 0) {
					(_metadataPointer->startAddress = contentsOf(_fieldValue));
				}
				if ((strcmp("dataSize", contentsOf(_fieldName))) == 0) {
					(_metadataPointer->dataSize = contentsOf(_fieldValue));
				}
			}
			/* begin endOfSTON: */
			_aCharacter = fgetc(_file2);
			ungetc(_aCharacter, _file2);
			/* end endOfSTON: */
		} while (!((_aCharacter == -1) || (_aCharacter == '}')));
		/* end readFieldsSTONFrom:into: */
		/* end readSTONFrom:into: */
		sqImageFileClose(_file2);
		_segmentMetadata = _metadata;
		/* end readMetadataFromFileName: */
		/* end readSegmentMetadata:fromImage: */
		_oldBase = (_segmentMetadata.startAddress);
		_segmentSize = (_segmentMetadata.dataSize);
		/* begin withNewSegmentDo: */
		_segInfo2 = &(GIV(segments)[GIV(numSegments)]);
		{
			{
				(_segInfo2->segStart = _oldBase);
				(_segInfo2->segSize = _segmentSize);
				(_segInfo2->swizzle = _newBase - _oldBase);
			}
		}
		if (((GIV(numSegments) += 1)) >= GIV(numSegInfos)) {
			allocateOrExtendSegmentInfos();
		}
		/* end withNewSegmentDo: */
		/* begin readDataFromFileName:startingAt:bytes: */
		{
			/* begin simulationOnly: */
			/* end simulationOnly: */
			{
				snprintf(_buffer2, 0xFF, "%s/seg%d%s", ((char *) _imageFileName ), ((int) _segmentIndex ), ".data");
				_fullFileName = _buffer2;
			}
		}
		_startingAddress = ((sqInt) (pointerForOop(_newBase)) );
		_file = sqImageFileOpen(_fullFileName, "rb");
		if (_segmentSize > 0) {
			_bytes = sqImageFileRead(_startingAddress, sizeof(char), _segmentSize, _file);
		} else {
			_bytes = 0;
		}
		sqImageFileClose(_file);
		_bytesRead = _bytes;
		/* end readDataFromFileName:startingAt:bytes: */
		if (_bytesRead > 0) {
			_totalBytesRead += _bytesRead;
		}
		if (_bytesRead != _segmentSize) {
			logError("Expecting %lld Got %lld", _segmentSize, _bytesRead);
			unableToReadImageError();
		}
		_newBase = (_newBase + _segmentSize) - (2 * BaseHeaderSize);
		_segmentIndex += 1;
		/* begin existSegment:inImage: */
		{
			snprintf(_buffer, 0xFF, "%s/seg%d%s", ((char *) _imageFileName ), ((int) _segmentIndex ), ".data");
			_fileName = _buffer;
		}
		/* end existSegment:inImage: */
	} while (fileExists(_fileName));
	/* begin finalizeSegmentsRead:newBase: */
	assert((_newBase - (((getMemoryMap())->oldSpaceStart))) == (_totalBytesRead - ((numSegments()) * (bridgeSize()))));
	/* begin setCanSwizzle: */
	GIV(canSwizzle) = 1;
	/* end setCanSwizzle: */
	/* begin setFreeOldSpaceStart: */
	GIV(freeOldSpaceStart) = _newBase;
	/* end setFreeOldSpaceStart: */
	/* end finalizeSegmentsRead:newBase: */
	return _totalBytesRead;
}
/*	Write one image header file + many segments files (metadata & data per 
	segment) TODO: Rename this class */
/* ComposedImageWriter>>#CIW_writeImageFile:fromHeader: */
static void NoDbgRegParms
CIW_writeImageFilefromHeader(char *_imageFileName, SpurImageHeaderStruct _header)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char _buffer[255];
	char _buffer2[255];
	char _buffer22[255];
	char _buffer3[255];
	char _buffer4[255];
	size_t _bytesWritten;
	sqImageFile _dataFile;
	sqInt _fieldName;
	sqInt _fieldName2;
	sqInt _fieldValue;
	sqInt _fieldValue2;
	sqImageFile _file;
	sqInt _fullFileName;
	sqInt _fullFileName2;
	sqInt _i;
	sqInt _iLimit;
	ComposedMetadataStruct _metadata;
	sqImageFile _metadataFile;
	sqInt _name;
	sqInt _name2;
	size_t _nWritten;
	size_t _oldSpaceBytesWritten;
	size_t _permanentSpaceBytesWritten;
	sqInt _r;
	int _segmentIndex2;
	sqInt _size;
	sqInt _start;
	sqInt _successBoolean;
	size_t _total;

	_fieldName = 0;
	_fieldName2 = 0;
	_fieldValue = 0;
	_fieldValue2 = 0;
	_name = 0;
	_name2 = 0;
	logDebug("Writing snapshot %s", _imageFileName);
	/* begin createImageDirectory: */
	
#  if (defined(_WIN32)) || (defined(_WIN64))
	{
		mkdir(_imageFileName);
	}
#  else /* (defined(_WIN32)) || (defined(_WIN64)) */
	{
		mkdir(_imageFileName, 0x1FF);
	}
#  endif /* (defined(_WIN32)) || (defined(_WIN64)) */
	/* end createImageDirectory: */
	/* begin writeHeaderFile:fromHeader: */
	/* begin simulationOnly: */
	/* end simulationOnly: */
	_file = sqImageFileOpen(headerFileNameinImageintobufferSize(_imageFileName, _buffer3, 0xFF), "w");
	if (!_file) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		goto l4;
		/* end primitiveFail */
	}
	/* begin writeHeaderSTON:toFile: */
	/* begin writeSTON:toFile: */
	{
		fprintf(_file, "%s {\n", "SpurImageHeaderStruct");
	}
	{
		fprintf(_file, fieldFormat(), "dataSize", ((sqInt) ((_header.dataSize)) ));
		fprintf(_file, ",\n");
		fprintf(_file, fieldFormat(), "hdrOldSpaceSize", ((sqInt) ((_header.hdrOldSpaceSize)) ));
		fprintf(_file, ",\n");
		fprintf(_file, fieldFormat(), "oldBaseAddr", ((sqInt) ((_header.oldBaseAddr)) ));
		fprintf(_file, ",\n");
		fprintf(_file, fieldFormat(), "initialSpecialObjectsOop", ((sqInt) ((_header.initialSpecialObjectsOop)) ));
		fprintf(_file, ",\n");
		fprintf(_file, fieldFormat(), "headerFlags", ((sqInt) ((_header.headerFlags)) ));
		fprintf(_file, ",\n");
		fprintf(_file, fieldFormat(), "extraVMMemory", ((sqInt) ((_header.extraVMMemory)) ));
		fprintf(_file, ",\n");
		fprintf(_file, fieldFormat(), "hdrNumStackPages", ((sqInt) ((_header.hdrNumStackPages)) ));
		fprintf(_file, ",\n");
		fprintf(_file, fieldFormat(), "hdrCogCodeSize", ((sqInt) ((_header.hdrCogCodeSize)) ));
		fprintf(_file, ",\n");
		fprintf(_file, fieldFormat(), "hdrEdenBytes", ((sqInt) ((_header.hdrEdenBytes)) ));
		fprintf(_file, ",\n");
		fprintf(_file, fieldFormat(), "hdrMaxExtSemTabSize", ((sqInt) ((_header.hdrMaxExtSemTabSize)) ));
		fprintf(_file, ",\n");
		fprintf(_file, fieldFormat(), "firstSegSize", ((sqInt) ((_header.firstSegSize)) ));
		fprintf(_file, ",\n");
		fprintf(_file, fieldFormat(), "freeOldSpaceInImage", ((sqInt) ((_header.freeOldSpaceInImage)) ));
		fprintf(_file, ",\n");
		fprintf(_file, fieldFormat(), "swapBytes", ((sqInt) ((_header.swapBytes)) ));
		fprintf(_file, ",\n");
		fprintf(_file, fieldFormat(), "hdrLastHash", ((sqInt) ((_header.hdrLastHash)) ));
		fprintf(_file, ",\n");
		fprintf(_file, fieldFormat(), "imageFormat", ((sqInt) ((_header.imageFormat)) ));
		fprintf(_file, ",\n");
		fprintf(_file, fieldFormat(), "imageHeaderSize", ((sqInt) ((_header.imageHeaderSize)) ));
		fprintf(_file, ",\n");
		fprintf(_file, fieldFormat(), "imageVersion", ((sqInt) ((_header.imageVersion)) ));
	}
	fprintf(_file, "\n}");
	/* end writeSTON:toFile: */
	/* end writeHeaderSTON:toFile: */
	sqImageFileClose(_file);
	l4:
	;
	/* end writeHeaderFile:fromHeader: */
	flag("TODO");
	/* begin writeImageSegments: */
	/* begin beginWriteImageSegments */
	assert((firstSegmentBytes()) > 0);
	/* end beginWriteImageSegments */
	/* begin ensureDeleteSegments: */
	_segmentIndex2 = 0;
	while (existSegmentinImage(_segmentIndex2, _imageFileName)) {
		_r = unlink(segmentMetadataFileinImage(_segmentIndex2, _imageFileName));
		if (_r != 0) {
			logError("Error deleting %s", segmentMetadataFileinImage(_segmentIndex2, _imageFileName));
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			goto l2;
			/* end primitiveFail */
		}
		_r = unlink((/* begin simulationOnly: */ /* end simulationOnly: */ snprintf(_buffer, 0xFF, "%s/seg%d%s", ((char *) _imageFileName ), ((int) _segmentIndex2 ), ".data"), _buffer));
		if (_r != 0) {
			logError("Error deleting %s", (/* begin simulationOnly: */ /* end simulationOnly: */ snprintf(_buffer2, 0xFF, "%s/seg%d%s", ((char *) _imageFileName ), ((int) _segmentIndex2 ), ".data"), _buffer2));
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			goto l2;
			/* end primitiveFail */
		}
		_segmentIndex2 += 1;
	}
	l2:
	;
	/* end ensureDeleteSegments: */
	if (GIV(primFailCode)) {
		_oldSpaceBytesWritten = 0;
		goto l3;
	}
	/* begin withNonEmptySegmentsDo: */
	_total = 0;
	for (_i = 0, _iLimit = (numSegments()) - 1; _i <= _iLimit; _i += 1) {
		if ((((GIV(segments)[_i]).segSize)) > (2 * BaseHeaderSize)) {
			_total += writeSegmentnextIndexinImage(&(GIV(segments)[_i]), _i, _imageFileName);
		}
	}
	_oldSpaceBytesWritten = _total;
	/* end withNonEmptySegmentsDo: */
	l3:
	;
	/* end writeImageSegments: */
	/* begin writeImagePermanentSpace: */
	/* begin writePermanentSpaceMetadata: */
	/* begin simulationOnly: */
	/* end simulationOnly: */
	(_metadata.startAddress = ((getMemoryMap())->permSpaceStart));
	(_metadata.dataSize = totalBytesInPermanentSpace());
	/* begin writeMetadata:inFileName: */
	{
		/* begin simulationOnly: */
		/* end simulationOnly: */
		/* begin permSpaceFileName:inImage:into:bufferSize: */
		snprintf(_buffer4, 0xFF, "%s/%s", ((char *) _imageFileName ), ((char *) "permSpace.ston" ));
		_fullFileName = _buffer4;
		/* end permSpaceFileName:inImage:into:bufferSize: */
	}
	_metadataFile = sqImageFileOpen(_fullFileName, "w");
	if (!_metadataFile) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		goto l6;
		/* end primitiveFail */
	}
	/* begin writeSTON:toFile: */
	{
		fprintf(_metadataFile, "%s {\n", "ComposedMetadataStruct");
	}
	{
		fprintf(_metadataFile, fieldFormat(), "startAddress", ((sqInt) ((_metadata.startAddress)) ));
		fprintf(_metadataFile, ",\n");
		fprintf(_metadataFile, fieldFormat(), "dataSize", ((sqInt) ((_metadata.dataSize)) ));
	}
	fprintf(_metadataFile, "\n}");
	/* end writeSTON:toFile: */
	sqImageFileClose(_metadataFile);
	l6:
	;
	/* end writeMetadata:inFileName: */
	/* end writePermanentSpaceMetadata: */
	/* begin writePermanentSpaceData: */
	/* begin writeDataStatingAt:withSize:inFileName: */
	_start = ((sqInt) ((void *) (((getMemoryMap())->permSpaceStart)) ) );
	/* begin totalBytesInPermanentSpace */
	_size = ((size_t) (GIV(permSpaceFreeStart) - ((GIV(memoryMap)->permSpaceStart))) );
	/* end totalBytesInPermanentSpace */
	{
		/* begin simulationOnly: */
		/* end simulationOnly: */
		snprintf(_buffer22, 0xFF, "%s/%s", ((char *) _imageFileName ), ((char *) "permSpace.data" ));
		_fullFileName2 = _buffer22;
	}
	_dataFile = sqImageFileOpen(_fullFileName2, "wb");
	if (!_dataFile) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		_permanentSpaceBytesWritten = null;
		goto l7;
		/* end primitiveFail */
	}
	_nWritten = 0;
	if (_size > 0) {
		_nWritten = sqImageFileWrite(_start, 1, _size, _dataFile);
	}
	sqImageFileClose(_dataFile);
	_permanentSpaceBytesWritten = _nWritten;
	/* end writeDataStatingAt:withSize:inFileName: */
	/* end writePermanentSpaceData: */
	l7:
	;
	/* end writeImagePermanentSpace: */
	_bytesWritten = _oldSpaceBytesWritten + _permanentSpaceBytesWritten;
	/* begin success: */
	_successBoolean = _bytesWritten == ((_header.dataSize));
	if (!_successBoolean) {
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
	}
	/* end success: */
}
/* ComposedImageWriter>>#writeSegment:nextIndex:inImage: */
static size_t NoDbgRegParms
writeSegmentnextIndexinImage(SpurSegmentInfo *_segment, sqInt _segmentIndex, char *_imageFileName)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char _buffer[255];
	char _buffer2[255];
	sqImageFile _dataFile;
	sqInt _fieldName;
	sqInt _fieldValue;
	sqInt _fullFileName;
	sqInt _fullFileName2;
	ComposedMetadataStruct _metadata;
	sqImageFile _metadataFile;
	sqInt _name;
	size_t _nWritten;
	sqInt _size;
	sqInt _start;

	_fieldName = 0;
	_fieldValue = 0;
	_name = 0;
	logDebug(msgFormat("Segment Start: "), (_segment->segStart));
	logDebug(msgFormat("Segment Size: "), (_segment->segSize));
	/* begin writeSegmentMetadata:nextIndex:inImage: */
	/* begin simulationOnly: */
	/* end simulationOnly: */
	(_metadata.startAddress = (_segment->segStart));
	(_metadata.dataSize = (_segment->segSize));
	/* begin writeMetadata:inFileName: */
	/* begin segmentMetadataFile:inImage: */
	/* begin simulationOnly: */
	/* end simulationOnly: */
	/* begin segmentFileName:withExtension:inImage:into:bufferSize: */
	{
		snprintf(_buffer2, 0xFF, "%s/seg%d%s", ((char *) _imageFileName ), ((int) _segmentIndex ), ".ston");
		_fullFileName = _buffer2;
	}
	/* end segmentFileName:withExtension:inImage:into:bufferSize: */
	/* end segmentMetadataFile:inImage: */
	_metadataFile = sqImageFileOpen(_fullFileName, "w");
	if (!_metadataFile) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		goto l2;
		/* end primitiveFail */
	}
	/* begin writeSTON:toFile: */
	{
		fprintf(_metadataFile, "%s {\n", "ComposedMetadataStruct");
	}
	{
		fprintf(_metadataFile, fieldFormat(), "startAddress", ((sqInt) ((_metadata.startAddress)) ));
		fprintf(_metadataFile, ",\n");
		fprintf(_metadataFile, fieldFormat(), "dataSize", ((sqInt) ((_metadata.dataSize)) ));
	}
	fprintf(_metadataFile, "\n}");
	/* end writeSTON:toFile: */
	sqImageFileClose(_metadataFile);
	l2:
	;
	/* end writeMetadata:inFileName: */
	/* end writeSegmentMetadata:nextIndex:inImage: */
	/* begin writeSegmentData:nextIndex:inImage: */
	/* begin writeDataStatingAt:withSize:inFileName: */
	_start = ((sqInt) ((void *) ((_segment->segStart)) ) );
	_size = (_segment->segSize);
	{
		/* begin simulationOnly: */
		/* end simulationOnly: */
		{
			snprintf(_buffer, 0xFF, "%s/seg%d%s", ((char *) _imageFileName ), ((int) _segmentIndex ), ".data");
			_fullFileName2 = _buffer;
		}
	}
	_dataFile = sqImageFileOpen(_fullFileName2, "wb");
	if (!_dataFile) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	_nWritten = 0;
	if (_size > 0) {
		_nWritten = sqImageFileWrite(_start, 1, _size, _dataFile);
	}
	sqImageFileClose(_dataFile);
	return _nWritten;
	/* end writeDataStatingAt:withSize:inFileName: */
	/* end writeSegmentData:nextIndex:inImage: */
}
/* InterpreterPrimitives>>#canBeImmutable: */

#if IMMUTABILITY
static sqInt NoDbgRegParms
canBeImmutable(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _processLists;
	sqInt _schedAssoc;
	sqInt _scheduler;

	assert(isNonImmediate(_oop));
	if (((_oop & (tagMask())) == 0) && (((longAt(_oop)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
		return 0;
	}
	if ((assert(isNonImmediate(_oop)), isEphemeronFormat((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())))) {
		return 0;
	}
	if (isWeakFormat((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask()))) {
		return 0;
	}
	if (((longAt(_oop)) & (classIndexMask())) == (rawHashBitsOf(splObj(ClassSemaphore)))) {
		return 0;
	}
	/* begin fetchPointer:ofObject: */
	_schedAssoc = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_schedAssoc == GIV(nilObj)) {
		return 1;
	}
	_scheduler = unsignedLongAt((_schedAssoc + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
	_processLists = unsignedLongAt((_scheduler + BaseHeaderSize) + ((sqInt) (((usqInt) ProcessListsIndex ) << (shiftForWord())) ));
	if (_oop == _scheduler) {
		return 0;
	}
	if (_oop == _processLists) {
		return 0;
	}
	if ((classIndexOf(unsignedLongAt((_processLists + BaseHeaderSize) + (1U << (shiftForWord()))))) == ((longAt(_oop)) & (classIndexMask()))) {
		return 0;
	}
	if ((classIndexOf(unsignedLongAt((_scheduler + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) )))) == ((longAt(_oop)) & (classIndexMask()))) {
		return 0;
	}
	return 1;
}
#endif /* IMMUTABILITY */
/*	Answer either a malloced string with the null-terminated contents of oop 
	if oop is a string, 
	or the null pointer if oop is nil, or fail. It is the client's 
	responsibility to free the string later. */
/* InterpreterPrimitives>>#cStringOrNullFor: */
char *
cStringOrNullFor(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _ccIndex;
	sqInt _classOop;
	char *_cString;
	sqInt _fmt;
	sqInt _isString;
	sqInt _len;
	usqInt _numSlots;
	usqInt _numSlots2;

	/* begin is:instanceOf:compactClassIndex: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteString ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	if (_oop & (tagMask())) {
		_isString = 0;
		goto l3;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	assert(!(isImmediate(_oop)));
	/* begin classIndexOf: */
	_ccIndex = (longAt(_oop)) & (classIndexMask());
	/* end classIndexOf: */
	{
		_isString = ClassByteStringCompactIndex == _ccIndex;
		goto l3;
	}
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	l3:
	;
	/* end is:instanceOf:compactClassIndex: */
	if (!_isString) {
		if (_oop != GIV(nilObj)) {
			GIV(primFailCode) = PrimErrBadArgument;
		}
		return 0;
	}
	/* begin lengthOf:format: */
	_fmt = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOfAny: */
	_numSlots2 = byteAt(_oop + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_oop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOfAny: */
	if (_fmt <= 5) {
		_len = _numSlots;
		goto l5;
	}
	if (_fmt >= (firstByteFormat())) {
		_len = (_numSlots << (shiftForWord())) - (_fmt & 7);
		goto l5;
	}
	if (_fmt >= (firstShortFormat())) {
		_len = (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
		goto l5;
	}
	if (_fmt >= (firstLongFormat())) {
		_len = (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
		goto l5;
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		_len = _numSlots;
		goto l5;
	}
	_len = 0;
	l5:
	;
	/* end lengthOf:format: */
	if (_len == 0) {
		return 0;
	}
	_cString = malloc(_len + 1);
	if (!_cString) {
		GIV(primFailCode) = PrimErrNoCMemory;
		return 0;
	}
	memcpy(_cString, firstIndexableField(_oop), _len);
	_cString[_len] = 0;
	return _cString;
}
/* InterpreterPrimitives>>#doWaitSemaphore: */
void
doWaitSemaphore(sqInt _sema)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeProc;
	sqInt _excessSignals;
	sqInt _inInterpreter;
	sqInt _objOop;
	sqInt _objOop2;

	/* begin doWaitSemaphore:reEnterInterpreter: */
	_excessSignals = fetchIntegerofObject(ExcessSignalsIndex, _sema);
	if (_excessSignals > 0) {
		/* begin storeInteger:ofObject:withValue: */
		if ((((((usqInt) (_excessSignals - 1) ) >> 60) + 1) & 15) <= 1) {
			/* begin storePointerUnchecked:ofObject:withValue: */
			assert(!(isOopForwarded(_sema)));
			longAtput((_sema + BaseHeaderSize) + ((sqInt) (((usqInt) ExcessSignalsIndex ) << (shiftForWord())) ), ((((usqInt) (_excessSignals - 1) ) << 3) | 1));
			/* end storePointerUnchecked:ofObject:withValue: */
		} else {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
		}
		/* end storeInteger:ofObject:withValue: */
	} else {
		_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
		/* begin memoryActiveProcess */
		/* begin fetchPointer:ofObject: */
		/* begin fetchPointer:ofObject: */
		/* begin splObj: */
		/* begin fetchPointer:ofObject: */
		_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		_activeProc = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end memoryActiveProcess */
		addLastLinktoList(_activeProc, _sema);
		transferTofrom(wakeHighestPriority(), CSWait);
		{
			/* begin forProcessPrimitiveReturnToExecutivePostContextSwitch: */
			if (GIV(nextProfileTick) > 0) {
				checkProfileTick(GIV(newMethod));
			}
			returnToExecutivepostContextSwitch(_inInterpreter, 1);
			/* end forProcessPrimitiveReturnToExecutivePostContextSwitch: */
		}
	}
	/* end doWaitSemaphore:reEnterInterpreter: */
}
/*	In C, non-zero is true, so avoid computation by simply answering 
	primFailCode in the C version. */
/* InterpreterPrimitives>>#failed */
sqInt
failed(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(primFailCode);
}
/*	Answer true if integer object is negative. 
	Fail if object pointed by oop i not an integer. */
/* InterpreterPrimitives>>#isNegativeIntegerValueOf: */
static sqInt NoDbgRegParms
isNegativeIntegerValueOf(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _ccIndex;
	sqInt _ccIndex2;
	sqInt _classOop;
	sqInt _classOop2;
	sqInt _ok;
	sqInt _smallInt;

	if (((_oop & 7) == 1)) {
		_smallInt = _oop >> 3;
		return _smallInt < 0;
	}
	if ((_oop & (tagMask())) == 0) {
		/* begin isClassOfNonImm:equalTo:compactClassIndex: */
		_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
		assert(!(isImmediate(_oop)));
		/* begin classIndexOf: */
		_ccIndex = (longAt(_oop)) & (classIndexMask());
		/* end classIndexOf: */
		{
			_ok = ClassLargePositiveIntegerCompactIndex == _ccIndex;
			goto l3;
		}
		l3:
		;
		/* end isClassOfNonImm:equalTo:compactClassIndex: */
		if (_ok) {
			return 0;
		}
		/* begin isClassOfNonImm:equalTo:compactClassIndex: */
		_classOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargeNegativeInteger ) << (shiftForWord())) ));
		assert(!(isImmediate(_oop)));
		/* begin classIndexOf: */
		_ccIndex2 = (longAt(_oop)) & (classIndexMask());
		/* end classIndexOf: */
		{
			_ok = ClassLargeNegativeIntegerCompactIndex == _ccIndex2;
			goto l5;
		}
		l5:
		;
		/* end isClassOfNonImm:equalTo:compactClassIndex: */
		if (_ok) {
			return 1;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	return 0;
}
/*	Answer if oop is a value of an integer in address range, i.e up to the 
	size of a machine word. 
	The object may be either a positive SmallInteger or a LargePositiveInteger 
	of size <= word size. */
/* InterpreterPrimitives>>#isPositiveMachineIntegerObject: */
sqInt
isPositiveMachineIntegerObject(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _ccIndex;
	sqInt _classOop;
	sqInt _ok;

	if (((_oop & 7) == 1)) {
		return (_oop >> 3) >= 0;
	}
	if (_oop & (tagMask())) {
		return 0;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(_oop)));
	/* begin classIndexOf: */
	_ccIndex = (longAt(_oop)) & (classIndexMask());
	/* end classIndexOf: */
	{
		_ok = ClassLargePositiveIntegerCompactIndex == _ccIndex;
		goto l3;
	}
	l3:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	return _ok && ((numBytesOfBytes(_oop)) <= (sizeof(usqIntptr_t)));
}
/*	Return a Large Integer object for the given integer magnitude and sign */
/* InterpreterPrimitives>>#magnitude64BitIntegerFor:neg: */
static sqInt NoDbgRegParms
magnitude64BitIntegerForneg(usqLong _magnitude, sqInt _isNegative)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	int _isSmall;
	sqInt _largeClass;
	sqInt _newLargeInteger;
	sqInt _smallVal;
	int _sz;

	_isSmall = ((_isNegative)
		 ? _magnitude <= (MaxSmallInteger + 1)
		 : _magnitude <= MaxSmallInteger);
	if (_isSmall) {
		_smallVal = ((sqInt) _magnitude );
		if (_isNegative) {
			_smallVal = 0 - _smallVal;
		}
		return ((((usqInt) _smallVal ) << 3) | 1);
	}
	if (_isNegative) {
		/* begin knownClassAtIndex: */
		assert((ClassLargeNegativeIntegerCompactIndex >= 1) && (ClassLargeNegativeIntegerCompactIndex <= (classTablePageSize())));
		/* begin fetchPointer:ofObject: */
		_largeClass = unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargeNegativeIntegerCompactIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end knownClassAtIndex: */
	}
 else {
		/* begin knownClassAtIndex: */
		assert((ClassLargePositiveIntegerCompactIndex >= 1) && (ClassLargePositiveIntegerCompactIndex <= (classTablePageSize())));
		/* begin fetchPointer:ofObject: */
		_largeClass = unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveIntegerCompactIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end knownClassAtIndex: */
	}
	{
		_sz = 8;
	}
	_newLargeInteger = instantiateClassindexableSizeisPinnedisOldSpace(_largeClass, _sz, 0, 0);
	long64Atput((_newLargeInteger + BaseHeaderSize) + (0U << 3), SQ_SWAP_8_BYTES_IF_BIGENDIAN(_magnitude));
	return _newLargeInteger;
}
/*	Convert the given object into an integer value. 
	The object may be either a positive SmallInteger or an eight-byte 
	LargeInteger.  */
/* InterpreterPrimitives>>#magnitude64BitValueOf: */
static usqLong NoDbgRegParms
magnitude64BitValueOf(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _ccIndex;
	sqInt _ccIndex2;
	sqInt _classOop;
	sqInt _classOop2;
	sqInt _fmt;
	sqInt _ok;
	sqInt _smallIntValue;
	sqInt _sz;
	usqLong _value;

	if (((_oop & 7) == 1)) {
		_smallIntValue = _oop >> 3;
		if (_smallIntValue < 0) {
			_smallIntValue = 0 - _smallIntValue;
		}
		return ((usqLong) _smallIntValue );
	}
	if (_oop & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	_classOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(_oop)));
	/* begin classIndexOf: */
	_ccIndex2 = (longAt(_oop)) & (classIndexMask());
	/* end classIndexOf: */
	{
		_ok = ClassLargePositiveIntegerCompactIndex == _ccIndex2;
		goto l5;
	}
	l5:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (!_ok) {
		/* begin isClassOfNonImm:equalTo:compactClassIndex: */
		_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargeNegativeInteger ) << (shiftForWord())) ));
		assert(!(isImmediate(_oop)));
		/* begin classIndexOf: */
		_ccIndex = (longAt(_oop)) & (classIndexMask());
		/* end classIndexOf: */
		{
			_ok = ClassLargeNegativeIntegerCompactIndex == _ccIndex;
			goto l3;
		}
		l3:
		;
		/* end isClassOfNonImm:equalTo:compactClassIndex: */
		if (!_ok) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return 0;
		}
	}
	/* begin numBytesOfBytes: */
	_fmt = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
	assert(_fmt >= (firstByteFormat()));
	_sz = ((numSlotsOf(_oop)) << (shiftForWord())) - (_fmt & 7);
	/* end numBytesOfBytes: */
	if (_sz > (sizeof(sqLong))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	if (_sz > 4) {
		_value = SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((_oop + BaseHeaderSize) + (0U << 3)));
	} else {
		_value = ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_oop + BaseHeaderSize) + (0U << 2)))) );
	}
	return _value;
}
/*	Convert the given object into an integer value. 
	The object may be either a positive SmallInteger or a four-byte 
	LargePositiveInteger.  */
/* InterpreterPrimitives>>#positive32BitValueOf: */
unsigned int
positive32BitValueOf(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _value64;

	{
		if (((_oop & 7) == 1)) {
			_value64 = _oop >> 3;
			if ((_value64 < 0) || (((unsigned int) _value64 ) != _value64)) {
				/* begin primitiveFail */
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
				/* end primitiveFail */
				_value64 = 0;
			}
			return _value64;
		}
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
}
/*	Convert the given object into an integer value. 
	The object may be either a positive SmallInteger or an eight-byte 
	LargePositiveInteger.  */
/* InterpreterPrimitives>>#positive64BitValueOf: */
usqLong
positive64BitValueOf(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _ccIndex;
	sqInt _classOop;
	sqInt _fmt;
	sqInt _ok;
	sqInt _sz;
	usqLong _value;

	if (((_oop & 7) == 1)) {
		if ((_oop >> 3) < 0) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			return null;
			/* end primitiveFail */
		}
		return _oop >> 3;
	}
	if (_oop & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(_oop)));
	/* begin classIndexOf: */
	_ccIndex = (longAt(_oop)) & (classIndexMask());
	/* end classIndexOf: */
	{
		_ok = ClassLargePositiveIntegerCompactIndex == _ccIndex;
		goto l3;
	}
	l3:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (!_ok) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	/* begin numBytesOfBytes: */
	_fmt = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
	assert(_fmt >= (firstByteFormat()));
	_sz = ((numSlotsOf(_oop)) << (shiftForWord())) - (_fmt & 7);
	/* end numBytesOfBytes: */
	if (_sz > (sizeof(sqLong))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	if (_sz > 4) {
		_value = SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((_oop + BaseHeaderSize) + (0U << 3)));
	} else {
		_value = ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_oop + BaseHeaderSize) + (0U << 2)))) );
	}
	return _value;
}
/*	Answer a value of an integer in address range, i.e up to the size of a 
	machine word. 
	The object may be either a positive SmallInteger or a LargePositiveInteger 
	of size <= word size.only two callers & one is primitiveNewWithArg */
/* InterpreterPrimitives>>#positiveMachineIntegerValueOf: */
usqIntptr_t
positiveMachineIntegerValueOf(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _bs;
	sqInt _ccIndex;
	sqInt _classOop;
	sqInt _fmt;
	sqInt _ok;
	sqInt _value;

	if (((_oop & 7) == 1)) {
		_value = _oop >> 3;
		if (_value < 0) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			return null;
			/* end primitiveFail */
		}
		return _value;
	}
	if (_oop & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(_oop)));
	/* begin classIndexOf: */
	_ccIndex = (longAt(_oop)) & (classIndexMask());
	/* end classIndexOf: */
	{
		_ok = ClassLargePositiveIntegerCompactIndex == _ccIndex;
		goto l3;
	}
	l3:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (!_ok) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	/* begin numBytesOfBytes: */
	_fmt = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
	assert(_fmt >= (firstByteFormat()));
	_bs = ((numSlotsOf(_oop)) << (shiftForWord())) - (_fmt & 7);
	/* end numBytesOfBytes: */
	if (_bs > (sizeof(usqIntptr_t))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	if (((sizeof(usqIntptr_t)) == 8) && (_bs > 4)) {
		return SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((_oop + BaseHeaderSize) + (0U << 3)));
	}
 else {
		return ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_oop + BaseHeaderSize) + (0U << 2)))) );
	}
}
/* InterpreterPrimitives>>#primitiveAdd */
static void
primitiveAdd(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerResult;
	char *_sp;

	/* begin pop2AndPushIntegerIfOK: */
	_integerResult = (stackIntegerValue(1)) + (stackIntegerValue(0));
	if (!GIV(primFailCode)) {
		if ((((((usqInt) _integerResult ) >> 60) + 1) & 15) <= 1) {
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((((usqInt) _integerResult ) << 3) | 1));
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
		} else {
			/* begin success: */
			{
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
			}
			/* end success: */
		}
	}
	/* end pop2AndPushIntegerIfOK: */
}
/*	Primitive arithmetic operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveAddLargeIntegers */
EXPORT(void)
primitiveAddLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _a;
	sqInt _aIsNegative;
	usqLong _b;
	sqInt _bIsNegative;
	sqInt _oopArg;
	sqInt _oopRcvr;
	sqInt _oopResult;
	usqLong _result;
	sqInt _resultIsNegative;
	char *_sp;

	_oopArg = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	_oopRcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_aIsNegative = isNegativeIntegerValueOf(_oopRcvr);
	_bIsNegative = isNegativeIntegerValueOf(_oopArg);
	_a = magnitude64BitValueOf(_oopRcvr);
	_b = magnitude64BitValueOf(_oopArg);
	if (GIV(primFailCode)) {
		{
			return;
		}
	}
	if (_aIsNegative == _bIsNegative) {
		if (_a > (0xFFFFFFFFFFFFFFFFULL - _b)) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			{
				return;
			}
		}
		_result = _a + _b;
		_resultIsNegative = _aIsNegative;
	} else {
		if (_a >= _b) {
			_result = _a - _b;
			_resultIsNegative = _aIsNegative;
		} else {
			_result = _b - _a;
			_resultIsNegative = _bIsNegative;
		}
	}
	_oopResult = magnitude64BitIntegerForneg(_result, _resultIsNegative);
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oopResult);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/*	Primitive. Change the class of the argument to make it an instance of the 
	receiver given that the format of the receiver matches the format of the 
	argument's class. 
	Fail if receiver or argument are SmallIntegers, or the receiver is an 
	instance of a 
	compact class and the argument isn't, or when the argument's class is 
	compact and 
	the receiver isn't, or when the format of the receiver is different from 
	the format of 
	the argument's class, or when the arguments class is fixed and the 
	receiver's size 
	differs from the size that an instance of the argument's class should 
	have.  */
/* InterpreterPrimitives>>#primitiveAdoptInstance */
static void
primitiveAdoptInstance(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _arg;
	sqInt _err;
	sqInt _rcvr;

	_arg = unsignedLongAt(GIV(stackPointer));
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if ((_arg & (tagMask())) || ((GIV(argumentCount) > 1) && ((_rcvr & (tagMask())) || (!(objCouldBeClassObj(_rcvr)))))) {
		{
			GIV(primFailCode) = PrimErrBadArgument;
			return;
		}
	}
	_err = changeClassOfto(_arg, _rcvr);
	if (_err == 0) {
		/* begin pop: */
		GIV(stackPointer) += GIV(argumentCount) * BytesPerWord;
		/* end pop: */
	} else {
		if (_err == PrimErrBadReceiver) {
			_err = PrimErrBadArgument;
		} else {
			if (_err == PrimErrBadArgument) {
				_err = PrimErrBadReceiver;
			}
		}
		GIV(primFailCode) = _err;
	}
	{
		return;
	}
}
/*	Answer an array of all instances of the receiver that exist 
	when the primitive is called, excluding any that may be 
	garbage collected as a side effect of allocating the result array. */
/* InterpreterPrimitives>>#primitiveAllInstances */
EXPORT(void)
primitiveAllInstances(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _delta;
	sqInt _result;
	char *_sp;

	_result = allInstancesOf(unsignedLongAt(GIV(stackPointer)));
	if (((_result & 7) == 1)) {
		/* begin growToAccomodateContainerWithNumSlots: */
		_delta = (BaseHeaderSize * 2) + ((_result >> 3) * BytesPerOop);
		growOldSpaceByAtLeastcallingOperation(((GIV(growHeadroom) < _delta) ? _delta : GIV(growHeadroom)), "growing to accomodate allObjects / allInstances container");
		/* end growToAccomodateContainerWithNumSlots: */
		_result = allInstancesOf(unsignedLongAt(GIV(stackPointer)));
		if (((_result & 7) == 1)) {
			{
				GIV(primFailCode) = PrimErrNoMemory;
				return;
			}
		}
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _result);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Answer an array of all objects that exist when the primitive 
	is called, excluding those that may be garbage collected as 
	a side effect of allocating the result array. */
/* InterpreterPrimitives>>#primitiveAllObjects */
EXPORT(void)
primitiveAllObjects(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _delta;
	sqInt _result;
	char *_sp;

	_result = allObjects();
	if (((_result & 7) == 1)) {
		/* begin growToAccomodateContainerWithNumSlots: */
		_delta = (BaseHeaderSize * 2) + ((_result >> 3) * BytesPerOop);
		growOldSpaceByAtLeastcallingOperation(((GIV(growHeadroom) < _delta) ? _delta : GIV(growHeadroom)), "growing to accomodate allObjects / allInstances container");
		/* end growToAccomodateContainerWithNumSlots: */
		_result = allObjects();
		if (((_result & 7) == 1)) {
			{
				GIV(primFailCode) = PrimErrNoMemory;
				return;
			}
		}
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _result);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	N.B. IMO we should be able to assume the receiver is a float because this 
	primitive is specific to floats. eem 2/13/2017 */
/* InterpreterPrimitives>>#primitiveArctan */
static void
primitiveArctan(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aValue;
	double _rcvr;

	/* begin stackFloatValue: */
	_rcvr = floatValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	/* end stackFloatValue: */
	if (!GIV(primFailCode)) {
		/* begin stackTopPut: */
		_aValue = floatObjectOf(atan(_rcvr));
		unsignedLongAtput(GIV(stackPointer), _aValue);
		/* end stackTopPut: */
	}
}
/*	We must flush the method cache here, to eliminate stale references 
	to mutated classes and/or selectors. */
/* InterpreterPrimitives>>#primitiveArrayBecome */
static void
primitiveArrayBecome(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _arg;
	sqInt _ec;
	sqInt _rcvr;

	_arg = unsignedLongAt(GIV(stackPointer));
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_ec = becomewithtwoWaycopyHash(_rcvr, _arg, 1, 0);
	if (_ec == PrimNoErr) {
		/* begin pop: */
		GIV(stackPointer) += 1 * BytesPerWord;
		/* end pop: */
	} else {
		GIV(primFailCode) = _ec;
	}
}
/*	We must flush the method cache here, to eliminate stale references 
	to mutated classes and/or selectors. */
/* InterpreterPrimitives>>#primitiveArrayBecomeOneWay */
static void
primitiveArrayBecomeOneWay(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _arg;
	sqInt _ec;
	sqInt _rcvr;

	_arg = unsignedLongAt(GIV(stackPointer));
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_ec = becomewithtwoWaycopyHash(_rcvr, _arg, 0, 1);
	if (_ec == PrimNoErr) {
		/* begin pop: */
		GIV(stackPointer) += 1 * BytesPerWord;
		/* end pop: */
	} else {
		GIV(primFailCode) = _ec;
	}
}
/*	Similar to primitiveArrayBecomeOneWay but accepts a third argument 
	deciding whether to 
	copy the receiver's elements identity hashes over the argument's elements 
	identity hashes. */
/* InterpreterPrimitives>>#primitiveArrayBecomeOneWayCopyHash */
static void
primitiveArrayBecomeOneWayCopyHash(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	int _copyHashFlag;
	sqInt _ec;

	_copyHashFlag = 0;
	if ((unsignedLongAt(GIV(stackPointer))) == GIV(trueObj)) {
		_copyHashFlag = 1;
	} else {
		if ((unsignedLongAt(GIV(stackPointer))) == GIV(falseObj)) {
			_copyHashFlag = 0;
		} else {
			GIV(primFailCode) = PrimErrBadArgument;
			{
				return;
			}
		}
	}
	_ec = becomewithtwoWaycopyHash(unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord)), unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord)), 0, _copyHashFlag);
	if (_ec == PrimNoErr) {
		/* begin pop: */
		GIV(stackPointer) += GIV(argumentCount) * BytesPerWord;
		/* end pop: */
	} else {
		GIV(primFailCode) = _ec;
	}
}
/*	Similar to primitiveArrayBecomeOneWay but does /not/ copy the receiver's 
	elements identity hashes over the argument's elements identity hashes. */
/* InterpreterPrimitives>>#primitiveArrayBecomeOneWayNoCopyHash */
static void
primitiveArrayBecomeOneWayNoCopyHash(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _arg;
	sqInt _ec;
	sqInt _rcvr;

	_arg = unsignedLongAt(GIV(stackPointer));
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_ec = becomewithtwoWaycopyHash(_rcvr, _arg, 0, 0);
	if (_ec == PrimNoErr) {
		/* begin pop: */
		GIV(stackPointer) += 1 * BytesPerWord;
		/* end pop: */
	} else {
		GIV(primFailCode) = _ec;
	}
}
/* InterpreterPrimitives>>#primitiveAsCharacter */
static void
primitiveAsCharacter(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _characterCode;
	sqInt _characterObject;
	sqInt _reasonCode;
	char *_sp;

	_characterCode = unsignedLongAt(GIV(stackPointer));
	if (!((((_characterCode & 7) == 1)) && (((_characterCode = _characterCode >> 3), (_characterCode >= 0) && (_characterCode <= ((1U << 30) - 1)))))) {
		{
			/* begin primitiveFailFor: */
			_reasonCode = ((GIV(argumentCount) == 0)
				 ? PrimErrBadReceiver
				 : PrimErrBadArgument);
			GIV(primFailCode) = _reasonCode;
			/* end primitiveFailFor: */
			return;
		}
	}
	_characterObject = ((sqInt) (((usqInt) _characterCode ) << (numTagBits())) ) + (characterTag());
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _characterObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	N.B. This will answer inexact results for integers with > 53 bits of 
	magnitude.  */
/* InterpreterPrimitives>>#primitiveAsFloat */
static void
primitiveAsFloat(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _rcvr;
	char *_sp;

	_rcvr = unsignedLongAt(GIV(stackPointer));
	assert(((_rcvr & 7) == 1));
	/* begin pop:thenPushFloat: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), floatObjectOf(((double) (_rcvr >> 3) )));
	GIV(stackPointer) = _sp;
	/* end pop:thenPushFloat: */
}
/* InterpreterPrimitives>>#primitiveAt */
static void
primitiveAt(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _class;
	sqInt _classFormat;
	sqInt _fixedFields;
	sqInt _fmt;
	sqInt _index;
	unsigned int _integerValue;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _rcvr;
	sqInt _reasonCode;
	sqInt _result;
	char *_sp;
	sqInt _sp2;
	sqInt _sp3;
	sqInt _stSize;
	sqInt _totalLength;

	/* begin commonAt: */
	/* begin initPrimCall */
	GIV(primFailCode) = 0;
	/* end initPrimCall */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_index = unsignedLongAt(GIV(stackPointer));
	if (_rcvr & (tagMask())) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrInappropriate;
		goto l10;
		/* end primitiveFailFor: */
	}
	if (((_index & (smallIntegerTag())) == 0) || ((GIV(argumentCount) > 1) && (((long64At(_rcvr)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		goto l10;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin stObject:at: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin lengthOf:format: */
	/* begin numSlotsOfAny: */
	_numSlots2 = byteAt(_rcvr + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOfAny: */
	if (_fmt <= 5) {
		_totalLength = _numSlots;
		goto l4;
	}
	if (_fmt >= (firstByteFormat())) {
		_totalLength = (_numSlots << (shiftForWord())) - (_fmt & 7);
		goto l4;
	}
	if (_fmt >= (firstShortFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
		goto l4;
	}
	if (_fmt >= (firstLongFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
		goto l4;
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		_totalLength = _numSlots;
		goto l4;
	}
	_totalLength = 0;
	l4:
	;
	/* end lengthOf:format: */
	/* begin fixedFieldsOf:format:length: */
	if ((_fmt >= (sixtyFourBitIndexableFormat())) || (_fmt == 2)) {
		_fixedFields = 0;
		goto l5;
	}
	if (_fmt < 2) {
		_fixedFields = _totalLength;
		goto l5;
	}
	_class = fetchClassOfNonImm(_rcvr);
	/* begin fixedFieldsOfClassFormat: */
	_classFormat = (unsignedLongAt((_class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	_fixedFields = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	/* end fixedFieldsOfClassFormat: */
	l5:
	;
	/* end fixedFieldsOf:format:length: */
	if ((_fmt == (indexablePointersFormat())) && (((long64At(_rcvr)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
		/* begin stackPointerForMaybeMarriedContext: */
		if (((((unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_rcvr)))) {
			_sp3 = stackPointerIndexForFrame(frameOfMarriedContext(_rcvr));
			assert((ReceiverIndex + (_sp3 >> 3)) < (lengthOf(_rcvr)));
			_stSize = _sp3;
			goto l7;
		}
		/* begin fetchStackPointerOf: */
		/* begin fetchPointer:ofObject: */
		_sp2 = unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (!(((_sp2 & 7) == 1))) {
			_stSize = 0;
			goto l7;
		}
		assert((ReceiverIndex + (_sp2 >> 3)) < (lengthOf(_rcvr)));
		_stSize = _sp2 >> 3;
		/* end fetchStackPointerOf: */
		l7:
		;
		/* end stackPointerForMaybeMarriedContext: */
		if ((oopisGreaterThanOrEqualTo(_index, 1)) && ((oopisLessThanOrEqualTo(_index, _stSize)) && (((((unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_rcvr)))))) {
			_result = noInlineTemporaryin(_index - 1, frameOfMarriedContext(_rcvr));
			goto l9;
		}
	} else {
		_stSize = _totalLength - _fixedFields;
	}
	if ((oopisGreaterThanOrEqualTo(_index, ((_fmt >= (firstCompiledMethodFormat()))
		 ? (((literalCountOf(_rcvr)) + LiteralStart) * BytesPerOop) + 1
		 : 1))) && (oopisLessThanOrEqualTo(_index, _stSize))) {
		/* begin subscript:with:format: */
		if (_fmt <= 5) {
			/* begin fetchPointer:ofObject: */
			_result = unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << (shiftForWord())) ));
			goto l9;
			/* end fetchPointer:ofObject: */
		}
		if (_fmt >= (firstByteFormat())) {
			_result = ((((usqInt) (byteAt((_rcvr + BaseHeaderSize) + ((_index + _fixedFields) - 1))) ) << 3) | 1);
			goto l9;
		}
		if (_fmt >= (firstShortFormat())) {
			_result = ((((usqInt) ((unsigned short) (shortAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 1) ))) ) ) << 3) | 1);
			goto l9;
		}
		if (_fmt == (sixtyFourBitIndexableFormat())) {
			_result = positive64BitIntegerFor(long64At((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 3) )));
			goto l9;
		}
		/* begin positive32BitIntegerFor: */
		_integerValue = long32At((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 2) ));
		{
			_result = (((((usqInt) _integerValue ) & 0xFFFFFFFFU) << 3) | 1);
			goto l9;
		}
		/* end positive32BitIntegerFor: */
		/* end subscript:with:format: */
	}
	/* begin primitiveFailFor: */
	_reasonCode = ((_fmt <= 1)
		 ? PrimErrBadReceiver
		 : PrimErrBadIndex);
	GIV(primFailCode) = _reasonCode;
	/* end primitiveFailFor: */
	_result = 0;
	l9:
	;
	/* end stObject:at: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _result);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
	l10:
	;
	/* end commonAt: */
}
/* InterpreterPrimitives>>#primitiveAtPut */
static void
primitiveAtPut(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _class2;
	sqInt _classFormat2;
	sqInt _fixedFields2;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numSlots22;
	usqInt _numSlots3;
	sqInt _rcvr;
	sqInt _reasonCode2;
	sqInt _signedValueToStore2;
	char *_sp;
	sqInt _stSize2;
	sqInt _totalLength2;
	usqLong _unsigned64BitValueToStore2;
	unsigned int _unsignedValueToStore2;
	sqInt _value;

	/* begin commonAtPut: */
	/* begin initPrimCall */
	GIV(primFailCode) = 0;
	/* end initPrimCall */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_value = unsignedLongAt(GIV(stackPointer));
	if (_rcvr & (tagMask())) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrInappropriate;
		goto l27;
		/* end primitiveFailFor: */
	}
	if (((_index & (smallIntegerTag())) == 0) || ((GIV(argumentCount) > 2) && (((long64At(_rcvr)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		goto l27;
		/* end primitiveFailFor: */
	}
	if (
#    if IMMUTABILITY
			(/* begin isImmutable: */ ((((usqInt) (longAt(_rcvr)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#    else /* IMMUTABILITY */
			0
#    endif /* IMMUTABILITY */
			) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrNoModification;
		goto l27;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	{
		/* begin stObject:at:put: */
		if (((long64At(_rcvr)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadReceiver;
			goto l26;
			/* end primitiveFailFor: */
		}
		_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
		/* begin lengthOf:format: */
		/* begin numSlotsOfAny: */
		_numSlots22 = byteAt(_rcvr + 7);
		_numSlots3 = ((_numSlots22 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots22);
		/* end numSlotsOfAny: */
		if (_fmt2 <= 5) {
			_totalLength2 = _numSlots3;
			goto l23;
		}
		if (_fmt2 >= (firstByteFormat())) {
			_totalLength2 = (_numSlots3 << (shiftForWord())) - (_fmt2 & 7);
			goto l23;
		}
		if (_fmt2 >= (firstShortFormat())) {
			_totalLength2 = (_numSlots3 << ((shiftForWord()) - 1)) - (_fmt2 & 3);
			goto l23;
		}
		if (_fmt2 >= (firstLongFormat())) {
			_totalLength2 = (_numSlots3 << ((shiftForWord()) - 2)) - (_fmt2 & 1);
			goto l23;
		}
		if (_fmt2 == (sixtyFourBitIndexableFormat())) {
			_totalLength2 = _numSlots3;
			goto l23;
		}
		_totalLength2 = 0;
		l23:
		;
		/* end lengthOf:format: */
		/* begin fixedFieldsOf:format:length: */
		if ((_fmt2 >= (sixtyFourBitIndexableFormat())) || (_fmt2 == 2)) {
			_fixedFields2 = 0;
			goto l19;
		}
		if (_fmt2 < 2) {
			_fixedFields2 = _totalLength2;
			goto l19;
		}
		_class2 = fetchClassOfNonImm(_rcvr);
		/* begin fixedFieldsOfClassFormat: */
		_classFormat2 = (unsignedLongAt((_class2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
		_fixedFields2 = _classFormat2 & ((1U << (fixedFieldsFieldWidth())) - 1);
		/* end fixedFieldsOfClassFormat: */
		l19:
		;
		/* end fixedFieldsOf:format:length: */
		_stSize2 = _totalLength2 - _fixedFields2;
		if ((oopisGreaterThanOrEqualTo(_index, ((_fmt2 >= (firstCompiledMethodFormat()))
			 ? (((literalCountOf(_rcvr)) + LiteralStart) * BytesPerOop) + 1
			 : 1))) && (oopisLessThanOrEqualTo(_index, _stSize2))) {
			/* begin subscript:with:storing:format: */
			if (_fmt2 <= 5) {
				/* begin storePointer:ofObject:withValue: */
				assert(!(isForwarded(_rcvr)));
				if (((_rcvr & (tagMask())) == 0) && ((_rcvr & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
					if (((_value & (tagMask())) == 0) && (((_value & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_value >= ((GIV(memoryMap)->newSpaceStart))))) {
						/* begin possibleOldObjectStoreInto: */
						if (!(((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0)) {
							remember(GIV(fromOldSpaceRememberedSet), _rcvr);
						}
						/* end possibleOldObjectStoreInto: */
					}
				}
				/* begin possiblePermObjectStoreInto:value: */
				if (((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0) {
					goto l17;
				}
				if (_value & (tagMask())) {
					goto l17;
				}
				if (!(_rcvr >= 0x20000000000LL)) {
					goto l17;
				}
				if (_value >= 0x20000000000LL) {
					goto l17;
				}
				if ((_value >= GIV(nilObj)) && (_value <= GIV(trueObj))) {
					goto l17;
				}
				if (!(_value >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l17;
				}
				remember(getFromPermToNewSpaceRememberedSet(), _rcvr);
				l17:
				;
				/* end possiblePermObjectStoreInto:value: */
				unsignedLongAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields2) - 1) ) << (shiftForWord())) ), _value);
				/* end storePointer:ofObject:withValue: */
				goto l21;
			}
			if (_fmt2 >= (firstByteFormat())) {
				if (!(((_value & 7) == 1))) {
					GIV(primFailCode) = PrimErrBadArgument;
					goto l21;
				}
				_signedValueToStore2 = _value >> 3;
				if (!((_signedValueToStore2 >= 0) && (_signedValueToStore2 <= 0xFF))) {
					GIV(primFailCode) = PrimErrBadArgument;
					goto l21;
				}
				/* begin storeByte:ofObject:withValue: */
				byteAtput((_rcvr + BaseHeaderSize) + ((_index + _fixedFields2) - 1), _signedValueToStore2);
				/* end storeByte:ofObject:withValue: */
				goto l21;
			}
			if (_fmt2 >= (firstShortFormat())) {
				if (!(((_value & 7) == 1))) {
					GIV(primFailCode) = PrimErrBadArgument;
					goto l21;
				}
				_signedValueToStore2 = _value >> 3;
				if (!((_signedValueToStore2 >= 0) && (_signedValueToStore2 <= 0xFFFF))) {
					GIV(primFailCode) = PrimErrBadArgument;
					goto l21;
				}
				/* begin storeShort16:ofObject:withValue: */
				shortAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields2) - 1) ) << 1) ), _signedValueToStore2);
				/* end storeShort16:ofObject:withValue: */
				goto l21;
			}
			if (_fmt2 == (sixtyFourBitIndexableFormat())) {
				_unsigned64BitValueToStore2 = positive64BitValueOf(_value);
				if (!GIV(primFailCode)) {
					/* begin storeLong64:ofObject:withValue: */
					long64Atput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields2) - 1) ) << 3) ), _unsigned64BitValueToStore2);
					/* end storeLong64:ofObject:withValue: */
				}
				goto l21;
			}
			_unsignedValueToStore2 = positive32BitValueOf(_value);
			if (!GIV(primFailCode)) {
				/* begin storeLong32:ofObject:withValue: */
				uint32AtPointerput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields2) - 1) ) << 2) ), _unsignedValueToStore2);
				/* end storeLong32:ofObject:withValue: */
			}
			l21:
			;
			/* end subscript:with:storing:format: */
		} else {
			/* begin primitiveFailFor: */
			_reasonCode2 = ((_fmt2 <= 1)
				 ? PrimErrBadReceiver
				 : PrimErrBadIndex);
			GIV(primFailCode) = _reasonCode2;
			/* end primitiveFailFor: */
		}
		l26:
		;
		/* end stObject:at:put: */
	}
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _value);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
	l27:
	;
	/* end commonAtPut: */
}
/* InterpreterPrimitives>>#primitiveBehaviorHash */
static void
primitiveBehaviorHash(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aBehavior;
	sqInt _err;
	sqInt _hash;
	sqInt _hashOrError;
	char *_sp;

	assert((isNonImmediate(stackTop())) && (addressCouldBeClassObj(stackTop())));
	/* begin ensureBehaviorHash: */
	_aBehavior = unsignedLongAt(GIV(stackPointer));
	assert(addressCouldBeClassObj(_aBehavior));
	if (((_hash = (uint32AtPointer(_aBehavior + 4)) & (identityHashHalfWordMask()))) != 0) {
		_hashOrError = _hash;
	} else {
		if (objCouldBeClassObj(_aBehavior)) {
			_hashOrError = ((((_err = enterIntoClassTable(_aBehavior))) != 0)
				 ? -_err
				 : (uint32AtPointer(_aBehavior + 4)) & (identityHashHalfWordMask()));
		} else {
			_hashOrError = -PrimErrBadReceiver;
		}
	}
	/* end ensureBehaviorHash: */
	if (_hashOrError >= 0) {
		/* begin pop:thenPushInteger: */
		unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _hashOrError ) << 3) | 1));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushInteger: */
	} else {
		GIV(primFailCode) = -_hashOrError;
	}
}
/*	Note no short-cut for SmallIntegers. Either the inline interpreter 
	bytecode or the JIT primitive will handle this case. */
/* InterpreterPrimitives>>#primitiveBitAnd */
static void
primitiveBitAnd(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _bs;
	sqInt _bs2;
	sqInt _ccIndex;
	sqInt _ccIndex2;
	sqInt _classOop;
	sqInt _classOop2;
	sqInt _fmt;
	sqInt _fmt2;
	usqInt _integerArgumentValue;
	usqInt _integerReceiverValue;
	sqInt _ok;
	sqInt _ok2;
	sqInt _oop;
	sqInt _oop2;
	sqInt _oop3;
	char *_sp;
	sqInt _value;
	sqInt _value2;

	/* begin positiveMachineIntegerValueOf: */
	_oop2 = unsignedLongAt(GIV(stackPointer));
	if (((_oop2 & 7) == 1)) {
		_value = _oop2 >> 3;
		if (_value < 0) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			_integerArgumentValue = ((usqIntptr_t) null );
			goto l5;
			/* end primitiveFail */
		}
		_integerArgumentValue = ((usqIntptr_t) _value );
		goto l5;
	}
	if (_oop2 & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerArgumentValue = 0;
		goto l5;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(_oop2)));
	/* begin classIndexOf: */
	_ccIndex = (longAt(_oop2)) & (classIndexMask());
	/* end classIndexOf: */
	{
		_ok = ClassLargePositiveIntegerCompactIndex == _ccIndex;
		goto l3;
	}
	l3:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (!_ok) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerArgumentValue = 0;
		goto l5;
	}
	/* begin numBytesOfBytes: */
	_fmt = (((usqInt) (longAt(_oop2)) ) >> (formatShift())) & (formatMask());
	assert(_fmt >= (firstByteFormat()));
	_bs = ((numSlotsOf(_oop2)) << (shiftForWord())) - (_fmt & 7);
	/* end numBytesOfBytes: */
	if (_bs > (sizeof(usqIntptr_t))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerArgumentValue = 0;
		goto l5;
	}
	if (((sizeof(usqIntptr_t)) == 8) && (_bs > 4)) {
		_integerArgumentValue = ((usqIntptr_t) (SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((_oop2 + BaseHeaderSize) + (0U << 3)))) );
		goto l5;
	}
 else {
		_integerArgumentValue = ((usqIntptr_t) ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_oop2 + BaseHeaderSize) + (0U << 2)))) ) );
		goto l5;
	}
	l5:
	;
	/* end positiveMachineIntegerValueOf: */
	/* begin positiveMachineIntegerValueOf: */
	_oop3 = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (((_oop3 & 7) == 1)) {
		_value2 = _oop3 >> 3;
		if (_value2 < 0) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			_integerReceiverValue = ((usqIntptr_t) null );
			goto l9;
			/* end primitiveFail */
		}
		_integerReceiverValue = ((usqIntptr_t) _value2 );
		goto l9;
	}
	if (_oop3 & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerReceiverValue = 0;
		goto l9;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	_classOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(_oop3)));
	/* begin classIndexOf: */
	_ccIndex2 = (longAt(_oop3)) & (classIndexMask());
	/* end classIndexOf: */
	{
		_ok2 = ClassLargePositiveIntegerCompactIndex == _ccIndex2;
		goto l6;
	}
	l6:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (!_ok2) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerReceiverValue = 0;
		goto l9;
	}
	/* begin numBytesOfBytes: */
	_fmt2 = (((usqInt) (longAt(_oop3)) ) >> (formatShift())) & (formatMask());
	assert(_fmt2 >= (firstByteFormat()));
	_bs2 = ((numSlotsOf(_oop3)) << (shiftForWord())) - (_fmt2 & 7);
	/* end numBytesOfBytes: */
	if (_bs2 > (sizeof(usqIntptr_t))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerReceiverValue = 0;
		goto l9;
	}
	if (((sizeof(usqIntptr_t)) == 8) && (_bs2 > 4)) {
		_integerReceiverValue = ((usqIntptr_t) (SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((_oop3 + BaseHeaderSize) + (0U << 3)))) );
		goto l9;
	}
 else {
		_integerReceiverValue = ((usqIntptr_t) ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_oop3 + BaseHeaderSize) + (0U << 2)))) ) );
		goto l9;
	}
	l9:
	;
	/* end positiveMachineIntegerValueOf: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		_oop = positiveMachineIntegerFor(_integerArgumentValue & _integerReceiverValue);
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oop);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/*	Primitive logical operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveBitAndLargeIntegers */
EXPORT(void)
primitiveBitAndLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _integerArg;
	usqLong _integerRcvr;
	sqInt _oopResult;
	char *_sp;

	_integerArg = positive64BitValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	_integerRcvr = positive64BitValueOf(unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord)));
	if (GIV(primFailCode)) {
		{
			return;
		}
	}
	_oopResult = positive64BitIntegerFor(_integerRcvr & _integerArg);
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oopResult);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/*	Note no short-cut for SmallIntegers. Either the inline interpreter 
	bytecode or the JIT primitive will handle this case. */
/* InterpreterPrimitives>>#primitiveBitOr */
static void
primitiveBitOr(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _bs;
	sqInt _bs2;
	sqInt _ccIndex;
	sqInt _ccIndex2;
	sqInt _classOop;
	sqInt _classOop2;
	sqInt _fmt;
	sqInt _fmt2;
	usqInt _integerArgumentValue;
	usqInt _integerReceiverValue;
	sqInt _ok;
	sqInt _ok2;
	sqInt _oop;
	sqInt _oop2;
	sqInt _oop3;
	char *_sp;
	sqInt _value;
	sqInt _value2;

	/* begin positiveMachineIntegerValueOf: */
	_oop2 = unsignedLongAt(GIV(stackPointer));
	if (((_oop2 & 7) == 1)) {
		_value = _oop2 >> 3;
		if (_value < 0) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			_integerArgumentValue = ((usqIntptr_t) null );
			goto l5;
			/* end primitiveFail */
		}
		_integerArgumentValue = ((usqIntptr_t) _value );
		goto l5;
	}
	if (_oop2 & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerArgumentValue = 0;
		goto l5;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(_oop2)));
	/* begin classIndexOf: */
	_ccIndex = (longAt(_oop2)) & (classIndexMask());
	/* end classIndexOf: */
	{
		_ok = ClassLargePositiveIntegerCompactIndex == _ccIndex;
		goto l3;
	}
	l3:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (!_ok) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerArgumentValue = 0;
		goto l5;
	}
	/* begin numBytesOfBytes: */
	_fmt = (((usqInt) (longAt(_oop2)) ) >> (formatShift())) & (formatMask());
	assert(_fmt >= (firstByteFormat()));
	_bs = ((numSlotsOf(_oop2)) << (shiftForWord())) - (_fmt & 7);
	/* end numBytesOfBytes: */
	if (_bs > (sizeof(usqIntptr_t))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerArgumentValue = 0;
		goto l5;
	}
	if (((sizeof(usqIntptr_t)) == 8) && (_bs > 4)) {
		_integerArgumentValue = ((usqIntptr_t) (SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((_oop2 + BaseHeaderSize) + (0U << 3)))) );
		goto l5;
	}
 else {
		_integerArgumentValue = ((usqIntptr_t) ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_oop2 + BaseHeaderSize) + (0U << 2)))) ) );
		goto l5;
	}
	l5:
	;
	/* end positiveMachineIntegerValueOf: */
	/* begin positiveMachineIntegerValueOf: */
	_oop3 = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (((_oop3 & 7) == 1)) {
		_value2 = _oop3 >> 3;
		if (_value2 < 0) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			_integerReceiverValue = ((usqIntptr_t) null );
			goto l9;
			/* end primitiveFail */
		}
		_integerReceiverValue = ((usqIntptr_t) _value2 );
		goto l9;
	}
	if (_oop3 & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerReceiverValue = 0;
		goto l9;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	_classOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(_oop3)));
	/* begin classIndexOf: */
	_ccIndex2 = (longAt(_oop3)) & (classIndexMask());
	/* end classIndexOf: */
	{
		_ok2 = ClassLargePositiveIntegerCompactIndex == _ccIndex2;
		goto l6;
	}
	l6:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (!_ok2) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerReceiverValue = 0;
		goto l9;
	}
	/* begin numBytesOfBytes: */
	_fmt2 = (((usqInt) (longAt(_oop3)) ) >> (formatShift())) & (formatMask());
	assert(_fmt2 >= (firstByteFormat()));
	_bs2 = ((numSlotsOf(_oop3)) << (shiftForWord())) - (_fmt2 & 7);
	/* end numBytesOfBytes: */
	if (_bs2 > (sizeof(usqIntptr_t))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerReceiverValue = 0;
		goto l9;
	}
	if (((sizeof(usqIntptr_t)) == 8) && (_bs2 > 4)) {
		_integerReceiverValue = ((usqIntptr_t) (SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((_oop3 + BaseHeaderSize) + (0U << 3)))) );
		goto l9;
	}
 else {
		_integerReceiverValue = ((usqIntptr_t) ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_oop3 + BaseHeaderSize) + (0U << 2)))) ) );
		goto l9;
	}
	l9:
	;
	/* end positiveMachineIntegerValueOf: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		_oop = positiveMachineIntegerFor(_integerArgumentValue | _integerReceiverValue);
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oop);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/*	Primitive logical operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveBitOrLargeIntegers */
EXPORT(void)
primitiveBitOrLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _integerArg;
	usqLong _integerRcvr;
	sqInt _oopResult;
	char *_sp;

	_integerArg = positive64BitValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	_integerRcvr = positive64BitValueOf(unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord)));
	if (GIV(primFailCode)) {
		{
			return;
		}
	}
	_oopResult = positive64BitIntegerFor(_integerRcvr | _integerArg);
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oopResult);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/*	Perform a bitShift. In 32-bits deal only with non-negative 32-bit 
	integers. In 64-bits deal with signed 64-bit quantities (max (2^63)-1). */
/* InterpreterPrimitives>>#primitiveBitShift */
static void
primitiveBitShift(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerArgument;
	sqInt _integerReceiver;
	sqInt _shifted;
	char *_sp;

	_integerArgument = unsignedLongAt(GIV(stackPointer));
	if (!(((_integerArgument & 7) == 1))) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	_integerReceiver = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	{
		_integerReceiver = signed64BitValueOf(_integerReceiver);
	}
	if (!GIV(primFailCode)) {
		if (((_integerArgument = _integerArgument >> 3)) >= 0) {
			if (!(_integerArgument <= 61)) {
				{
					/* begin primitiveFail */
					if (!GIV(primFailCode)) {
						GIV(primFailCode) = 1;
					}
					/* end primitiveFail */
					return;
				}
			}
			_shifted = ((sqInt) (((usqInt) _integerReceiver ) << _integerArgument) );
			if (!(_integerReceiver == (((sqInt) _shifted ) >> _integerArgument))) {
				{
					/* begin primitiveFail */
					if (!GIV(primFailCode)) {
						GIV(primFailCode) = 1;
					}
					/* end primitiveFail */
					return;
				}
			}
		} else {
			if (!(_integerArgument >= -61)) {
				{
					/* begin primitiveFail */
					if (!GIV(primFailCode)) {
						GIV(primFailCode) = 1;
					}
					/* end primitiveFail */
					return;
				}
			}
			_shifted = ((sqInt) _integerReceiver ) >> (0 - _integerArgument);
		}
		{
			_shifted = (((((((usqInt) _shifted ) >> 60) + 1) & 15) <= 1)
				 ? ((((usqInt) _shifted ) << 3) | 1)
				 : signed64BitIntegerFor(_shifted));
		}
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _shifted);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/*	Primitive arithmetic operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveBitShiftLargeIntegers */
EXPORT(void)
primitiveBitShiftLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _a;
	sqInt _aIsNegative;
	sqInt _integerPointer;
	sqInt _oopRcvr;
	sqInt _oopResult;
	usqLong _result;
	sqInt _shift;
	char *_sp;

	/* begin stackIntegerValue: */
	_integerPointer = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_shift = _integerPointer >> 3;
		goto l2;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_shift = 0;
		goto l2;
	}
	/* end checkedIntegerValueOf: */
	l2:
	;
	/* end stackIntegerValue: */
	_oopRcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_aIsNegative = isNegativeIntegerValueOf(_oopRcvr);
	_a = magnitude64BitValueOf(_oopRcvr);
	if (GIV(primFailCode)) {
		{
			return;
		}
	}
	if (_shift >= 0) {
		_result = 0xFFFFFFFFFFFFFFFFULL;
		if ((_shift >= 64) || (_a > (_result >> _shift))) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			{
				return;
			}
		}
		_result = _a << _shift;
	} else {
		_shift = 0 - _shift;
		if (_shift >= 64) {
			_result = 0;
		} else {
			_result = _a >> _shift;
		}
		if (_aIsNegative && ((_result << _shift) != _a)) {
			_result += 1;
		}
	}
	_oopResult = magnitude64BitIntegerForneg(_result, _aIsNegative);
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oopResult);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/* InterpreterPrimitives>>#primitiveBitXor */
static void
primitiveBitXor(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _bs;
	sqInt _bs2;
	sqInt _ccIndex;
	sqInt _ccIndex2;
	sqInt _classOop;
	sqInt _classOop2;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _integerArgument;
	usqInt _integerArgumentValue;
	sqInt _integerReceiver;
	usqInt _integerReceiverValue;
	sqInt _ok;
	sqInt _ok2;
	sqInt _oop;
	sqInt _oop2;
	char *_sp;
	char *_sp2;
	sqInt _value;
	sqInt _value2;

	_integerArgument = unsignedLongAt(GIV(stackPointer));
	_integerReceiver = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if ((((_integerArgument & 7) == 1)) && (((_integerReceiver & 7) == 1))) {
		/* begin pop:thenPush: */
		_oop = (_integerArgument ^ _integerReceiver) + (smallIntegerTag());
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oop);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	} else {
		/* begin positiveMachineIntegerValueOf: */
		if (((_integerArgument & 7) == 1)) {
			_value = _integerArgument >> 3;
			if (_value < 0) {
				/* begin primitiveFail */
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
				_integerArgumentValue = ((usqIntptr_t) null );
				goto l5;
				/* end primitiveFail */
			}
			_integerArgumentValue = ((usqIntptr_t) _value );
			goto l5;
		}
		if (_integerArgument & (tagMask())) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			_integerArgumentValue = 0;
			goto l5;
		}
		/* begin isClassOfNonImm:equalTo:compactClassIndex: */
		_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
		assert(!(isImmediate(_integerArgument)));
		/* begin classIndexOf: */
		_ccIndex = (longAt(_integerArgument)) & (classIndexMask());
		/* end classIndexOf: */
		{
			_ok = ClassLargePositiveIntegerCompactIndex == _ccIndex;
			goto l3;
		}
		l3:
		;
		/* end isClassOfNonImm:equalTo:compactClassIndex: */
		if (!_ok) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			_integerArgumentValue = 0;
			goto l5;
		}
		/* begin numBytesOfBytes: */
		_fmt = (((usqInt) (longAt(_integerArgument)) ) >> (formatShift())) & (formatMask());
		assert(_fmt >= (firstByteFormat()));
		_bs = ((numSlotsOf(_integerArgument)) << (shiftForWord())) - (_fmt & 7);
		/* end numBytesOfBytes: */
		if (_bs > (sizeof(usqIntptr_t))) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			_integerArgumentValue = 0;
			goto l5;
		}
		if (((sizeof(usqIntptr_t)) == 8) && (_bs > 4)) {
			_integerArgumentValue = ((usqIntptr_t) (SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((_integerArgument + BaseHeaderSize) + (0U << 3)))) );
			goto l5;
		}
 else {
			_integerArgumentValue = ((usqIntptr_t) ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_integerArgument + BaseHeaderSize) + (0U << 2)))) ) );
			goto l5;
		}
		l5:
		;
		/* end positiveMachineIntegerValueOf: */
		/* begin positiveMachineIntegerValueOf: */
		if (((_integerReceiver & 7) == 1)) {
			_value2 = _integerReceiver >> 3;
			if (_value2 < 0) {
				/* begin primitiveFail */
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
				_integerReceiverValue = ((usqIntptr_t) null );
				goto l9;
				/* end primitiveFail */
			}
			_integerReceiverValue = ((usqIntptr_t) _value2 );
			goto l9;
		}
		if (_integerReceiver & (tagMask())) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			_integerReceiverValue = 0;
			goto l9;
		}
		/* begin isClassOfNonImm:equalTo:compactClassIndex: */
		_classOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
		assert(!(isImmediate(_integerReceiver)));
		/* begin classIndexOf: */
		_ccIndex2 = (longAt(_integerReceiver)) & (classIndexMask());
		/* end classIndexOf: */
		{
			_ok2 = ClassLargePositiveIntegerCompactIndex == _ccIndex2;
			goto l6;
		}
		l6:
		;
		/* end isClassOfNonImm:equalTo:compactClassIndex: */
		if (!_ok2) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			_integerReceiverValue = 0;
			goto l9;
		}
		/* begin numBytesOfBytes: */
		_fmt2 = (((usqInt) (longAt(_integerReceiver)) ) >> (formatShift())) & (formatMask());
		assert(_fmt2 >= (firstByteFormat()));
		_bs2 = ((numSlotsOf(_integerReceiver)) << (shiftForWord())) - (_fmt2 & 7);
		/* end numBytesOfBytes: */
		if (_bs2 > (sizeof(usqIntptr_t))) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			_integerReceiverValue = 0;
			goto l9;
		}
		if (((sizeof(usqIntptr_t)) == 8) && (_bs2 > 4)) {
			_integerReceiverValue = ((usqIntptr_t) (SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((_integerReceiver + BaseHeaderSize) + (0U << 3)))) );
			goto l9;
		}
 else {
			_integerReceiverValue = ((usqIntptr_t) ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_integerReceiver + BaseHeaderSize) + (0U << 2)))) ) );
			goto l9;
		}
		l9:
		;
		/* end positiveMachineIntegerValueOf: */
		if (!GIV(primFailCode)) {
			/* begin pop:thenPush: */
			_oop2 = positiveMachineIntegerFor(_integerArgumentValue ^ _integerReceiverValue);
			unsignedLongAtput((_sp2 = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oop2);
			GIV(stackPointer) = _sp2;
			/* end pop:thenPush: */
		}
	}
}
/*	Primitive logical operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveBitXorLargeIntegers */
EXPORT(void)
primitiveBitXorLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _integerArg;
	usqLong _integerRcvr;
	sqInt _oopResult;
	char *_sp;

	_integerArg = positive64BitValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	_integerRcvr = positive64BitValueOf(unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord)));
	if (GIV(primFailCode)) {
		{
			return;
		}
	}
	_oopResult = positive64BitIntegerFor(_integerRcvr ^ _integerArg);
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oopResult);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/*	Answer bytes available at this moment. For more meaningful  
	results, calls to this primitive should be precedeed by a full  
	or incremental garbage collection. */
/* InterpreterPrimitives>>#primitiveBytesLeft */
static void
primitiveBytesLeft(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _freeChunk;
	sqInt _i;
	sqInt _integerVal;
	sqInt _integerVal2;
	sqInt _obj;
	char *_sp;
	char *_sp2;
	char *_sp3;

	if (GIV(argumentCount) == 0) {
		{
			/* begin pop:thenPushInteger: */
			unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), ((GIV(totalFreeOldSpace) << 3) | 1));
			GIV(stackPointer) = _sp;
			/* end pop:thenPushInteger: */
			return;
		}
	}
	if (GIV(argumentCount) == 1) {
		if ((unsignedLongAt(GIV(stackPointer))) == GIV(nilObj)) {
			{
				/* begin pop:thenPushInteger: */
				/* begin sizeOfLargestFreeChunk */
				_freeChunk = findLargestFreeChunk();
				if (!_freeChunk) {
					for (_i = 0x3F; _i >= 1; _i += -1) {
						_freeChunk = GIV(freeLists)[_i];
						if (_freeChunk != 0) {
							_integerVal = bytesInObject(_freeChunk);
							goto l3;
						}
					}
					_integerVal = 0;
					goto l3;
				}
				_integerVal = bytesInObject(_freeChunk);
				l3:
				;
				/* end sizeOfLargestFreeChunk */
				unsignedLongAtput((_sp2 = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((((usqInt) _integerVal ) << 3) | 1));
				GIV(stackPointer) = _sp2;
				/* end pop:thenPushInteger: */
				return;
			}
		}
		/* begin booleanValueOf: */
		_obj = unsignedLongAt(GIV(stackPointer));
		if (_obj == GIV(trueObj)) {
			goto l2;
		}
		if (_obj == GIV(falseObj)) {
			goto l2;
		}
		/* begin success: */
		{
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
		}
		/* end success: */
		l2:
		;
		/* end booleanValueOf: */
		if (!GIV(primFailCode)) {
			{
				/* begin pop:thenPushInteger: */
				_integerVal2 = (((GIV(totalFreeOldSpace) + ((((eden()).limit)) - GIV(freeStart))) + ((((pastSpace()).limit)) - GIV(pastSpaceStart))) + ((((futureSpace()).limit)) - (((futureSpace()).limit)))) - (interpreterAllocationReserveBytes());
				unsignedLongAtput((_sp3 = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((((usqInt) _integerVal2 ) << 3) | 1));
				GIV(stackPointer) = _sp3;
				/* end pop:thenPushInteger: */
				return;
			}
		}
	}
	{
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return;
	}
}
/*	Perform a function call to a foreign function. 
	Only invoked from method containing explicit external call spec. 
	Due to this we use the pluggable prim mechanism explicitly here 
	(the first literal of any FFI spec'ed method is an ExternalFunction 
	and not an array as used in the pluggable primitive mechanism). */
/* InterpreterPrimitives>>#primitiveCalloutToFFI */
static void
primitiveCalloutToFFI(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	static void *_function = (void *)-1;
	void (*_primitiveCallout)(void);

	/* begin functionForPrimitiveCallout */
	if (((sqInt) _function ) == -1) {
		_function = ioLoadFunctionFrom("primitiveCallout", "SqueakFFIPrims");
	}
	_primitiveCallout = ((void (*)(void)) _function );
	/* end functionForPrimitiveCallout */
	if (_primitiveCallout == null) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	} else {
		_primitiveCallout();
	}
}
/*	Primitive. Change the class of the receiver into the class of the argument 
	given that 
	the format of the receiver matches the format of the argument's class. 
	Fail if the 
	receiver or argument are SmallIntegers, or the receiver is an instance of 
	a compact 
	class and the argument isn't, or when the argument's class is compact and 
	the receiver 
	isn't, or when the format of the receiver is different from the format of 
	the argument's 
	class, or when the arguments class is fixed and the receiver's size 
	differs from the size 
	that an instance of the argument's class should have. */
/* InterpreterPrimitives>>#primitiveChangeClass */
static void
primitiveChangeClass(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _arg;
	sqInt _argClass;
	sqInt _err;
	sqInt _oop;
	sqInt _oop2;
	sqInt _rcvr;

	/* begin stackObjectValue: */
	_oop = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	if (_oop & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_arg = null;
		goto l3;
	}
	_arg = _oop;
	l3:
	;
	/* end stackObjectValue: */
	/* begin stackObjectValue: */
	_oop2 = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (_oop2 & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_rcvr = null;
		goto l4;
	}
	_rcvr = _oop2;
	l4:
	;
	/* end stackObjectValue: */
	if (GIV(primFailCode)) {
		{
			return;
		}
	}
	_argClass = fetchClassOfNonImm(_arg);
	_err = changeClassOfto(_rcvr, _argClass);
	if (_err == 0) {
		/* begin pop: */
		GIV(stackPointer) += GIV(argumentCount) * BytesPerWord;
		/* end pop: */
	} else {
		GIV(primFailCode) = _err;
	}
	{
		return;
	}
}
/* InterpreterPrimitives>>#primitiveClass */
static void
primitiveClass(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _instance;
	sqInt _oop;
	char *_sp;
	sqInt _tagBits;

	_instance = unsignedLongAt(GIV(stackPointer));
	if ((GIV(argumentCount) > 0) && (((_instance & (tagMask())) == 0) && (((long64At(_instance)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	} else {
		/* begin pop:thenPush: */
		if (((_tagBits = _instance & (tagMask()))) != 0) {
			/* begin fetchPointer:ofObject: */
			_oop = unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
		} else {
			_oop = fetchClassOfNonImm(_instance);
		}
		unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/*	Return the value of the microsecond clock in the local timezone, as 
	updated by the heartbeat, as an integer. 
	This is the number of microseconds since the Smalltalk epoch, 1901/1/1 
	12:00am. The microsecond clock is at least 60 bits wide which means it'll 
	get to around August 
	38435 before it wraps around. Be sure to put it on your calendar. The 
	coarse clock is 
	updated by the heartbeat thread and as such is much cheaper than 
	primitiveUTCMicrosecondClock, which always entails a system call. */
/* InterpreterPrimitives>>#primitiveCoarseLocalMicrosecondClock */
static void
primitiveCoarseLocalMicrosecondClock(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _oop;
	char *_sp;

	/* begin pop:thenPush: */
	_oop = positive64BitIntegerFor(ioLocalMicroseconds());
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Return the value of the microsecond clock as updated by the heartbeat as 
	an integer. 
	This is the number of microseconds since the Smalltalk epoch, 1901/1/1 
	12:00am. The microsecond clock is at least 60 bits wide which means it'll 
	get to around August 
	38435 before it wraps around. Be sure to put it on your calendar. The 
	coarse clock is 
	updated by the heartbeat thread and as such is much cheaper than 
	primitiveUTCMicrosecondClock, which always entails a system call. */
/* InterpreterPrimitives>>#primitiveCoarseUTCMicrosecondClock */
static void
primitiveCoarseUTCMicrosecondClock(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _oop;
	char *_sp;

	/* begin pop:thenPush: */
	_oop = positive64BitIntegerFor(ioUTCMicroseconds());
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Fill the receiver, which must be an indexable non-pointer 
	object, with the given integer value. */
/* InterpreterPrimitives>>#primitiveConstantFill */
static void
primitiveConstantFill(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _end;
	usqLong _fillValue;
	sqInt _format;
	usqInt _i;
	sqInt _oddBytes;
	sqInt _rcvr;

	/* begin primitiveConstantFillSpur */
	_fillValue = positive64BitValueOf(unsignedLongAt(GIV(stackPointer)));
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (!(!GIV(primFailCode) && (((_rcvr & (tagMask())) == 0) && (((_format = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask()))) >= (sixtyFourBitIndexableFormat()))))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		goto l3;
		/* end primitiveFail */
	}
	if (_format >= (firstShortFormat())) {
		if (_format >= (firstByteFormat())) {
			if ((_fillValue > 0xFF) || (_format >= (firstCompiledMethodFormat()))) {
				/* begin primitiveFail */
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
				goto l3;
				/* end primitiveFail */
			}
			_fillValue = ((_fillValue + (_fillValue << 8)) + (_fillValue << 16)) + (_fillValue << 24);
			_oddBytes = _format & 7;
		} else {
			if (_fillValue > 0xFFFF) {
				/* begin primitiveFail */
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
				goto l3;
				/* end primitiveFail */
			}
			_fillValue += _fillValue << 16;
			_oddBytes = ((sqInt) (((usqInt) (_format & 3) ) << 1) );
		}
		_fillValue += _fillValue << 32;
	} else {
		if (_format == (sixtyFourBitIndexableFormat())) {
			_oddBytes = 0;
		} else {
			if (_fillValue > 0xFFFFFFFFU) {
				/* begin primitiveFail */
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
				goto l3;
				/* end primitiveFail */
			}
			_fillValue += _fillValue << 32;
			_oddBytes = ((sqInt) (((usqInt) (_format & 1) ) << 2) );
		}
	}
	_end = addressAfter(_rcvr);
	_i = _rcvr + BaseHeaderSize;
	while (_i < _end) {
		long64Atput(_i, _fillValue);
		_i += 8;
	}
	if (_oddBytes > 0) {
		flag("endianness");
		_fillValue = _fillValue >> (8 * _oddBytes);
		long64Atput(_i - 8, _fillValue);
	}
	/* begin pop: */
	GIV(stackPointer) += 1 * BytesPerWord;
	/* end pop: */
	l3:
	;
	/* end primitiveConstantFillSpur */
}
/*	Primitive. Copy the state of the receiver from the argument.  
	Fail if receiver and argument are of a different class. 
	Fail if the receiver or argument are contexts (because of context-to-stack 
	mapping). Fail if receiver and argument have different lengths (for 
	indexable objects). 
	Fail if the objects are not in a fit state to be copied (e.g. married 
	contexts and Cogged methods) */
/* InterpreterPrimitives>>#primitiveCopyObject */
static void
primitiveCopyObject(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _arg;
	sqInt _fmt;
	sqInt _i;
	usqInt _length;
	usqInt _numBytes;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _rcvr;
	sqInt _valuePointer;

	if (!(GIV(argumentCount) >= 1)) {
		{
			GIV(primFailCode) = PrimErrBadNumArgs;
			return;
		}
	}
	_arg = unsignedLongAt(GIV(stackPointer));
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (_rcvr & (tagMask())) {
		{
			GIV(primFailCode) = PrimErrBadReceiver;
			return;
		}
	}
	if (_arg & (tagMask())) {
		{
			GIV(primFailCode) = PrimErrBadArgument;
			return;
		}
	}
	if (((longAt(_rcvr)) & (classIndexMask())) != ((longAt(_arg)) & (classIndexMask()))) {
		{
			GIV(primFailCode) = PrimErrBadArgument;
			return;
		}
	}
	if (isPureBitsFormat((((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask()))) {
		/* begin numBytesOf: */
		_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
		/* begin numSlotsOf: */
		assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
		_numSlots2 = byteAt(_rcvr + 7);
		_numBytes = ((_numSlots2 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots2);
		/* end numSlotsOf: */
		_numBytes = _numBytes << (shiftForWord());
		if (_fmt >= (firstByteFormat())) {
			_length = _numBytes - (_fmt & 7);
			goto l5;
		}
		if (_fmt <= (sixtyFourBitIndexableFormat())) {
			_length = ((sqInt) _numBytes );
			goto l5;
		}
		if (_fmt >= (firstShortFormat())) {
			_length = _numBytes - ((sqInt) (((usqInt) (_fmt & 3) ) << 1) );
			goto l5;
		}
		_length = _numBytes - ((sqInt) (((usqInt) (_fmt & 1) ) << 2) );
		l5:
		;
		/* end numBytesOf: */
		if (!((((((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask())) == ((((usqInt) (longAt(_arg)) ) >> (formatShift())) & (formatMask()))) && (_length == (numBytesOf(_arg))))) {
			{
				GIV(primFailCode) = PrimErrBadArgument;
				return;
			}
		}
		memcpy(((void *) (_rcvr + BaseHeaderSize) ), ((void *) (_arg + BaseHeaderSize) ), _length);
	} else {
		if (!(isAppropriateForCopyObject(_rcvr))) {
			{
				GIV(primFailCode) = PrimErrBadReceiver;
				return;
			}
		}
		/* begin numSlotsOf: */
		assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
		_numSlots = byteAt(_rcvr + 7);
		_length = ((_numSlots == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots);
		/* end numSlotsOf: */
		if (!((isAppropriateForCopyObject(_arg)) && (_length == (lengthOfformat(_arg, (((usqInt) (longAt(_arg)) ) >> (formatShift())) & (formatMask())))))) {
			{
				GIV(primFailCode) = PrimErrBadArgument;
				return;
			}
		}
		for (_i = 0; _i < _length; _i += 1) {
			/* begin storePointer:ofObject:withValue: */
			_valuePointer = unsignedLongAt((_arg + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
			assert(!(isForwarded(_rcvr)));
			if (((_rcvr & (tagMask())) == 0) && ((_rcvr & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((_valuePointer & (tagMask())) == 0) && (((_valuePointer & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_valuePointer >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), _rcvr);
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l6;
			}
			if (_valuePointer & (tagMask())) {
				goto l6;
			}
			if (!(_rcvr >= 0x20000000000LL)) {
				goto l6;
			}
			if (_valuePointer >= 0x20000000000LL) {
				goto l6;
			}
			if ((_valuePointer >= GIV(nilObj)) && (_valuePointer <= GIV(trueObj))) {
				goto l6;
			}
			if (!(_valuePointer >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l6;
			}
			remember(getFromPermToNewSpaceRememberedSet(), _rcvr);
			l6:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _valuePointer);
			/* end storePointer:ofObject:withValue: */
		}
	}
	/* begin pop: */
	GIV(stackPointer) += GIV(argumentCount) * BytesPerWord;
	/* end pop: */
}
/* InterpreterPrimitives>>#primitiveDiv */
static void
primitiveDiv(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _quotient;
	char *_sp;

	_quotient = doPrimitiveDivby(unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord)), unsignedLongAt(GIV(stackPointer)));
	/* begin pop2AndPushIntegerIfOK: */
	if (!GIV(primFailCode)) {
		if ((((((usqInt) _quotient ) >> 60) + 1) & 15) <= 1) {
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((((usqInt) _quotient ) << 3) | 1));
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
		} else {
			/* begin success: */
			{
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
			}
			/* end success: */
		}
	}
	/* end pop2AndPushIntegerIfOK: */
}
/* InterpreterPrimitives>>#primitiveDivide */
static void
primitiveDivide(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerArgument;
	sqInt _integerPointer;
	sqInt _integerPointer2;
	sqInt _integerReceiver;
	char *_sp;

	/* begin stackIntegerValue: */
	_integerPointer = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_integerReceiver = _integerPointer >> 3;
		goto l2;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerReceiver = 0;
		goto l2;
	}
	/* end checkedIntegerValueOf: */
	l2:
	;
	/* end stackIntegerValue: */
	/* begin stackIntegerValue: */
	_integerPointer2 = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer2 & 7) == 1)) {
		_integerArgument = _integerPointer2 >> 3;
		goto l3;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerArgument = 0;
		goto l3;
	}
	/* end checkedIntegerValueOf: */
	l3:
	;
	/* end stackIntegerValue: */
	if ((_integerArgument != 0) && ((_integerReceiver % _integerArgument) == 0)) {
		/* begin pop2AndPushIntegerIfOK: */
		if (!GIV(primFailCode)) {
			if ((((((usqInt) (_integerReceiver / _integerArgument) ) >> 60) + 1) & 15) <= 1) {
				/* begin pop:thenPush: */
				unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((((usqInt) (_integerReceiver / _integerArgument) ) << 3) | 1));
				GIV(stackPointer) = _sp;
				/* end pop:thenPush: */
			} else {
				/* begin success: */
				{
					if (!GIV(primFailCode)) {
						GIV(primFailCode) = 1;
					}
				}
				/* end success: */
			}
		}
		/* end pop2AndPushIntegerIfOK: */
	}
 else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	}
}
/*	Primitive arithmetic operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveDivideLargeIntegers */
EXPORT(void)
primitiveDivideLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _a;
	sqInt _aIsNegative;
	usqLong _b;
	sqInt _bIsNegative;
	sqInt _oopArg;
	sqInt _oopRcvr;
	sqInt _oopResult;
	usqLong _result;
	char *_sp;

	_oopArg = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	_oopRcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_aIsNegative = isNegativeIntegerValueOf(_oopRcvr);
	_bIsNegative = isNegativeIntegerValueOf(_oopArg);
	_a = magnitude64BitValueOf(_oopRcvr);
	_b = magnitude64BitValueOf(_oopArg);
	if (GIV(primFailCode)) {
		{
			return;
		}
	}
	if (!((_b != 0) && ((_a % _b) == 0))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		{
			return;
		}
	}
	_result = _a / _b;
	_oopResult = magnitude64BitIntegerForneg(_result, _aIsNegative != _bIsNegative);
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oopResult);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/*	Primitive arithmetic operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveDivLargeIntegers */
EXPORT(void)
primitiveDivLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _a;
	sqInt _aIsNegative;
	usqLong _b;
	sqInt _bIsNegative;
	sqInt _oopArg;
	sqInt _oopRcvr;
	sqInt _oopResult;
	usqLong _rem;
	usqLong _result;
	char *_sp;

	_oopArg = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	_oopRcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_aIsNegative = isNegativeIntegerValueOf(_oopRcvr);
	_bIsNegative = isNegativeIntegerValueOf(_oopArg);
	_a = magnitude64BitValueOf(_oopRcvr);
	_b = magnitude64BitValueOf(_oopArg);
	if (_b == 0) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	}
	if (GIV(primFailCode)) {
		{
			return;
		}
	}
	_result = _a / _b;
	if (!(_a == 0)) {
		if (!(_bIsNegative == _aIsNegative)) {
			_rem = _a % _b;
			if (!(_rem == 0)) {
				_result += 1;
			}
		}
	}
	_oopResult = magnitude64BitIntegerForneg(_result, _bIsNegative != _aIsNegative);
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oopResult);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/* InterpreterPrimitives>>#primitiveEqual */
static void
primitiveEqual(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerArgument;
	sqInt _integerReceiver;
	int _result;
	char *_sp;
	char *_sp2;

	_integerArgument = unsignedLongAt(GIV(stackPointer));
	_integerReceiver = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if ((_integerReceiver & _integerArgument) & (smallIntegerTag())) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_integerReceiver == _integerArgument)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	} else {
		_result = (signed64BitValueOf(_integerReceiver)) == (signed64BitValueOf(_integerArgument));
		if (!GIV(primFailCode)) {
			/* begin pop:thenPushBool: */
			unsignedLongAtput((_sp2 = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_result)
				 ? GIV(trueObj)
				 : GIV(falseObj)));
			GIV(stackPointer) = _sp2;
			/* end pop:thenPushBool: */
		}
	}
}
/*	Primitive comparison operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveEqualLargeIntegers */
EXPORT(void)
primitiveEqualLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqLong _integerArg;
	sqLong _integerRcvr;
	char *_sp;

	_integerArg = signed64BitValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	_integerRcvr = signed64BitValueOf(unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord)));
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_integerRcvr == _integerArg)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	}
}
/*	Computes E raised to the receiver power. 
	N.B. IMO we should be able to assume the receiver is a float because this 
	primitive is specific to floats. eem 2/13/2017 */
/* InterpreterPrimitives>>#primitiveExp */
static void
primitiveExp(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aValue;
	double _rcvr;

	/* begin stackFloatValue: */
	_rcvr = floatValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	/* end stackFloatValue: */
	if (!GIV(primFailCode)) {
		/* begin stackTopPut: */
		_aValue = floatObjectOf(exp(_rcvr));
		unsignedLongAtput(GIV(stackPointer), _aValue);
		/* end stackTopPut: */
	}
}
/*	Exponent part of this float. 
	N.B. IMO we should be able to assume the receiver is a float because this 
	primitive is specific to floats. eem 2/13/2017 */
/* InterpreterPrimitives>>#primitiveExponent */
static void
primitiveExponent(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	int _pwr;
	double _rcvr;

	/* begin stackFloatValue: */
	_rcvr = floatValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	_pwr = 0;
	/* end stackFloatValue: */
	if (!GIV(primFailCode)) {
		frexp(_rcvr, &_pwr);
		unsignedLongAtput(GIV(stackPointer), ((((usqInt) (_pwr - 1) ) << 3) | 1));
	}
}
/*	Set general (unspecified) primitive failure. Don't overwrite an error code 
	that has already been set.Use returnTypeC: #sqInt because that's the way it is defined in sq.h. 
	Use no explicit return so that Slang doesn't fail an inlining type-check 
	when a primitive with return type void uses ^self primitiveFail to exit. */
/* InterpreterPrimitives>>#primitiveFail */
sqInt
primitiveFail(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	return 0;
}
/*	Set PrimErrOSError primitive failure and associated osErrorCode. */
/* InterpreterPrimitives>>#primitiveFailForOSError: */
sqInt
primitiveFailForOSError(sqLong _osError)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	GIV(osErrorCode) = _osError;
	return (GIV(primFailCode) = PrimErrOSError);
}
/*	Set specific primitive failure. 
	N.B. primitiveFailFor: PrimNoErr is expected to clear the primFailCode. */
/* InterpreterPrimitives>>#primitiveFailFor: */
sqInt
primitiveFailFor(sqInt _reasonCode)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return (GIV(primFailCode) = _reasonCode);
}
/* InterpreterPrimitives>>#primitiveFailureCode */
sqInt
primitiveFailureCode(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(primFailCode);
}
/* InterpreterPrimitives>>#primitiveFetchNextMourner */
static void
primitiveFetchNextMourner(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _mourner;
	char *_sp;

	{
		_mourner = ((GIV(mournQueue) != GIV(nilObj))
			 ? popObjStack(GIV(mournQueue))
			 : 0);
		if (_mourner == null) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrNotFound;
			/* end primitiveFailFor: */
		} else {
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), _mourner);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
		}
	}
}
/* InterpreterPrimitives>>#primitiveFloatAdd */
static void
primitiveFloatAdd(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	double _arg;
	sqInt _argOop;
	usqLong _bits;
	usqLong _bits2;
	double _rcvr;
	sqInt _rcvrOop;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	{
		/* begin primitiveFloatAdd:toArg: */
		_rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
		_argOop = unsignedLongAt(GIV(stackPointer));
		/* begin loadFloatOrIntFrom: */
		if (((_tagBits = _rcvrOop & (tagMask()))) != 0) {
			if (_tagBits == (smallFloatTag())) {
				/* begin smallFloatValueOf: */
				/* begin smallFloatBitsOf: */
				assert(isImmediateFloat(_rcvrOop));
				_rot = ((usqInt) ((usqInt) _rcvrOop ) ) >> (numTagBits());
				if (_rot > 1) {
					_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
				}
				/* begin rotateRight: */
				_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
				/* end rotateRight: */
				_bits = _rot;
				/* end smallFloatBitsOf: */
				{
					memcpy(&_value, &_bits, sizeof(_value));
					_rcvr = _value;
					goto l4;
				}
				_rcvr = null;
				goto l4;
				/* end smallFloatValueOf: */
			}
			if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _rcvrOop ) << _shift) ) ) >> _shift) == _rcvrOop))) {
				_rcvr = ((double) (_rcvrOop >> 3) );
				goto l4;
			}
		} else {
			if (((longAt(_rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
				fetchFloatAtinto(_rcvrOop + BaseHeaderSize, _result);
				_rcvr = _result;
				goto l4;
			}
		}
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_rcvr = 0.0;
		l4:
		;
		/* end loadFloatOrIntFrom: */
		/* begin loadFloatOrIntFrom: */
		if (((_tagBits2 = _argOop & (tagMask()))) != 0) {
			if (_tagBits2 == (smallFloatTag())) {
				/* begin smallFloatValueOf: */
				/* begin smallFloatBitsOf: */
				assert(isImmediateFloat(_argOop));
				_rot2 = ((usqInt) ((usqInt) _argOop ) ) >> (numTagBits());
				if (_rot2 > 1) {
					_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
				}
				/* begin rotateRight: */
				_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
				/* end rotateRight: */
				_bits2 = _rot2;
				/* end smallFloatBitsOf: */
				{
					memcpy(&_value2, &_bits2, sizeof(_value2));
					_arg = _value2;
					goto l7;
				}
				_arg = null;
				goto l7;
				/* end smallFloatValueOf: */
			}
			if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _argOop ) << _shift2) ) ) >> _shift2) == _argOop))) {
				_arg = ((double) (_argOop >> 3) );
				goto l7;
			}
		} else {
			if (((longAt(_argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
				fetchFloatAtinto(_argOop + BaseHeaderSize, _result2);
				_arg = _result2;
				goto l7;
			}
		}
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_arg = 0.0;
		l7:
		;
		/* end loadFloatOrIntFrom: */
		if (!GIV(primFailCode)) {
			/* begin pop:thenPushFloat: */
			unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), floatObjectOf(_rcvr + _arg));
			GIV(stackPointer) = _sp;
			/* end pop:thenPushFloat: */
		}
		/* end primitiveFloatAdd:toArg: */
		return;
	}
}
/*	Provide platform-independent access to 32-bit words comprising 
	a Float. Map index 1 onto the most significant word and index 2 
	onto the least significant word. */
/* InterpreterPrimitives>>#primitiveFloatAt */
static void
primitiveFloatAt(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _index;
	int _indexToUse;
	unsigned int _integerValue;
	sqInt _rcvr;
	sqInt _reasonCode;
	usqInt _result;
	char *_sp;

	_indexToUse = 0;
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_index = unsignedLongAt(GIV(stackPointer));
	if (_index == ConstOne) {
		_indexToUse = 0;
	} else {
		if (_index == ConstTwo) {
			_indexToUse = 1;
		} else {
			{
				/* begin primitiveFailFor: */
				_reasonCode = ((((_index & 7) == 1))
					 ? PrimErrBadIndex
					 : PrimErrBadArgument);
				GIV(primFailCode) = _reasonCode;
				/* end primitiveFailFor: */
				return;
			}
		}
	}
	if (!VMBIGENDIAN) {
		_indexToUse = ((_indexToUse == 0)
			 ? 1
			 : 0);
	}
	/* begin positive32BitIntegerFor: */
	_integerValue = ((unsigned int) (fetchLong32ofFloatObject(_indexToUse, _rcvr)) );
	{
		_result = (((((usqInt) _integerValue ) & 0xFFFFFFFFU) << 3) | 1);
		goto l3;
	}
	l3:
	;
	/* end positive32BitIntegerFor: */
	{
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _result);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
		return;
	}
}
/*	Provide platform-independent access to 32-bit words comprising 
	a Float. Map index 1 onto the most significant word and index 2 
	onto the least significant word. */
/* InterpreterPrimitives>>#primitiveFloatAtPut */
static void
primitiveFloatAtPut(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;
	sqInt _index;
	sqInt _oopToStore;
	sqInt _rcvr;
	sqInt _reasonCode;
	char *_sp;
	char *_sp2;
	usqInt _valueToStore;

	_oopToStore = unsignedLongAt(GIV(stackPointer));
	_valueToStore = positive32BitValueOf(_oopToStore);
	if (GIV(primFailCode)) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			return;
		}
	}
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (_rcvr & (smallFloatTag())) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadReceiver;
			/* end primitiveFailFor: */
			return;
		}
	}
	if (
#    if IMMUTABILITY
			(/* begin isImmutable: */ ((((usqInt) (longAt(_rcvr)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#    else /* IMMUTABILITY */
			0
#    endif /* IMMUTABILITY */
			) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrNoModification;
			/* end primitiveFailFor: */
			return;
		}
	}
	if (_index == ConstOne) {
		/* begin storeLong32:ofObject:withValue: */
		_fieldIndex = ((VMBIGENDIAN)
			 ? 0
			 : 1);
		uint32AtPointerput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << 2) ), _valueToStore);
		/* end storeLong32:ofObject:withValue: */
		{
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + ((3 - 1) * BytesPerWord)), _oopToStore);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
			return;
		}
	}
	if (_index == ConstTwo) {
		/* begin storeLong32:ofObject:withValue: */
		_fieldIndex2 = ((VMBIGENDIAN)
			 ? 1
			 : 0);
		uint32AtPointerput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << 2) ), _valueToStore);
		/* end storeLong32:ofObject:withValue: */
		{
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp2 = GIV(stackPointer) + ((3 - 1) * BytesPerWord)), _oopToStore);
			GIV(stackPointer) = _sp2;
			/* end pop:thenPush: */
			return;
		}
	}
	/* begin primitiveFailFor: */
	_reasonCode = ((((_index & 7) == 1))
		 ? PrimErrBadIndex
		 : PrimErrBadArgument);
	GIV(primFailCode) = _reasonCode;
	/* end primitiveFailFor: */
}
/* InterpreterPrimitives>>#primitiveFloatDivide */
static void
primitiveFloatDivide(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	double _arg;
	sqInt _argOop;
	usqLong _bits;
	usqLong _bits2;
	double _rcvr;
	sqInt _rcvrOop;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin primitiveFloatDivide:byArg: */
	_rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	_argOop = unsignedLongAt(GIV(stackPointer));
	/* begin loadFloatOrIntFrom: */
	if (((_tagBits = _rcvrOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_rcvrOop));
			_rot = ((usqInt) ((usqInt) _rcvrOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l4;
			}
			_rcvr = null;
			goto l4;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _rcvrOop ) << _shift) ) ) >> _shift) == _rcvrOop))) {
			_rcvr = ((double) (_rcvrOop >> 3) );
			goto l4;
		}
	} else {
		if (((longAt(_rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_rcvrOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l4;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l4:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	if (((_tagBits2 = _argOop & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_argOop));
			_rot2 = ((usqInt) ((usqInt) _argOop ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l7;
			}
			_arg = null;
			goto l7;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _argOop ) << _shift2) ) ) >> _shift2) == _argOop))) {
			_arg = ((double) (_argOop >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(_argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_argOop + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l7;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l7:
	;
	/* end loadFloatOrIntFrom: */
	/* begin success: */
	if (!(_arg != 0.0)) {
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
	}
	/* end success: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushFloat: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), floatObjectOf(_rcvr / _arg));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushFloat: */
	}
	/* end primitiveFloatDivide:byArg: */
}
/* InterpreterPrimitives>>#primitiveFloatEqual */
static void
primitiveFloatEqual(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aBool;
	double _arg;
	sqInt _argOop;
	usqLong _bits;
	usqLong _bits2;
	double _rcvr;
	sqInt _rcvrOop;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin primitiveFloatEqual:toArg: */
	_rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	_argOop = unsignedLongAt(GIV(stackPointer));
	/* begin loadFloatOrIntFrom: */
	if (((_tagBits = _rcvrOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_rcvrOop));
			_rot = ((usqInt) ((usqInt) _rcvrOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l4;
			}
			_rcvr = null;
			goto l4;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _rcvrOop ) << _shift) ) ) >> _shift) == _rcvrOop))) {
			_rcvr = ((double) (_rcvrOop >> 3) );
			goto l4;
		}
	} else {
		if (((longAt(_rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_rcvrOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l4;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l4:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	if (((_tagBits2 = _argOop & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_argOop));
			_rot2 = ((usqInt) ((usqInt) _argOop ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l7;
			}
			_arg = null;
			goto l7;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _argOop ) << _shift2) ) ) >> _shift2) == _argOop))) {
			_arg = ((double) (_argOop >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(_argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_argOop + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l7;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l7:
	;
	/* end loadFloatOrIntFrom: */
	_aBool = _rcvr == _arg;
	/* end primitiveFloatEqual:toArg: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_aBool)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	}
}
/* InterpreterPrimitives>>#primitiveFloatGreaterOrEqual */
static void
primitiveFloatGreaterOrEqual(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aBool;
	double _arg;
	sqInt _argOop;
	usqLong _bits;
	usqLong _bits2;
	double _rcvr;
	sqInt _rcvrOop;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin primitiveFloatGreaterOrEqual:toArg: */
	_rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	_argOop = unsignedLongAt(GIV(stackPointer));
	/* begin loadFloatOrIntFrom: */
	if (((_tagBits = _rcvrOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_rcvrOop));
			_rot = ((usqInt) ((usqInt) _rcvrOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l4;
			}
			_rcvr = null;
			goto l4;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _rcvrOop ) << _shift) ) ) >> _shift) == _rcvrOop))) {
			_rcvr = ((double) (_rcvrOop >> 3) );
			goto l4;
		}
	} else {
		if (((longAt(_rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_rcvrOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l4;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l4:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	if (((_tagBits2 = _argOop & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_argOop));
			_rot2 = ((usqInt) ((usqInt) _argOop ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l7;
			}
			_arg = null;
			goto l7;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _argOop ) << _shift2) ) ) >> _shift2) == _argOop))) {
			_arg = ((double) (_argOop >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(_argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_argOop + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l7;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l7:
	;
	/* end loadFloatOrIntFrom: */
	_aBool = _rcvr >= _arg;
	/* end primitiveFloatGreaterOrEqual:toArg: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_aBool)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	}
}
/* InterpreterPrimitives>>#primitiveFloatGreaterThan */
static void
primitiveFloatGreaterThan(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aBool;
	double _arg;
	sqInt _argOop;
	usqLong _bits;
	usqLong _bits2;
	double _rcvr;
	sqInt _rcvrOop;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin primitiveFloatGreater:thanArg: */
	_rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	_argOop = unsignedLongAt(GIV(stackPointer));
	/* begin loadFloatOrIntFrom: */
	if (((_tagBits = _rcvrOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_rcvrOop));
			_rot = ((usqInt) ((usqInt) _rcvrOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l4;
			}
			_rcvr = null;
			goto l4;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _rcvrOop ) << _shift) ) ) >> _shift) == _rcvrOop))) {
			_rcvr = ((double) (_rcvrOop >> 3) );
			goto l4;
		}
	} else {
		if (((longAt(_rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_rcvrOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l4;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l4:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	if (((_tagBits2 = _argOop & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_argOop));
			_rot2 = ((usqInt) ((usqInt) _argOop ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l7;
			}
			_arg = null;
			goto l7;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _argOop ) << _shift2) ) ) >> _shift2) == _argOop))) {
			_arg = ((double) (_argOop >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(_argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_argOop + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l7;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l7:
	;
	/* end loadFloatOrIntFrom: */
	_aBool = _rcvr > _arg;
	/* end primitiveFloatGreater:thanArg: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_aBool)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	}
}
/* InterpreterPrimitives>>#primitiveFloatLessOrEqual */
static void
primitiveFloatLessOrEqual(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aBool;
	double _arg;
	sqInt _argOop;
	usqLong _bits;
	usqLong _bits2;
	double _rcvr;
	sqInt _rcvrOop;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin primitiveFloatLessOrEqual:toArg: */
	_rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	_argOop = unsignedLongAt(GIV(stackPointer));
	/* begin loadFloatOrIntFrom: */
	if (((_tagBits = _rcvrOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_rcvrOop));
			_rot = ((usqInt) ((usqInt) _rcvrOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l4;
			}
			_rcvr = null;
			goto l4;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _rcvrOop ) << _shift) ) ) >> _shift) == _rcvrOop))) {
			_rcvr = ((double) (_rcvrOop >> 3) );
			goto l4;
		}
	} else {
		if (((longAt(_rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_rcvrOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l4;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l4:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	if (((_tagBits2 = _argOop & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_argOop));
			_rot2 = ((usqInt) ((usqInt) _argOop ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l7;
			}
			_arg = null;
			goto l7;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _argOop ) << _shift2) ) ) >> _shift2) == _argOop))) {
			_arg = ((double) (_argOop >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(_argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_argOop + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l7;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l7:
	;
	/* end loadFloatOrIntFrom: */
	_aBool = _rcvr <= _arg;
	/* end primitiveFloatLessOrEqual:toArg: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_aBool)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	}
}
/* InterpreterPrimitives>>#primitiveFloatLessThan */
static void
primitiveFloatLessThan(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aBool;
	double _arg;
	sqInt _argOop;
	usqLong _bits;
	usqLong _bits2;
	double _rcvr;
	sqInt _rcvrOop;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin primitiveFloatLess:thanArg: */
	_rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	_argOop = unsignedLongAt(GIV(stackPointer));
	/* begin loadFloatOrIntFrom: */
	if (((_tagBits = _rcvrOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_rcvrOop));
			_rot = ((usqInt) ((usqInt) _rcvrOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l4;
			}
			_rcvr = null;
			goto l4;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _rcvrOop ) << _shift) ) ) >> _shift) == _rcvrOop))) {
			_rcvr = ((double) (_rcvrOop >> 3) );
			goto l4;
		}
	} else {
		if (((longAt(_rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_rcvrOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l4;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l4:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	if (((_tagBits2 = _argOop & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_argOop));
			_rot2 = ((usqInt) ((usqInt) _argOop ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l7;
			}
			_arg = null;
			goto l7;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _argOop ) << _shift2) ) ) >> _shift2) == _argOop))) {
			_arg = ((double) (_argOop >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(_argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_argOop + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l7;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l7:
	;
	/* end loadFloatOrIntFrom: */
	_aBool = _rcvr < _arg;
	/* end primitiveFloatLess:thanArg: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_aBool)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	}
}
/* InterpreterPrimitives>>#primitiveFloatMultiply */
static void
primitiveFloatMultiply(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	double _arg;
	sqInt _argOop;
	usqLong _bits;
	usqLong _bits2;
	double _rcvr;
	sqInt _rcvrOop;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin primitiveFloatMultiply:byArg: */
	_rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	_argOop = unsignedLongAt(GIV(stackPointer));
	/* begin loadFloatOrIntFrom: */
	if (((_tagBits = _rcvrOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_rcvrOop));
			_rot = ((usqInt) ((usqInt) _rcvrOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l4;
			}
			_rcvr = null;
			goto l4;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _rcvrOop ) << _shift) ) ) >> _shift) == _rcvrOop))) {
			_rcvr = ((double) (_rcvrOop >> 3) );
			goto l4;
		}
	} else {
		if (((longAt(_rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_rcvrOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l4;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l4:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	if (((_tagBits2 = _argOop & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_argOop));
			_rot2 = ((usqInt) ((usqInt) _argOop ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l7;
			}
			_arg = null;
			goto l7;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _argOop ) << _shift2) ) ) >> _shift2) == _argOop))) {
			_arg = ((double) (_argOop >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(_argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_argOop + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l7;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l7:
	;
	/* end loadFloatOrIntFrom: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushFloat: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), floatObjectOf(_rcvr * _arg));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushFloat: */
	}
	/* end primitiveFloatMultiply:byArg: */
}
/* InterpreterPrimitives>>#primitiveFloatNotEqual */
static void
primitiveFloatNotEqual(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aBool;
	double _arg;
	sqInt _argOop;
	usqLong _bits;
	usqLong _bits2;
	double _rcvr;
	sqInt _rcvrOop;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin primitiveFloatEqual:toArg: */
	_rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	_argOop = unsignedLongAt(GIV(stackPointer));
	/* begin loadFloatOrIntFrom: */
	if (((_tagBits = _rcvrOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_rcvrOop));
			_rot = ((usqInt) ((usqInt) _rcvrOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l4;
			}
			_rcvr = null;
			goto l4;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _rcvrOop ) << _shift) ) ) >> _shift) == _rcvrOop))) {
			_rcvr = ((double) (_rcvrOop >> 3) );
			goto l4;
		}
	} else {
		if (((longAt(_rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_rcvrOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l4;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l4:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	if (((_tagBits2 = _argOop & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_argOop));
			_rot2 = ((usqInt) ((usqInt) _argOop ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l7;
			}
			_arg = null;
			goto l7;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _argOop ) << _shift2) ) ) >> _shift2) == _argOop))) {
			_arg = ((double) (_argOop >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(_argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_argOop + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l7;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l7:
	;
	/* end loadFloatOrIntFrom: */
	_aBool = _rcvr == _arg;
	/* end primitiveFloatEqual:toArg: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((!_aBool)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	}
}
/* InterpreterPrimitives>>#primitiveFloatSubtract */
static void
primitiveFloatSubtract(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	double _arg;
	sqInt _argOop;
	usqLong _bits;
	usqLong _bits2;
	double _rcvr;
	sqInt _rcvrOop;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	{
		/* begin primitiveFloatSubtract:fromArg: */
		_rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
		_argOop = unsignedLongAt(GIV(stackPointer));
		/* begin loadFloatOrIntFrom: */
		if (((_tagBits = _rcvrOop & (tagMask()))) != 0) {
			if (_tagBits == (smallFloatTag())) {
				/* begin smallFloatValueOf: */
				/* begin smallFloatBitsOf: */
				assert(isImmediateFloat(_rcvrOop));
				_rot = ((usqInt) ((usqInt) _rcvrOop ) ) >> (numTagBits());
				if (_rot > 1) {
					_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
				}
				/* begin rotateRight: */
				_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
				/* end rotateRight: */
				_bits = _rot;
				/* end smallFloatBitsOf: */
				{
					memcpy(&_value, &_bits, sizeof(_value));
					_rcvr = _value;
					goto l4;
				}
				_rcvr = null;
				goto l4;
				/* end smallFloatValueOf: */
			}
			if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _rcvrOop ) << _shift) ) ) >> _shift) == _rcvrOop))) {
				_rcvr = ((double) (_rcvrOop >> 3) );
				goto l4;
			}
		} else {
			if (((longAt(_rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
				fetchFloatAtinto(_rcvrOop + BaseHeaderSize, _result);
				_rcvr = _result;
				goto l4;
			}
		}
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_rcvr = 0.0;
		l4:
		;
		/* end loadFloatOrIntFrom: */
		/* begin loadFloatOrIntFrom: */
		if (((_tagBits2 = _argOop & (tagMask()))) != 0) {
			if (_tagBits2 == (smallFloatTag())) {
				/* begin smallFloatValueOf: */
				/* begin smallFloatBitsOf: */
				assert(isImmediateFloat(_argOop));
				_rot2 = ((usqInt) ((usqInt) _argOop ) ) >> (numTagBits());
				if (_rot2 > 1) {
					_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
				}
				/* begin rotateRight: */
				_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
				/* end rotateRight: */
				_bits2 = _rot2;
				/* end smallFloatBitsOf: */
				{
					memcpy(&_value2, &_bits2, sizeof(_value2));
					_arg = _value2;
					goto l7;
				}
				_arg = null;
				goto l7;
				/* end smallFloatValueOf: */
			}
			if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _argOop ) << _shift2) ) ) >> _shift2) == _argOop))) {
				_arg = ((double) (_argOop >> 3) );
				goto l7;
			}
		} else {
			if (((longAt(_argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
				fetchFloatAtinto(_argOop + BaseHeaderSize, _result2);
				_arg = _result2;
				goto l7;
			}
		}
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_arg = 0.0;
		l7:
		;
		/* end loadFloatOrIntFrom: */
		if (!GIV(primFailCode)) {
			/* begin pop:thenPushFloat: */
			unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), floatObjectOf(_rcvr - _arg));
			GIV(stackPointer) = _sp;
			/* end pop:thenPushFloat: */
		}
		/* end primitiveFloatSubtract:fromArg: */
		return;
	}
}
/*	Clear the method lookup cache. This must be done after every programming 
	change.  */
/* InterpreterPrimitives>>#primitiveFlushCache */
static void
primitiveFlushCache(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;

	/* begin flushMethodCache */
	for (_i = 1; _i <= MethodCacheSize; _i += 1) {
		GIV(methodCache)[_i] = 0;
	}
	GIV(lastMethodCacheProbeWrite) = 0;
	/* end flushMethodCache */
}
/*	Primitive. Flush all the existing external primitives in the image thus 
	forcing a reload on next invokation. */
/* InterpreterPrimitives>>#primitiveFlushExternalPrimitives */
static void
primitiveFlushExternalPrimitives(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	sqInt _i;
	sqInt _i2;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	/* begin flushExternalPrimitives */
	/* begin allObjectsDo: */
	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop2 = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop2, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
					flushExternalPrimitiveOf(_objOop2);
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l2;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l2:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop2 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
					flushExternalPrimitiveOf(_objOop2);
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop2 = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	/* begin allOldSpaceObjectsDo: */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop22 = GIV(nilObj);
	while (1) {
		assert((_objOop22 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop22)) != 0);
		{
			if (isEnumerableObject(_objOop22)) {
				{
					if (((((usqInt) (longAt(_objOop22)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
						flushExternalPrimitiveOf(_objOop22);
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop22 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	/* end allOldSpaceObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (((((usqInt) (longAt(_currentObject)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
					flushExternalPrimitiveOf(_currentObject);
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
	/* begin flushMethodCache */
	for (_i = 1; _i <= MethodCacheSize; _i += 1) {
		GIV(methodCache)[_i] = 0;
	}
	GIV(lastMethodCacheProbeWrite) = 0;
	/* end flushMethodCache */
	/* begin flushExternalPrimitiveTable */
	for (_i2 = 0; _i2 < MaxExternalPrimitiveTableSize; _i2 += 1) {
		externalPrimitiveTable[_i2] = 0;
	}
	GIV(externalPrimitiveTableFirstFreeIndex) = 0;
	/* end flushExternalPrimitiveTable */
	/* end flushExternalPrimitives */
}
/*	Fractional part of this float. 
	N.B. IMO we should be able to assume the receiver is a float because this 
	primitive is specific to floats. eem 2/13/2017 */
/* InterpreterPrimitives>>#primitiveFractionalPart */
static void
primitiveFractionalPart(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aValue;
	double _rcvr;
	double _trunc;

	/* begin stackFloatValue: */
	_rcvr = floatValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	_trunc = 0;
	/* end stackFloatValue: */
	if (!GIV(primFailCode)) {
		/* begin stackTopPut: */
		_aValue = floatObjectOf(modf(_rcvr, &_trunc));
		unsignedLongAtput(GIV(stackPointer), _aValue);
		/* end stackTopPut: */
	}
}
/* InterpreterPrimitives>>#primitiveFullClosureValue */
static void
primitiveFullClosureValue(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _blockClosure;
	sqInt _closureMethod;
	CogMethod *_cogMethod;
	CogMethod *_cogMethod2;
	sqInt _header;
	sqInt _i;
	sqInt _inInterpreter;
	sqInt _inInterpreter2;
	sqInt _methodHeader;
	sqInt _methodHeader2;
	sqInt _methodHeader3;
	sqInt _methodHeader4;
	sqInt _numArgs;
	sqInt _numCopied;
	sqInt _numCopied2;
	sqInt _numTemps;
	sqInt _object;
	sqInt _object2;
	sqInt _object22;
	sqInt _object23;
	sqInt _object3;
	sqInt _object4;
	sqInt _object5;
	sqInt _objOop;
	sqInt _oop;
	char *_sp;
	char *_sp10;
	char *_sp11;
	char *_sp2;
	char *_sp22;
	char *_sp23;
	char *_sp3;
	char *_sp32;
	char *_sp33;
	char *_sp4;
	char *_sp42;
	char *_sp43;
	char *_sp5;
	char *_sp6;
	char *_sp7;
	char *_sp8;
	char *_sp9;
	sqInt _switched;

	_blockClosure = unsignedLongAt(GIV(stackPointer) + (GIV(argumentCount) * BytesPerWord));
	/* begin quickFetchInteger:ofObject: */
	/* begin fetchPointer:ofObject: */
	_oop = unsignedLongAt((_blockClosure + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureNumArgsIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(((_oop & 7) == 1));
	_numArgs = _oop >> 3;
	/* end quickFetchInteger:ofObject: */
	if (!(GIV(argumentCount) == _numArgs)) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	_closureMethod = unsignedLongAt((_blockClosure + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureCompiledBlockIndex ) << (shiftForWord())) ));
	if (!(((_closureMethod & (tagMask())) == 0) && (((((usqInt) (longAt(_closureMethod)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())))) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	/* begin activateNewFullClosure:method:numArgs:mayContextSwitch: */
	assert(_closureMethod == (fetchPointerofObject(FullClosureCompiledBlockIndex, _blockClosure)));
	/* begin fetchPointer:ofObject: */
	_methodHeader = unsignedLongAt((_closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if ((assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0)) {
		/* begin executeFullCogBlock:closure:mayContextSwitch: */
		/* begin cogMethodOf: */
		/* begin fetchPointer:ofObject: */
		_methodHeader3 = unsignedLongAt((_closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert((isNonImmediate(_methodHeader3)) && (((usqInt) _methodHeader3 ) < (startOfObjectMemory(getMemoryMap()))));
		_cogMethod = ((CogMethod *) _methodHeader3 );
		/* end cogMethodOf: */
		assertCStackWellAligned();
		/* begin assertValidExecutionPointe:r:s: */
		assertValidExecutionPointersimbarline(((usqInt) GIV(instructionPointer) ), GIV(framePointer), GIV(stackPointer), !(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) ))), __LINE__);
		/* end assertValidExecutionPointe:r:s: */
		/* begin ensurePushedInstructionPointer */
		if (!(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())))) {
			/* begin iframeSavedIP:put: */
			assert(!(isMachineCodeFrame(GIV(framePointer))));
			unsignedLongAtput(GIV(framePointer) + FoxIFSavedIP, GIV(instructionPointer));
			/* end iframeSavedIP:put: */
			/* begin push: */
			_object4 = ceReturnToInterpreterPC();
			unsignedLongAtput((_sp10 = GIV(stackPointer) - BytesPerWord), _object4);
			GIV(stackPointer) = _sp10;
			/* end push: */
		} else {
			/* begin push: */
			unsignedLongAtput((_sp22 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
			GIV(stackPointer) = _sp22;
			/* end push: */
		}
		/* end ensurePushedInstructionPointer */
		/* begin push: */
		_object22 = ((sqInt) _cogMethod ) + (fullBlockEntryOffset());
		unsignedLongAtput((_sp32 = GIV(stackPointer) - BytesPerWord), _object22);
		GIV(stackPointer) = _sp32;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp42 = GIV(stackPointer) - BytesPerWord), _blockClosure);
		GIV(stackPointer) = _sp42;
		/* end push: */
		/* begin callEnilopmart: */
		ceCallCogCodePopReceiverReg();
		/* end callEnilopmart: */
		{
			assert(0);
		}
		/* end executeFullCogBlock:closure:mayContextSwitch: */
		goto l11;
	}
	if (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
		if ((!(!(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap()))))) || (_closureMethod == GIV(lastCoggableInterpretedBlockMethod))) {
			if (_closureMethod != GIV(lastUncoggableInterpretedBlockMethod)) {
				_numCopied = (numSlotsOf(_blockClosure)) - FullClosureFirstCopiedValueIndex;
				cogFullBlockMethodnumCopied(_closureMethod, _numCopied);
				if ((assert(isNonImmediate(_closureMethod)), isCogMethodReference(rawHeaderOf(_closureMethod)))) {
					/* begin executeFullCogBlock:closure:mayContextSwitch: */
					/* begin cogMethodOf: */
					/* begin fetchPointer:ofObject: */
					_methodHeader4 = unsignedLongAt((_closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					assert((isNonImmediate(_methodHeader4)) && (((usqInt) _methodHeader4 ) < (startOfObjectMemory(getMemoryMap()))));
					_cogMethod2 = ((CogMethod *) _methodHeader4 );
					/* end cogMethodOf: */
					assertCStackWellAligned();
					/* begin assertValidExecutionPointe:r:s: */
					assertValidExecutionPointersimbarline(((usqInt) GIV(instructionPointer) ), GIV(framePointer), GIV(stackPointer), !(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) ))), __LINE__);
					/* end assertValidExecutionPointe:r:s: */
					/* begin ensurePushedInstructionPointer */
					if (!(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())))) {
						/* begin iframeSavedIP:put: */
						assert(!(isMachineCodeFrame(GIV(framePointer))));
						unsignedLongAtput(GIV(framePointer) + FoxIFSavedIP, GIV(instructionPointer));
						/* end iframeSavedIP:put: */
						/* begin push: */
						_object5 = ceReturnToInterpreterPC();
						unsignedLongAtput((_sp11 = GIV(stackPointer) - BytesPerWord), _object5);
						GIV(stackPointer) = _sp11;
						/* end push: */
					} else {
						/* begin push: */
						unsignedLongAtput((_sp23 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
						GIV(stackPointer) = _sp23;
						/* end push: */
					}
					/* end ensurePushedInstructionPointer */
					/* begin push: */
					_object23 = ((sqInt) _cogMethod2 ) + (fullBlockEntryOffset());
					unsignedLongAtput((_sp33 = GIV(stackPointer) - BytesPerWord), _object23);
					GIV(stackPointer) = _sp33;
					/* end push: */
					/* begin push: */
					unsignedLongAtput((_sp43 = GIV(stackPointer) - BytesPerWord), _blockClosure);
					GIV(stackPointer) = _sp43;
					/* end push: */
					/* begin callEnilopmart: */
					ceCallCogCodePopReceiverReg();
					/* end callEnilopmart: */
					{
						assert(0);
					}
					/* end executeFullCogBlock:closure:mayContextSwitch: */
					goto l11;
				}
				if (!GIV(cogCompiledCodeCompactionCalledFor)) {
					GIV(lastUncoggableInterpretedBlockMethod) = _closureMethod;
				}
			}
		} else {
			GIV(lastCoggableInterpretedBlockMethod) = _closureMethod;
		}
	} else {
		maybeFlagMethodAsInterpreted(_closureMethod);
	}
	assert(!(methodHasCogMethod(_closureMethod)));
	if (!((_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())))))) {
		if (((usqIntptr_t) GIV(instructionPointer) ) == (ceReturnToInterpreterPC())) {
			GIV(instructionPointer) = unsignedLongAt(GIV(framePointer) + FoxIFSavedIP);
		}
	}
	assert(_closureMethod == (fetchPointerofObject(FullClosureCompiledBlockIndex, _blockClosure)));
	_inInterpreter2 = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	_numCopied2 = (numSlotsOf(_blockClosure)) - FullClosureFirstCopiedValueIndex;
	/* begin push: */
	unsignedLongAtput((_sp4 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
	GIV(stackPointer) = _sp4;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp5 = GIV(stackPointer) - BytesPerWord), GIV(framePointer));
	GIV(stackPointer) = _sp5;
	/* end push: */
	GIV(framePointer) = GIV(stackPointer);
	/* begin push: */
	unsignedLongAtput((_sp6 = GIV(stackPointer) - BytesPerWord), _closureMethod);
	GIV(stackPointer) = _sp6;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp7 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
	GIV(stackPointer) = _sp7;
	/* end push: */
	/* begin push: */
	_object2 = ((VMBIGENDIAN)
		 ? ((1 + ((sqInt) (((usqInt) _numArgs ) << ((BytesPerWord * 8) - 8)) )) + 0) + (1ULL << ((BytesPerWord * 8) - 24))
		 : ((1 + ((sqInt) (((usqInt) _numArgs ) << 8) )) + 0) + (1U << 24));
	unsignedLongAtput((_sp8 = GIV(stackPointer) - BytesPerWord), _object2);
	GIV(stackPointer) = _sp8;
	/* end push: */
	{
		/* begin push: */
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), 0);
		GIV(stackPointer) = _sp;
		/* end push: */
	}
	/* begin push: */
	/* begin followField:ofObject: */
	/* begin fetchPointer:ofObject: */
	_objOop = unsignedLongAt((_blockClosure + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureReceiverIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		_objOop = fixFollowedFieldofObjectwithInitialValue(FullClosureReceiverIndex, _blockClosure, _objOop);
	}
	_object3 = _objOop;
	/* end followField:ofObject: */
	unsignedLongAtput((_sp9 = GIV(stackPointer) - BytesPerWord), _object3);
	GIV(stackPointer) = _sp9;
	/* end push: */
	for (_i = 0; _i < _numCopied2; _i += 1) {
		/* begin push: */
		_object = unsignedLongAt((_blockClosure + BaseHeaderSize) + ((sqInt) (((usqInt) (_i + FullClosureFirstCopiedValueIndex) ) << (shiftForWord())) ));
		unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _object);
		GIV(stackPointer) = _sp2;
		/* end push: */
	}
	assert(frameIsBlockActivation(GIV(framePointer)));
	assert(!(frameHasContext(GIV(framePointer))));
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_closureMethod));
	/* begin fetchPointer:ofObject: */
	_header = unsignedLongAt((_closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header & 7) == 1)) {
		_methodHeader2 = _header;
	} else {
		assert(((usqInt) _header ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_methodHeader2 = ((((CogMethod *) _header ))->methodHeader);
	}
	/* end methodHeaderOf: */
	_numTemps = (((usqInt) _methodHeader2 ) >> MethodHeaderTempCountShift) & 0x3F;
	for (_i = (_numArgs + _numCopied2) + 1; _i <= _numTemps; _i += 1) {
		/* begin push: */
		unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
		GIV(stackPointer) = _sp3;
		/* end push: */
	}
	GIV(instructionPointer) = ((_closureMethod + ((LiteralStart + ((assert(((_methodHeader2 & 7) == 1)), (_methodHeader2 >> 3) & AlternateHeaderNumLiteralsMask))) * BytesPerOop)) + BaseHeaderSize) - 1;
	/* begin setMethod: */
	assert(((usqInt) _closureMethod ) >= (startOfObjectMemory(getMemoryMap())));
	{
		GIV(method) = _closureMethod;
		assert(isOopCompiledMethod(GIV(method)));
	}
	/* end setMethod: */
	_switched = 0;
	if (GIV(stackPointer) < GIV(stackLimit)) {
		_switched = handleStackOverflowOrEventAllowContextSwitch(1);
	}
	returnToExecutivepostContextSwitch(_inInterpreter2, _switched);
	goto l11;
	l11:
	;
	/* end activateNewFullClosure:method:numArgs:mayContextSwitch: */
}
/*	An exact clone of primitiveFullClosureValue except that this version will 
	not check for interrupts on stack overflow. It may invoke the garbage 
	collector but will not switch processes. See 
	checkForInterruptsMayContextSwitch:  */
/* InterpreterPrimitives>>#primitiveFullClosureValueNoContextSwitch */
void
primitiveFullClosureValueNoContextSwitch(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _blockClosure;
	sqInt _closureMethod;
	CogMethod *_cogMethod;
	CogMethod *_cogMethod2;
	sqInt _header;
	sqInt _i;
	sqInt _inInterpreter;
	sqInt _inInterpreter2;
	sqInt _methodHeader;
	sqInt _methodHeader2;
	sqInt _methodHeader3;
	sqInt _methodHeader4;
	sqInt _numArgs;
	sqInt _numCopied;
	sqInt _numCopied2;
	sqInt _numTemps;
	sqInt _object;
	sqInt _object2;
	sqInt _object22;
	sqInt _object23;
	sqInt _object3;
	sqInt _object4;
	sqInt _object5;
	sqInt _objOop;
	sqInt _oop;
	char *_sp;
	char *_sp10;
	char *_sp11;
	char *_sp2;
	char *_sp22;
	char *_sp23;
	char *_sp3;
	char *_sp32;
	char *_sp33;
	char *_sp4;
	char *_sp42;
	char *_sp43;
	char *_sp5;
	char *_sp6;
	char *_sp7;
	char *_sp8;
	char *_sp9;
	sqInt _switched;

	_blockClosure = unsignedLongAt(GIV(stackPointer) + (GIV(argumentCount) * BytesPerWord));
	/* begin quickFetchInteger:ofObject: */
	/* begin fetchPointer:ofObject: */
	_oop = unsignedLongAt((_blockClosure + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureNumArgsIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(((_oop & 7) == 1));
	_numArgs = _oop >> 3;
	/* end quickFetchInteger:ofObject: */
	if (!(GIV(argumentCount) == _numArgs)) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	_closureMethod = unsignedLongAt((_blockClosure + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureCompiledBlockIndex ) << (shiftForWord())) ));
	if (!(((_closureMethod & (tagMask())) == 0) && (((((usqInt) (longAt(_closureMethod)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())))) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	/* begin activateNewFullClosure:method:numArgs:mayContextSwitch: */
	assert(_closureMethod == (fetchPointerofObject(FullClosureCompiledBlockIndex, _blockClosure)));
	/* begin fetchPointer:ofObject: */
	_methodHeader = unsignedLongAt((_closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if ((assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0)) {
		/* begin executeFullCogBlock:closure:mayContextSwitch: */
		/* begin cogMethodOf: */
		/* begin fetchPointer:ofObject: */
		_methodHeader3 = unsignedLongAt((_closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert((isNonImmediate(_methodHeader3)) && (((usqInt) _methodHeader3 ) < (startOfObjectMemory(getMemoryMap()))));
		_cogMethod = ((CogMethod *) _methodHeader3 );
		/* end cogMethodOf: */
		assertCStackWellAligned();
		/* begin assertValidExecutionPointe:r:s: */
		assertValidExecutionPointersimbarline(((usqInt) GIV(instructionPointer) ), GIV(framePointer), GIV(stackPointer), !(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) ))), __LINE__);
		/* end assertValidExecutionPointe:r:s: */
		/* begin ensurePushedInstructionPointer */
		if (!(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())))) {
			/* begin iframeSavedIP:put: */
			assert(!(isMachineCodeFrame(GIV(framePointer))));
			unsignedLongAtput(GIV(framePointer) + FoxIFSavedIP, GIV(instructionPointer));
			/* end iframeSavedIP:put: */
			/* begin push: */
			_object4 = ceReturnToInterpreterPC();
			unsignedLongAtput((_sp10 = GIV(stackPointer) - BytesPerWord), _object4);
			GIV(stackPointer) = _sp10;
			/* end push: */
		} else {
			/* begin push: */
			unsignedLongAtput((_sp22 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
			GIV(stackPointer) = _sp22;
			/* end push: */
		}
		/* end ensurePushedInstructionPointer */
		/* begin push: */
		_object22 = ((sqInt) _cogMethod ) + (fullBlockNoContextSwitchEntryOffset());
		unsignedLongAtput((_sp32 = GIV(stackPointer) - BytesPerWord), _object22);
		GIV(stackPointer) = _sp32;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp42 = GIV(stackPointer) - BytesPerWord), _blockClosure);
		GIV(stackPointer) = _sp42;
		/* end push: */
		/* begin callEnilopmart: */
		ceCallCogCodePopReceiverReg();
		/* end callEnilopmart: */
		{
			assert(0);
		}
		/* end executeFullCogBlock:closure:mayContextSwitch: */
		goto l11;
	}
	if (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
		if ((!(!(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap()))))) || (_closureMethod == GIV(lastCoggableInterpretedBlockMethod))) {
			if (_closureMethod != GIV(lastUncoggableInterpretedBlockMethod)) {
				_numCopied = (numSlotsOf(_blockClosure)) - FullClosureFirstCopiedValueIndex;
				cogFullBlockMethodnumCopied(_closureMethod, _numCopied);
				if ((assert(isNonImmediate(_closureMethod)), isCogMethodReference(rawHeaderOf(_closureMethod)))) {
					/* begin executeFullCogBlock:closure:mayContextSwitch: */
					/* begin cogMethodOf: */
					/* begin fetchPointer:ofObject: */
					_methodHeader4 = unsignedLongAt((_closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					assert((isNonImmediate(_methodHeader4)) && (((usqInt) _methodHeader4 ) < (startOfObjectMemory(getMemoryMap()))));
					_cogMethod2 = ((CogMethod *) _methodHeader4 );
					/* end cogMethodOf: */
					assertCStackWellAligned();
					/* begin assertValidExecutionPointe:r:s: */
					assertValidExecutionPointersimbarline(((usqInt) GIV(instructionPointer) ), GIV(framePointer), GIV(stackPointer), !(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) ))), __LINE__);
					/* end assertValidExecutionPointe:r:s: */
					/* begin ensurePushedInstructionPointer */
					if (!(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())))) {
						/* begin iframeSavedIP:put: */
						assert(!(isMachineCodeFrame(GIV(framePointer))));
						unsignedLongAtput(GIV(framePointer) + FoxIFSavedIP, GIV(instructionPointer));
						/* end iframeSavedIP:put: */
						/* begin push: */
						_object5 = ceReturnToInterpreterPC();
						unsignedLongAtput((_sp11 = GIV(stackPointer) - BytesPerWord), _object5);
						GIV(stackPointer) = _sp11;
						/* end push: */
					} else {
						/* begin push: */
						unsignedLongAtput((_sp23 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
						GIV(stackPointer) = _sp23;
						/* end push: */
					}
					/* end ensurePushedInstructionPointer */
					/* begin push: */
					_object23 = ((sqInt) _cogMethod2 ) + (fullBlockNoContextSwitchEntryOffset());
					unsignedLongAtput((_sp33 = GIV(stackPointer) - BytesPerWord), _object23);
					GIV(stackPointer) = _sp33;
					/* end push: */
					/* begin push: */
					unsignedLongAtput((_sp43 = GIV(stackPointer) - BytesPerWord), _blockClosure);
					GIV(stackPointer) = _sp43;
					/* end push: */
					/* begin callEnilopmart: */
					ceCallCogCodePopReceiverReg();
					/* end callEnilopmart: */
					{
						assert(0);
					}
					/* end executeFullCogBlock:closure:mayContextSwitch: */
					goto l11;
				}
				if (!GIV(cogCompiledCodeCompactionCalledFor)) {
					GIV(lastUncoggableInterpretedBlockMethod) = _closureMethod;
				}
			}
		} else {
			GIV(lastCoggableInterpretedBlockMethod) = _closureMethod;
		}
	} else {
		maybeFlagMethodAsInterpreted(_closureMethod);
	}
	assert(!(methodHasCogMethod(_closureMethod)));
	if (!((_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())))))) {
		if (((usqIntptr_t) GIV(instructionPointer) ) == (ceReturnToInterpreterPC())) {
			GIV(instructionPointer) = unsignedLongAt(GIV(framePointer) + FoxIFSavedIP);
		}
	}
	assert(_closureMethod == (fetchPointerofObject(FullClosureCompiledBlockIndex, _blockClosure)));
	_inInterpreter2 = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	_numCopied2 = (numSlotsOf(_blockClosure)) - FullClosureFirstCopiedValueIndex;
	/* begin push: */
	unsignedLongAtput((_sp4 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
	GIV(stackPointer) = _sp4;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp5 = GIV(stackPointer) - BytesPerWord), GIV(framePointer));
	GIV(stackPointer) = _sp5;
	/* end push: */
	GIV(framePointer) = GIV(stackPointer);
	/* begin push: */
	unsignedLongAtput((_sp6 = GIV(stackPointer) - BytesPerWord), _closureMethod);
	GIV(stackPointer) = _sp6;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp7 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
	GIV(stackPointer) = _sp7;
	/* end push: */
	/* begin push: */
	_object2 = ((VMBIGENDIAN)
		 ? ((1 + ((sqInt) (((usqInt) _numArgs ) << ((BytesPerWord * 8) - 8)) )) + 0) + (1ULL << ((BytesPerWord * 8) - 24))
		 : ((1 + ((sqInt) (((usqInt) _numArgs ) << 8) )) + 0) + (1U << 24));
	unsignedLongAtput((_sp8 = GIV(stackPointer) - BytesPerWord), _object2);
	GIV(stackPointer) = _sp8;
	/* end push: */
	{
		/* begin push: */
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), 0);
		GIV(stackPointer) = _sp;
		/* end push: */
	}
	/* begin push: */
	/* begin followField:ofObject: */
	/* begin fetchPointer:ofObject: */
	_objOop = unsignedLongAt((_blockClosure + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureReceiverIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		_objOop = fixFollowedFieldofObjectwithInitialValue(FullClosureReceiverIndex, _blockClosure, _objOop);
	}
	_object3 = _objOop;
	/* end followField:ofObject: */
	unsignedLongAtput((_sp9 = GIV(stackPointer) - BytesPerWord), _object3);
	GIV(stackPointer) = _sp9;
	/* end push: */
	for (_i = 0; _i < _numCopied2; _i += 1) {
		/* begin push: */
		_object = unsignedLongAt((_blockClosure + BaseHeaderSize) + ((sqInt) (((usqInt) (_i + FullClosureFirstCopiedValueIndex) ) << (shiftForWord())) ));
		unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _object);
		GIV(stackPointer) = _sp2;
		/* end push: */
	}
	assert(frameIsBlockActivation(GIV(framePointer)));
	assert(!(frameHasContext(GIV(framePointer))));
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_closureMethod));
	/* begin fetchPointer:ofObject: */
	_header = unsignedLongAt((_closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header & 7) == 1)) {
		_methodHeader2 = _header;
	} else {
		assert(((usqInt) _header ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_methodHeader2 = ((((CogMethod *) _header ))->methodHeader);
	}
	/* end methodHeaderOf: */
	_numTemps = (((usqInt) _methodHeader2 ) >> MethodHeaderTempCountShift) & 0x3F;
	for (_i = (_numArgs + _numCopied2) + 1; _i <= _numTemps; _i += 1) {
		/* begin push: */
		unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
		GIV(stackPointer) = _sp3;
		/* end push: */
	}
	GIV(instructionPointer) = ((_closureMethod + ((LiteralStart + ((assert(((_methodHeader2 & 7) == 1)), (_methodHeader2 >> 3) & AlternateHeaderNumLiteralsMask))) * BytesPerOop)) + BaseHeaderSize) - 1;
	/* begin setMethod: */
	assert(((usqInt) _closureMethod ) >= (startOfObjectMemory(getMemoryMap())));
	{
		GIV(method) = _closureMethod;
		assert(isOopCompiledMethod(GIV(method)));
	}
	/* end setMethod: */
	_switched = 0;
	if (GIV(stackPointer) < GIV(stackLimit)) {
		_switched = handleStackOverflowOrEventAllowContextSwitch(0);
	}
	returnToExecutivepostContextSwitch(_inInterpreter2, _switched);
	goto l11;
	l11:
	;
	/* end activateNewFullClosure:method:numArgs:mayContextSwitch: */
}
/* InterpreterPrimitives>>#primitiveFullClosureValueWithArgs */
static void
primitiveFullClosureValueWithArgs(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _argumentArray;
	usqInt _arraySize;
	sqInt _blockClosure;
	sqInt _closureMethod;
	CogMethod *_cogMethod;
	CogMethod *_cogMethod2;
	sqInt _header;
	sqInt _i;
	int _index;
	sqInt _inInterpreter;
	sqInt _inInterpreter2;
	sqInt _methodHeader;
	sqInt _methodHeader2;
	sqInt _methodHeader3;
	sqInt _methodHeader4;
	sqInt _numArgs;
	sqInt _numCopied;
	sqInt _numCopied2;
	usqInt _numSlots;
	sqInt _numTemps;
	sqInt _object;
	sqInt _object2;
	sqInt _object22;
	sqInt _object23;
	sqInt _object3;
	sqInt _object4;
	sqInt _object5;
	sqInt _object6;
	sqInt _objOop;
	sqInt _oop;
	char *_sp;
	char *_sp10;
	char *_sp11;
	char *_sp12;
	char *_sp2;
	char *_sp22;
	char *_sp23;
	char *_sp3;
	char *_sp32;
	char *_sp33;
	char *_sp4;
	char *_sp42;
	char *_sp43;
	char *_sp5;
	char *_sp6;
	char *_sp7;
	char *_sp8;
	char *_sp9;
	sqInt _switched;
	sqInt _top;

	_argumentArray = unsignedLongAt(GIV(stackPointer));
	if (!(((_argumentArray & (tagMask())) == 0) && (((((usqInt) (longAt(_argumentArray)) ) >> (formatShift())) & (formatMask())) == 2))) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	/* begin numSlotsOf: */
	assert((classIndexOf(_argumentArray)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_argumentArray + 7);
	_arraySize = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_argumentArray - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	if (!(_arraySize <= (LargeContextSlots - CtxtTempFrameStart))) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	_blockClosure = unsignedLongAt(GIV(stackPointer) + (GIV(argumentCount) * BytesPerWord));
	/* begin quickFetchInteger:ofObject: */
	/* begin fetchPointer:ofObject: */
	_oop = unsignedLongAt((_blockClosure + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureNumArgsIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(((_oop & 7) == 1));
	_numArgs = _oop >> 3;
	/* end quickFetchInteger:ofObject: */
	if (!(_arraySize == _numArgs)) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	_closureMethod = unsignedLongAt((_blockClosure + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureCompiledBlockIndex ) << (shiftForWord())) ));
	if (!(((_closureMethod & (tagMask())) == 0) && (((((usqInt) (longAt(_closureMethod)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())))) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	/* begin popStack */
	_top = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	/* end popStack */
	_index = 1;
	while (_index <= _numArgs) {
		/* begin push: */
		_object = unsignedLongAt((_argumentArray + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << (shiftForWord())) ));
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
		GIV(stackPointer) = _sp;
		/* end push: */
		_index += 1;
	}
	/* begin activateNewFullClosure:method:numArgs:mayContextSwitch: */
	assert(_closureMethod == (fetchPointerofObject(FullClosureCompiledBlockIndex, _blockClosure)));
	/* begin fetchPointer:ofObject: */
	_methodHeader = unsignedLongAt((_closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if ((assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0)) {
		/* begin executeFullCogBlock:closure:mayContextSwitch: */
		/* begin cogMethodOf: */
		/* begin fetchPointer:ofObject: */
		_methodHeader3 = unsignedLongAt((_closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert((isNonImmediate(_methodHeader3)) && (((usqInt) _methodHeader3 ) < (startOfObjectMemory(getMemoryMap()))));
		_cogMethod = ((CogMethod *) _methodHeader3 );
		/* end cogMethodOf: */
		assertCStackWellAligned();
		/* begin assertValidExecutionPointe:r:s: */
		assertValidExecutionPointersimbarline(((usqInt) GIV(instructionPointer) ), GIV(framePointer), GIV(stackPointer), !(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) ))), __LINE__);
		/* end assertValidExecutionPointe:r:s: */
		/* begin ensurePushedInstructionPointer */
		if (!(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())))) {
			/* begin iframeSavedIP:put: */
			assert(!(isMachineCodeFrame(GIV(framePointer))));
			unsignedLongAtput(GIV(framePointer) + FoxIFSavedIP, GIV(instructionPointer));
			/* end iframeSavedIP:put: */
			/* begin push: */
			_object4 = ceReturnToInterpreterPC();
			unsignedLongAtput((_sp10 = GIV(stackPointer) - BytesPerWord), _object4);
			GIV(stackPointer) = _sp10;
			/* end push: */
		} else {
			/* begin push: */
			unsignedLongAtput((_sp22 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
			GIV(stackPointer) = _sp22;
			/* end push: */
		}
		/* end ensurePushedInstructionPointer */
		/* begin push: */
		_object22 = ((sqInt) _cogMethod ) + (fullBlockEntryOffset());
		unsignedLongAtput((_sp32 = GIV(stackPointer) - BytesPerWord), _object22);
		GIV(stackPointer) = _sp32;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((_sp42 = GIV(stackPointer) - BytesPerWord), _blockClosure);
		GIV(stackPointer) = _sp42;
		/* end push: */
		/* begin callEnilopmart: */
		ceCallCogCodePopReceiverReg();
		/* end callEnilopmart: */
		{
			assert(0);
		}
		/* end executeFullCogBlock:closure:mayContextSwitch: */
		goto l13;
	}
	if (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
		if ((!(!(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap()))))) || (_closureMethod == GIV(lastCoggableInterpretedBlockMethod))) {
			if (_closureMethod != GIV(lastUncoggableInterpretedBlockMethod)) {
				_numCopied = (numSlotsOf(_blockClosure)) - FullClosureFirstCopiedValueIndex;
				cogFullBlockMethodnumCopied(_closureMethod, _numCopied);
				if ((assert(isNonImmediate(_closureMethod)), isCogMethodReference(rawHeaderOf(_closureMethod)))) {
					/* begin executeFullCogBlock:closure:mayContextSwitch: */
					/* begin cogMethodOf: */
					/* begin fetchPointer:ofObject: */
					_methodHeader4 = unsignedLongAt((_closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					assert((isNonImmediate(_methodHeader4)) && (((usqInt) _methodHeader4 ) < (startOfObjectMemory(getMemoryMap()))));
					_cogMethod2 = ((CogMethod *) _methodHeader4 );
					/* end cogMethodOf: */
					assertCStackWellAligned();
					/* begin assertValidExecutionPointe:r:s: */
					assertValidExecutionPointersimbarline(((usqInt) GIV(instructionPointer) ), GIV(framePointer), GIV(stackPointer), !(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) ))), __LINE__);
					/* end assertValidExecutionPointe:r:s: */
					/* begin ensurePushedInstructionPointer */
					if (!(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())))) {
						/* begin iframeSavedIP:put: */
						assert(!(isMachineCodeFrame(GIV(framePointer))));
						unsignedLongAtput(GIV(framePointer) + FoxIFSavedIP, GIV(instructionPointer));
						/* end iframeSavedIP:put: */
						/* begin push: */
						_object5 = ceReturnToInterpreterPC();
						unsignedLongAtput((_sp11 = GIV(stackPointer) - BytesPerWord), _object5);
						GIV(stackPointer) = _sp11;
						/* end push: */
					} else {
						/* begin push: */
						unsignedLongAtput((_sp23 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
						GIV(stackPointer) = _sp23;
						/* end push: */
					}
					/* end ensurePushedInstructionPointer */
					/* begin push: */
					_object23 = ((sqInt) _cogMethod2 ) + (fullBlockEntryOffset());
					unsignedLongAtput((_sp33 = GIV(stackPointer) - BytesPerWord), _object23);
					GIV(stackPointer) = _sp33;
					/* end push: */
					/* begin push: */
					unsignedLongAtput((_sp43 = GIV(stackPointer) - BytesPerWord), _blockClosure);
					GIV(stackPointer) = _sp43;
					/* end push: */
					/* begin callEnilopmart: */
					ceCallCogCodePopReceiverReg();
					/* end callEnilopmart: */
					{
						assert(0);
					}
					/* end executeFullCogBlock:closure:mayContextSwitch: */
					goto l13;
				}
				if (!GIV(cogCompiledCodeCompactionCalledFor)) {
					GIV(lastUncoggableInterpretedBlockMethod) = _closureMethod;
				}
			}
		} else {
			GIV(lastCoggableInterpretedBlockMethod) = _closureMethod;
		}
	} else {
		maybeFlagMethodAsInterpreted(_closureMethod);
	}
	assert(!(methodHasCogMethod(_closureMethod)));
	if (!((_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())))))) {
		if (((usqIntptr_t) GIV(instructionPointer) ) == (ceReturnToInterpreterPC())) {
			GIV(instructionPointer) = unsignedLongAt(GIV(framePointer) + FoxIFSavedIP);
		}
	}
	assert(_closureMethod == (fetchPointerofObject(FullClosureCompiledBlockIndex, _blockClosure)));
	_inInterpreter2 = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	_numCopied2 = (numSlotsOf(_blockClosure)) - FullClosureFirstCopiedValueIndex;
	/* begin push: */
	unsignedLongAtput((_sp4 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
	GIV(stackPointer) = _sp4;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp5 = GIV(stackPointer) - BytesPerWord), GIV(framePointer));
	GIV(stackPointer) = _sp5;
	/* end push: */
	GIV(framePointer) = GIV(stackPointer);
	/* begin push: */
	unsignedLongAtput((_sp6 = GIV(stackPointer) - BytesPerWord), _closureMethod);
	GIV(stackPointer) = _sp6;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp7 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
	GIV(stackPointer) = _sp7;
	/* end push: */
	/* begin push: */
	_object2 = ((VMBIGENDIAN)
		 ? ((1 + ((sqInt) (((usqInt) _numArgs ) << ((BytesPerWord * 8) - 8)) )) + 0) + (1ULL << ((BytesPerWord * 8) - 24))
		 : ((1 + ((sqInt) (((usqInt) _numArgs ) << 8) )) + 0) + (1U << 24));
	unsignedLongAtput((_sp8 = GIV(stackPointer) - BytesPerWord), _object2);
	GIV(stackPointer) = _sp8;
	/* end push: */
	{
		/* begin push: */
		unsignedLongAtput((_sp12 = GIV(stackPointer) - BytesPerWord), 0);
		GIV(stackPointer) = _sp12;
		/* end push: */
	}
	/* begin push: */
	/* begin followField:ofObject: */
	/* begin fetchPointer:ofObject: */
	_objOop = unsignedLongAt((_blockClosure + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureReceiverIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		_objOop = fixFollowedFieldofObjectwithInitialValue(FullClosureReceiverIndex, _blockClosure, _objOop);
	}
	_object3 = _objOop;
	/* end followField:ofObject: */
	unsignedLongAtput((_sp9 = GIV(stackPointer) - BytesPerWord), _object3);
	GIV(stackPointer) = _sp9;
	/* end push: */
	for (_i = 0; _i < _numCopied2; _i += 1) {
		/* begin push: */
		_object6 = unsignedLongAt((_blockClosure + BaseHeaderSize) + ((sqInt) (((usqInt) (_i + FullClosureFirstCopiedValueIndex) ) << (shiftForWord())) ));
		unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _object6);
		GIV(stackPointer) = _sp2;
		/* end push: */
	}
	assert(frameIsBlockActivation(GIV(framePointer)));
	assert(!(frameHasContext(GIV(framePointer))));
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_closureMethod));
	/* begin fetchPointer:ofObject: */
	_header = unsignedLongAt((_closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header & 7) == 1)) {
		_methodHeader2 = _header;
	} else {
		assert(((usqInt) _header ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_methodHeader2 = ((((CogMethod *) _header ))->methodHeader);
	}
	/* end methodHeaderOf: */
	_numTemps = (((usqInt) _methodHeader2 ) >> MethodHeaderTempCountShift) & 0x3F;
	for (_i = (_numArgs + _numCopied2) + 1; _i <= _numTemps; _i += 1) {
		/* begin push: */
		unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
		GIV(stackPointer) = _sp3;
		/* end push: */
	}
	GIV(instructionPointer) = ((_closureMethod + ((LiteralStart + ((assert(((_methodHeader2 & 7) == 1)), (_methodHeader2 >> 3) & AlternateHeaderNumLiteralsMask))) * BytesPerOop)) + BaseHeaderSize) - 1;
	/* begin setMethod: */
	assert(((usqInt) _closureMethod ) >= (startOfObjectMemory(getMemoryMap())));
	{
		GIV(method) = _closureMethod;
		assert(isOopCompiledMethod(GIV(method)));
	}
	/* end setMethod: */
	_switched = 0;
	if (GIV(stackPointer) < GIV(stackLimit)) {
		_switched = handleStackOverflowOrEventAllowContextSwitch(1);
	}
	returnToExecutivepostContextSwitch(_inInterpreter2, _switched);
	goto l13;
	l13:
	;
	/* end activateNewFullClosure:method:numArgs:mayContextSwitch: */
}
/*	Fetch the system attribute with the given integer ID. The  
	result is a string, which will be empty if the attribute is not  
	defined. */
/* InterpreterPrimitives>>#primitiveGetAttribute */
static void
primitiveGetAttribute(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classObj;
	sqInt _index;
	sqInt _integerPointer;
	sqInt _s;
	char *_sp;
	sqInt _sz;

	/* begin stackIntegerValue: */
	_integerPointer = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_index = _integerPointer >> 3;
		goto l2;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_index = 0;
		goto l2;
	}
	/* end checkedIntegerValueOf: */
	l2:
	;
	/* end stackIntegerValue: */
	if (GIV(primFailCode)) {
		return;
	}
	_sz = attributeSize(_index);
	if (GIV(primFailCode)) {
		return;
	}
	/* begin instantiateClass:indexableSize: */
	_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteString ) << (shiftForWord())) ));
	_s = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, _sz, 0, 0);
	/* end instantiateClass:indexableSize: */
	getAttributeIntoLength(_index, _s + BaseHeaderSize, _sz);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _s);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Access to environment variables via getenv. No putenv or setenv as yet. */
/* InterpreterPrimitives>>#primitiveGetenv */
EXPORT(sqInt)
primitiveGetenv(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_key;
	sqInt _oop;
	sqInt _result;
	char *_sp;
	char *_var;

	_result = 0;
	_key = cStringOrNullFor(unsignedLongAt(GIV(stackPointer)));
	if (_key == 0) {
		if (!GIV(primFailCode)) {
			/* begin primitiveFailFor: */
			return (GIV(primFailCode) = PrimErrBadArgument);
			/* end primitiveFailFor: */
		}
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = GIV(primFailCode));
		/* end primitiveFailFor: */
	}
	_var = getenv(_key);
	free(_key);
	if (_var != 0) {
		_result = stringForCString(_var);
		if (!_result) {
			/* begin primitiveFailFor: */
			return (GIV(primFailCode) = PrimErrNoMemory);
			/* end primitiveFailFor: */
		}
	}
	assert(GIV(primFailCode) == 0);
	/* begin pop:thenPush: */
	_oop = ((_var == 0)
		 ? GIV(nilObj)
		 : _result);
	unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	return 0;
}
/* InterpreterPrimitives>>#primitiveGetImmutability */

#if IMMUTABILITY
static void
primitiveGetImmutability(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _rcvr;
	char *_sp;
	sqInt _trueOrFalse;

	_rcvr = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin pop:thenPushBool: */
	_trueOrFalse = (_rcvr & (tagMask())) || (((((usqInt) (longAt(_rcvr)) ) >> (immutableBitShift())) & 1) != 0);
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((_trueOrFalse)
		 ? GIV(trueObj)
		 : GIV(falseObj)));
	GIV(stackPointer) = _sp;
	/* end pop:thenPushBool: */
}
#endif /* IMMUTABILITY */
/* InterpreterPrimitives>>#primitiveGreaterOrEqual */
static void
primitiveGreaterOrEqual(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerArgument;
	sqInt _integerReceiver;
	char *_sp;

	_integerArgument = unsignedLongAt(GIV(stackPointer));
	_integerReceiver = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if ((_integerReceiver & _integerArgument) & (smallIntegerTag())) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_integerReceiver >= _integerArgument)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	}
}
/*	Primitive comparison operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveGreaterOrEqualLargeIntegers */
EXPORT(void)
primitiveGreaterOrEqualLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqLong _integerArg;
	sqLong _integerRcvr;
	char *_sp;

	_integerArg = signed64BitValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	_integerRcvr = signed64BitValueOf(unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord)));
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_integerRcvr >= _integerArg)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	}
}
/* InterpreterPrimitives>>#primitiveGreaterThan */
static void
primitiveGreaterThan(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerArgument;
	sqInt _integerReceiver;
	char *_sp;

	_integerArgument = unsignedLongAt(GIV(stackPointer));
	_integerReceiver = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if ((_integerReceiver & _integerArgument) & (smallIntegerTag())) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_integerReceiver > _integerArgument)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	}
}
/*	Primitive comparison operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveGreaterThanLargeIntegers */
EXPORT(void)
primitiveGreaterThanLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqLong _integerArg;
	sqLong _integerRcvr;
	char *_sp;

	_integerArg = signed64BitValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	_integerRcvr = signed64BitValueOf(unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord)));
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_integerRcvr > _integerArg)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	}
}
/* InterpreterPrimitives>>#primitiveGrowMemoryByAtLeast */
static void
primitiveGrowMemoryByAtLeast(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _ammount;
	size_t _segSize;
	char *_sp;

	_ammount = unsignedLongAt(GIV(stackPointer));
	if (!(((_ammount & 7) == 1))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			return;
		}
	}
	{
		_segSize = growOldSpaceByAtLeastcallingOperation(_ammount >> 3, "primitiveGrowMemoryByAtLeast - requested by the image");
		if (_segSize == null) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrNoMemory;
			/* end primitiveFailFor: */
		} else {
			/* begin pop:thenPushInteger: */
			unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((((usqInt) _segSize ) << 3) | 1));
			GIV(stackPointer) = _sp;
			/* end pop:thenPushInteger: */
		}
	}
}
/*	Implement 28-bit hashMultiply for SmallInteger and LargePositiveInteger 
	receivers.  */
/* InterpreterPrimitives>>#primitiveHashMultiply */
static void
primitiveHashMultiply(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _ccIndex;
	sqInt _classOop;
	sqInt _ok;
	char *_sp;
	sqInt _value;

	_value = unsignedLongAt(GIV(stackPointer));
	if (((_value & 7) == 1)) {
		_value = _value >> 3;
	} else {
		/* begin is:instanceOf:compactClassIndex: */
		_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
		if (_value & (tagMask())) {
			_ok = 0;
			goto l4;
		}
		/* begin isClassOfNonImm:equalTo:compactClassIndex: */
		assert(!(isImmediate(_value)));
		/* begin classIndexOf: */
		_ccIndex = (longAt(_value)) & (classIndexMask());
		/* end classIndexOf: */
		{
			_ok = ClassLargePositiveIntegerCompactIndex == _ccIndex;
			goto l4;
		}
		/* end isClassOfNonImm:equalTo:compactClassIndex: */
		l4:
		;
		/* end is:instanceOf:compactClassIndex: */
		if (!_ok) {
			{
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadReceiver;
				/* end primitiveFailFor: */
				return;
			}
		}
		_value = SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_value + BaseHeaderSize) + (0U << 2)));
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), ((((usqInt) ((_value * HashMultiplyConstant) & 0xFFFFFFF) ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Answer the heartbeat frequency in beats per second. If the argument is 
	true, reset the frequency measure. */
/* InterpreterPrimitives>>#primitiveHeartbeatFrequency */
EXPORT(sqInt)
primitiveHeartbeatFrequency(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	unsigned int _integerValue;
	sqInt _oop;
	sqInt _reset;
	char *_sp;

	_reset = (GIV(argumentCount) == 1) && ((unsignedLongAt(GIV(stackPointer))) == GIV(trueObj));
	/* begin pop:thenPush: */
	/* begin positive32BitIntegerFor: */
	_integerValue = ((unsigned int) (ioHeartbeatFrequency(_reset)) );
	{
		_oop = (((((usqInt) _integerValue ) & 0xFFFFFFFFU) << 3) | 1);
		goto l2;
	}
	l2:
	;
	/* end positive32BitIntegerFor: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	return 0;
}
/*	Return the value of the high resolution clock if this system has any. The 
	exact frequency of the high res clock is undefined specifically so that we 
	can use processor dependent instructions (like RDTSC). The only use for 
	the high res clock is for profiling where we can allocate time based on 
	sub-msec resolution of the high res clock. If no high-resolution counter 
	is available, the platform should return zero. */
/* InterpreterPrimitives>>#primitiveHighResClock */
EXPORT(sqInt)
primitiveHighResClock(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _object;
	char *_sp;

	/* begin pop: */
	GIV(stackPointer) += 1 * BytesPerWord;
	/* end pop: */
	/* begin push: */
	_object = positive64BitIntegerFor(ioHighResClock());
	unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
	GIV(stackPointer) = _sp;
	/* end push: */
	return 0;
}
/*	is the receiver/first argument the same object as the (last) argument?. 
	pop argumentCount because this can be used as a mirror primitive. */
/* InterpreterPrimitives>>#primitiveIdentical */
static void
primitiveIdentical(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _otherObject;
	char *_sp;
	sqInt _thisObject;

	_otherObject = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_thisObject = unsignedLongAt(GIV(stackPointer));
	if ((((_otherObject & (tagMask())) == 0) && (((long64At(_otherObject)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) || ((GIV(argumentCount) > 1) && (((_thisObject & (tagMask())) == 0) && (((long64At(_thisObject)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		/* end primitiveFailFor: */
	} else {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((_thisObject == _otherObject)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	}
}
/* InterpreterPrimitives>>#primitiveIdentityHash */
static void
primitiveIdentityHash(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _hash;
	sqInt _hash2;
	sqInt _integerVal;
	char *_sp;
	sqInt _thisReceiver;

	_thisReceiver = unsignedLongAt(GIV(stackPointer));
	if ((_thisReceiver & (tagMask())) || ((GIV(argumentCount) > 0) && (((long64At(_thisReceiver)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	} else {
		/* begin pop:thenPushInteger: */
		/* begin hashBitsOf: */
		_hash = (uint32AtPointer(_thisReceiver + 4)) & (identityHashHalfWordMask());
		if (_hash == 0) {
			/* begin newHashBitsOf: */
			_hash2 = (newObjectHash()) & (identityHashHalfWordMask());
			/* begin setHashBitsOf:to: */
			assert((_hash2 >= 0) && (_hash2 <= (identityHashHalfWordMask())));
			uint32AtPointerput(_thisReceiver + 4, (((uint32AtPointer(_thisReceiver + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + _hash2);
			/* end setHashBitsOf:to: */
			_hash = _hash2;
			/* end newHashBitsOf: */
		}
		_integerVal = _hash;
		/* end hashBitsOf: */
		unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _integerVal ) << 3) | 1));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushInteger: */
	}
}
/*	Answer an integer identifying the type of image. The image version number 
	may identify the format of the image (e.g. 32 or 64-bit word size) or 
	specific requirements 
	of the image (e.g. block closure support required). 
	 
	This is a named (not numbered) primitive in the null module (ie the VM) */
/* InterpreterPrimitives>>#primitiveImageFormatVersion */
EXPORT(sqInt)
primitiveImageFormatVersion(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _oop;
	char *_sp;

	/* begin pop:thenPush: */
	/* begin positive32BitIntegerFor: */
	{
		_oop = (((((usqInt) 68021 ) & 0xFFFFFFFFU) << 3) | 1);
		goto l2;
	}
	l2:
	;
	/* end positive32BitIntegerFor: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	return 0;
}
/*	When called with a single string argument, record the string as the 
	current image file name. When called with zero arguments, return a string 
	containing the current image file name. */
/* InterpreterPrimitives>>#primitiveImageName */
static void
primitiveImageName(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classObj;
	sqInt _classOop;
	sqInt _ok;
	sqInt _okToRename;
	sqInt _s;
	void *_sCRIfn;
	char *_sp;
	sqInt _sz;

	if (GIV(argumentCount) == 1) {
		_sCRIfn = ioLoadFunctionFrom("secCanRenameImage", "SecurityPlugin");
		if (_sCRIfn != 0) {
			_okToRename = ((sqInt (*)(void))_sCRIfn)();
			if (!_okToRename) {
				{
					/* begin primitiveFail */
					if (!GIV(primFailCode)) {
						GIV(primFailCode) = 1;
					}
					/* end primitiveFail */
					return;
				}
			}
		}
		_s = unsignedLongAt(GIV(stackPointer));
		/* begin assertClassOf:is: */
		_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteString ) << (shiftForWord())) ));
		/* begin isNonImmediate: */
		_ok = (_s & (tagMask())) == 0;
		/* end isNonImmediate: */
		if (_ok) {
			/* begin isClassOfNonImm:equalTo: */
			assert(isNonImmediate(_s));
			_ok = ((longAt(_s)) & (classIndexMask())) == ((uint32AtPointer(_classOop + 4)) & (identityHashHalfWordMask()));
			/* end isClassOfNonImm:equalTo: */
		}
		/* begin success: */
		if (!_ok) {
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
		}
		/* end success: */
		/* end assertClassOf:is: */
		if (!GIV(primFailCode)) {
			_sz = stSizeOf(_s);
			imageNamePutLength(_s + BaseHeaderSize, _sz);
			/* begin pop: */
			GIV(stackPointer) += 1 * BytesPerWord;
			/* end pop: */
		}
	} else {
		_sz = imageNameSize();
		/* begin instantiateClass:indexableSize: */
		_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteString ) << (shiftForWord())) ));
		_s = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, _sz, 0, 0);
		/* end instantiateClass:indexableSize: */
		imageNameGetLength(_s + BaseHeaderSize, _sz);
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), _s);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/*	For a SmallInteger, answer itself. 
	For a Character, answer its code as an unsigned integer. 
	For a SmallFloat, answer the signed, but unadjusted bit pattern (so as to 
	keep the result a SmallInteger). 
	This is a good value for an immediate's hash. */
/* InterpreterPrimitives>>#primitiveImmediateAsInteger */
static void
primitiveImmediateAsInteger(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _oop;
	char *_sp;
	usqInt _value;

	_value = 0;
	_oop = unsignedLongAt(GIV(stackPointer));
	if (((_oop & 7) == 1)) {
		_value = _oop >> 3;
	} else {
		if (_oop & (characterTag())) {
			_value = ((usqInt) ((usqInt) _oop ) ) >> (numTagBits());
		} else {
			if (_oop & (smallFloatTag())) {
				{
					assert(isImmediateFloat(_oop));
					_value = (((usqInt) ((usqInt) _oop ) ) >> ((numTagBits()) + 1)) + (((_oop & (1U << (numTagBits())))
						 ? ((usqInt) -1 ) << ((64 - (numTagBits())) - 1)
						 : 0));
				}
			} else {
				{
					/* begin primitiveFailFor: */
					GIV(primFailCode) = PrimErrBadReceiver;
					/* end primitiveFailFor: */
					return;
				}
			}
		}
	}
	/* begin pop:thenPushInteger: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((_value << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPushInteger: */
}
/*	Answer the signed integer element of a pure bits receiver. 
	If the receiver is indexable pointers simply function like at:. 
	Favour bits access over pointer access (normal at: being available). */
/* InterpreterPrimitives>>#primitiveIntegerAt */
static void
primitiveIntegerAt(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classFormat;
	sqInt _classPointer;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	sqInt _numFixed;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _oop;
	sqInt _oop3;
	sqInt _oop4;
	sqInt _rcvr;
	char *_sp;
	char *_sp3;
	char *_sp4;
	char *_sp5;
	char *_sp6;
	char *_sp7;
	sqInt _value;

	_index = unsignedLongAt(GIV(stackPointer));
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (!(((_index & 7) == 1))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			return;
		}
	}
	if (_rcvr & (tagMask())) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadReceiver;
			/* end primitiveFailFor: */
			return;
		}
	}
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	_index = (_index >> 3) - 1;
	if (_fmt >= (firstByteFormat())) {
		if (_fmt >= (firstCompiledMethodFormat())) {
			{
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrUnsupported;
				/* end primitiveFailFor: */
				return;
			}
		}
		/* begin numBytesOfBytes: */
		_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
		assert(_fmt2 >= (firstByteFormat()));
		_numSlots = ((numSlotsOf(_rcvr)) << (shiftForWord())) - (_fmt2 & 7);
		/* end numBytesOfBytes: */
		if (((usqInt) _index ) < _numSlots) {
			_value = byteAt((_rcvr + BaseHeaderSize) + _index);
			if (_value > 0x7F) {
				_value -= 256;
			}
			/* begin methodReturnInteger: */
			/* begin pop:thenPushInteger: */
			unsignedLongAtput((_sp5 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _value ) << 3) | 1));
			GIV(stackPointer) = _sp5;
			/* end pop:thenPushInteger: */
			/* end methodReturnInteger: */
			{
				return;
			}
		}
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadIndex;
			/* end primitiveFailFor: */
			return;
		}
	}
	if (_fmt >= (firstShortFormat())) {
		_numSlots = ((usqInt) (numBytesOf(_rcvr)) ) >> 1;
		if (((usqInt) _index ) < _numSlots) {
			_value = shortAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << 1) ));
			if (_value > 0x7FFF) {
				_value -= 65536;
			}
			/* begin methodReturnInteger: */
			/* begin pop:thenPushInteger: */
			unsignedLongAtput((_sp6 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _value ) << 3) | 1));
			GIV(stackPointer) = _sp6;
			/* end pop:thenPushInteger: */
			/* end methodReturnInteger: */
			{
				return;
			}
		}
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadIndex;
			/* end primitiveFailFor: */
			return;
		}
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		_numSlots = ((usqInt) (numBytesOf(_rcvr)) ) >> 3;
		if (((usqInt) _index ) < _numSlots) {
			/* begin methodReturnValue: */
			_oop = signed64BitIntegerFor(long64At((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << 3) )));
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
			/* end methodReturnValue: */
			{
				return;
			}
		}
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadIndex;
			/* end primitiveFailFor: */
			return;
		}
	}
	if (_fmt >= (firstLongFormat())) {
		_numSlots = ((usqInt) (numBytesOf(_rcvr)) ) >> 2;
		if (((usqInt) _index ) < _numSlots) {
			{
				_value = long32At((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << 2) ));
				if (_value > 0x7FFFFFFF) {
					_value -= 0x100000000LL;
				}
				/* begin methodReturnInteger: */
				/* begin pop:thenPushInteger: */
				unsignedLongAtput((_sp7 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _value ) << 3) | 1));
				GIV(stackPointer) = _sp7;
				/* end pop:thenPushInteger: */
				/* end methodReturnInteger: */
			}
			{
				return;
			}
		}
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadIndex;
			/* end primitiveFailFor: */
			return;
		}
	}
	if ((_fmt <= 5) && ((_fmt >= 2) && ((_fmt <= (weakArrayFormat())) || (_fmt >= (sixtyFourBitIndexableFormat()))))) {
		/* begin numSlotsOf: */
		assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
		_numSlots2 = byteAt(_rcvr + 7);
		_numSlots = ((_numSlots2 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots2);
		/* end numSlotsOf: */
		if (_fmt == 2) {
			if (((usqInt) _index ) < _numSlots) {
				/* begin methodReturnValue: */
				_oop3 = unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
				/* begin pop:thenPush: */
				unsignedLongAtput((_sp3 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop3);
				GIV(stackPointer) = _sp3;
				/* end pop:thenPush: */
				/* end methodReturnValue: */
				{
					return;
				}
			}
		}
		/* begin fixedFieldsOfClassFormat: */
		/* begin formatOfClass: */
		_classPointer = fetchClassOfNonImm(_rcvr);
		_classFormat = (unsignedLongAt((_classPointer + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
		/* end formatOfClass: */
		_numFixed = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
		/* end fixedFieldsOfClassFormat: */
		if (((_index + 1) >= _numFixed) && ((_index + 1) <= _numSlots)) {
			/* begin methodReturnValue: */
			_oop4 = unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (_index + _numFixed) ) << (shiftForWord())) ));
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp4 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop4);
			GIV(stackPointer) = _sp4;
			/* end pop:thenPush: */
			/* end methodReturnValue: */
			{
				return;
			}
		}
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadIndex;
			/* end primitiveFailFor: */
			return;
		}
	}
	{
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadReceiver;
		/* end primitiveFailFor: */
		return;
	}
}
/*	Assign an indexable variable of a pure bits receiver with a signed 
	integer. If the receiver is indexable pointers simply function like 
	at:put: primitive 61. 
	Favour bits access over pointer access (normal at:put: being available). */
/* InterpreterPrimitives>>#primitiveIntegerAtPut */
static void
primitiveIntegerAtPut(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classFormat;
	sqInt _classPointer;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	sqInt _numFixed;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _rcvr;
	char *_sp;
	char *_sp2;
	char *_sp3;
	char *_sp4;
	char *_sp5;
	char *_sp6;
	sqLong _value;
	sqInt _valueOop;

	_valueOop = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	_value = signed64BitValueOf(_valueOop);
	if (!(!GIV(primFailCode) && (((_index & 7) == 1)))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			return;
		}
	}
	if (_rcvr & (tagMask())) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadReceiver;
			/* end primitiveFailFor: */
			return;
		}
	}
	if (
#    if IMMUTABILITY
			(/* begin isImmutable: */ ((((usqInt) (longAt(_rcvr)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#    else /* IMMUTABILITY */
			0
#    endif /* IMMUTABILITY */
			) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrNoModification;
			/* end primitiveFailFor: */
			return;
		}
	}
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	_index = (_index >> 3) - 1;
	if (_fmt >= (firstByteFormat())) {
		if (_fmt >= (firstCompiledMethodFormat())) {
			{
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrUnsupported;
				/* end primitiveFailFor: */
				return;
			}
		}
		if (!(((usqInt) ((((sqLong) _value ) >> 7) + 1) ) <= 1)) {
			{
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				/* end primitiveFailFor: */
				return;
			}
		}
		/* begin numBytesOfBytes: */
		_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
		assert(_fmt2 >= (firstByteFormat()));
		_numSlots = ((numSlotsOf(_rcvr)) << (shiftForWord())) - (_fmt2 & 7);
		/* end numBytesOfBytes: */
		if (((usqInt) _index ) < _numSlots) {
			byteAtput((_rcvr + BaseHeaderSize) + _index, _value);
			/* begin methodReturnValue: */
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueOop);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
			/* end methodReturnValue: */
			{
				return;
			}
		}
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadIndex;
			/* end primitiveFailFor: */
			return;
		}
	}
	if (_fmt >= (firstShortFormat())) {
		if (!(((usqInt) ((((sqLong) _value ) >> 15) + 1) ) <= 1)) {
			{
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				/* end primitiveFailFor: */
				return;
			}
		}
		_numSlots = ((usqInt) (numBytesOf(_rcvr)) ) >> 1;
		if (((usqInt) _index ) < _numSlots) {
			shortAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << 1) ), _value);
			/* begin methodReturnValue: */
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp2 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueOop);
			GIV(stackPointer) = _sp2;
			/* end pop:thenPush: */
			/* end methodReturnValue: */
			{
				return;
			}
		}
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadIndex;
			/* end primitiveFailFor: */
			return;
		}
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		_numSlots = ((usqInt) (numBytesOf(_rcvr)) ) >> 3;
		if (((usqInt) _index ) < _numSlots) {
			long64Atput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << 3) ), _value);
			/* begin methodReturnValue: */
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp3 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueOop);
			GIV(stackPointer) = _sp3;
			/* end pop:thenPush: */
			/* end methodReturnValue: */
			{
				return;
			}
		}
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadIndex;
			/* end primitiveFailFor: */
			return;
		}
	}
	if (_fmt >= (firstLongFormat())) {
		if (!(((usqInt) ((((sqLong) _value ) >> 31) + 1) ) <= 1)) {
			{
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				/* end primitiveFailFor: */
				return;
			}
		}
		_numSlots = ((usqInt) (numBytesOf(_rcvr)) ) >> 2;
		if (((usqInt) _index ) < _numSlots) {
			uint32AtPointerput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << 2) ), _value);
			/* begin methodReturnValue: */
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp4 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueOop);
			GIV(stackPointer) = _sp4;
			/* end pop:thenPush: */
			/* end methodReturnValue: */
			{
				return;
			}
		}
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadIndex;
			/* end primitiveFailFor: */
			return;
		}
	}
	if ((_fmt <= 5) && ((_fmt >= 2) && ((_fmt <= (weakArrayFormat())) || (_fmt >= (sixtyFourBitIndexableFormat()))))) {
		/* begin numSlotsOf: */
		assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
		_numSlots2 = byteAt(_rcvr + 7);
		_numSlots = ((_numSlots2 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots2);
		/* end numSlotsOf: */
		if (_fmt == 2) {
			if (((usqInt) _index ) < _numSlots) {
				/* begin storePointer:ofObject:withValue: */
				assert(!(isForwarded(_rcvr)));
				if (((_rcvr & (tagMask())) == 0) && ((_rcvr & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
					if (((_valueOop & (tagMask())) == 0) && (((_valueOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_valueOop >= ((GIV(memoryMap)->newSpaceStart))))) {
						/* begin possibleOldObjectStoreInto: */
						if (!(((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0)) {
							remember(GIV(fromOldSpaceRememberedSet), _rcvr);
						}
						/* end possibleOldObjectStoreInto: */
					}
				}
				/* begin possiblePermObjectStoreInto:value: */
				if (((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0) {
					goto l23;
				}
				if (_valueOop & (tagMask())) {
					goto l23;
				}
				if (!(_rcvr >= 0x20000000000LL)) {
					goto l23;
				}
				if (_valueOop >= 0x20000000000LL) {
					goto l23;
				}
				if ((_valueOop >= GIV(nilObj)) && (_valueOop <= GIV(trueObj))) {
					goto l23;
				}
				if (!(_valueOop >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l23;
				}
				remember(getFromPermToNewSpaceRememberedSet(), _rcvr);
				l23:
				;
				/* end possiblePermObjectStoreInto:value: */
				unsignedLongAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ), _valueOop);
				/* end storePointer:ofObject:withValue: */
				/* begin methodReturnValue: */
				/* begin pop:thenPush: */
				unsignedLongAtput((_sp5 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueOop);
				GIV(stackPointer) = _sp5;
				/* end pop:thenPush: */
				/* end methodReturnValue: */
				{
					return;
				}
			}
		}
		/* begin fixedFieldsOfClassFormat: */
		/* begin formatOfClass: */
		_classPointer = fetchClassOfNonImm(_rcvr);
		_classFormat = (unsignedLongAt((_classPointer + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
		/* end formatOfClass: */
		_numFixed = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
		/* end fixedFieldsOfClassFormat: */
		if (((_index + 1) >= _numFixed) && ((_index + 1) <= _numSlots)) {
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(_rcvr)));
			if (((_rcvr & (tagMask())) == 0) && ((_rcvr & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((_valueOop & (tagMask())) == 0) && (((_valueOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_valueOop >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), _rcvr);
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l26;
			}
			if (_valueOop & (tagMask())) {
				goto l26;
			}
			if (!(_rcvr >= 0x20000000000LL)) {
				goto l26;
			}
			if (_valueOop >= 0x20000000000LL) {
				goto l26;
			}
			if ((_valueOop >= GIV(nilObj)) && (_valueOop <= GIV(trueObj))) {
				goto l26;
			}
			if (!(_valueOop >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l26;
			}
			remember(getFromPermToNewSpaceRememberedSet(), _rcvr);
			l26:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (_index + _numFixed) ) << (shiftForWord())) ), _valueOop);
			/* end storePointer:ofObject:withValue: */
			/* begin methodReturnValue: */
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp6 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueOop);
			GIV(stackPointer) = _sp6;
			/* end pop:thenPush: */
			/* end methodReturnValue: */
			{
				return;
			}
		}
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadIndex;
			/* end primitiveFailFor: */
			return;
		}
	}
	{
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadReceiver;
		/* end primitiveFailFor: */
		return;
	}
}
/*	Primitive. Answer the number of interrupt checks per milliseconds that we 
	execute on this machine. This can be used to adjust the sub-msecs profiler 
	to check (roughly)  
	n times per millisecond. */
/* InterpreterPrimitives>>#primitiveInterruptChecksPerMSec */
EXPORT(sqInt)
primitiveInterruptChecksPerMSec(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _oop;
	char *_sp;

	if (!(GIV(argumentCount) == 0)) {
		/* begin success: */
		{
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
		}
		return null;
		/* end success: */
	}
	/* begin pop:thenPush: */
	_oop = ((((usqInt) (ioHeartbeatMilliseconds()) ) << 3) | 1);
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	return 0;
}
/*	Primitive. 'Invoke' an object like a function, sending the special message 
	run: originalSelector with: arguments in: aReceiver. 
	 */
/* InterpreterPrimitives>>#primitiveInvokeObjectAsMethod */
static void
primitiveInvokeObjectAsMethod(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _inInterpreter;
	sqInt _lookupClassTag;
	sqInt _methodHeader;
	sqInt _nArgs;
	sqInt _runArgs;
	sqInt _runReceiver;
	char *_savedFramePointer;
	char *_savedStackPointer;
	char *_sp;
	char *_sp2;
	char *_sp3;
	char *_sp4;
	sqInt _succeeded;
	sqInt _tagBits;
	sqInt _top;
	sqInt _top2;
	sqInt _valuePointer;

	/* begin eeInstantiateClassIndex:format:numSlots: */
	assert((GIV(argumentCount) >= 0) && ((knownClassAtIndex(ClassArrayCompactIndex)) != GIV(nilObj)));
	_nArgs = 0;
	_savedFramePointer = ((char *) 0 );
	_savedStackPointer = ((char *) 0 );
	assert(2 == (instSpecOfClass(knownClassAtIndex(ClassArrayCompactIndex))));
	_runArgs = allocateNewSpaceSlotsformatclassIndex(GIV(argumentCount), 2, ClassArrayCompactIndex);
	/* end eeInstantiateClassIndex:format:numSlots: */
	for (_i = GIV(argumentCount) - 1; _i >= 0; _i += -1) {
		/* begin storePointerUnchecked:ofObject:withValue: */
		/* begin popStack */
		_top2 = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		_valuePointer = _top2;
		/* end popStack */
		assert(!(isOopForwarded(_runArgs)));
		longAtput((_runArgs + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _valuePointer);
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	/* begin popStack */
	_top = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	_runReceiver = _top;
	/* end popStack */
	/* begin push: */
	unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), GIV(newMethod));
	GIV(stackPointer) = _sp;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), GIV(messageSelector));
	GIV(stackPointer) = _sp2;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), _runArgs);
	GIV(stackPointer) = _sp3;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp4 = GIV(stackPointer) - BytesPerWord), _runReceiver);
	GIV(stackPointer) = _sp4;
	/* end push: */
	/* begin fetchPointer:ofObject: */
	GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorRunWithIn ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	GIV(argumentCount) = 3;
	if (((_tagBits = GIV(newMethod) & (tagMask()))) != 0) {
		_lookupClassTag = _tagBits;
	} else {
		/* begin classIndexOf: */
		_lookupClassTag = (longAt(GIV(newMethod))) & (classIndexMask());
		/* end classIndexOf: */
	}
	findNewMethodInClassTag(_lookupClassTag);
	/* begin executeNewMethod */
	/* begin executeNewMethod: */
	_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	/* begin executePrimitiveFromInterpreter:ifFail: */
	if (primitiveFunctionPointer != 0) {
		if (((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex) {
			executeQuickPrimitive();
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), _inInterpreter);
			/* end returnToExecutive: */
			goto l12;
		}
		/* begin slowPrimitiveResponse */
		if (recordPrimTrace()) {
			/* begin fastLogPrim: */
			GIV(primTraceLog)[GIV(primTraceLogIndex)] = GIV(messageSelector);
			primTraceLogIndex(GIV(primTraceLogIndex) + 1);
			/* end fastLogPrim: */
		}
		assert((remapBufferCount()) == 0);
		{
			_nArgs = GIV(argumentCount);
			_savedStackPointer = GIV(stackPointer);
			_savedFramePointer = GIV(framePointer);
		}
		/* begin initPrimCall */
		GIV(primFailCode) = 0;
		/* end initPrimCall */
		/* begin dispatchFunctionPointer: */
		primitiveFunctionPointer();
		/* end dispatchFunctionPointer: */
		assert(maybeLeakCheckExternalPrimCall(GIV(newMethod)));
		/* begin maybeRetryPrimitiveOnFailure */
		if (GIV(primFailCode)) {
			retryPrimitiveOnFailure();
		}
		/* end maybeRetryPrimitiveOnFailure */
		/* begin maybeFailForLastObjectOverwrite */
		if (checkAllocFiller) {
			if (((freeStart0()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart0())) != (freeStart0()))) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrWritePastObject;
				/* end primitiveFailFor: */
			}
		}
		/* end maybeFailForLastObjectOverwrite */
		if (!GIV(primFailCode) && ((GIV(framePointer) == _savedFramePointer) && (!(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))))) {
			if (GIV(stackPointer) != (_savedStackPointer + (_nArgs * BytesPerWord))) {
				flag("Would be nice to make this a message send of e.g. unbalancedPrimitive to the current process or context");
				failUnbalancedPrimitive();
				GIV(stackPointer) = _savedStackPointer;
			}
		}
		if (GIV(nextProfileTick) > 0) {
			checkProfileTick(GIV(newMethod));
		}
		_succeeded = !GIV(primFailCode);
		goto l8;
		l8:
		;
		/* end slowPrimitiveResponse */
		if (_succeeded) {
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), _inInterpreter);
			/* end returnToExecutive: */
			goto l12;
		}
	}
	{
		{
			/* begin fetchPointer:ofObject: */
			_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (!((assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0))) {
				if (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
					cogselector(GIV(newMethod), GIV(nilObj));
					/* begin fetchPointer:ofObject: */
					_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
				} else {
					maybeFlagMethodAsInterpreted(GIV(newMethod));
				}
			}
		}
		activateNewMethod();
	}
	l12:
	;
	/* end executePrimitiveFromInterpreter:ifFail: */
	/* end executeNewMethod: */
	/* end executeNewMethod */
	/* begin initPrimCall */
	GIV(primFailCode) = 0;
	/* end initPrimCall */
}
/*	Answer if running on a big endian machine. */
/* InterpreterPrimitives>>#primitiveIsBigEnder */
EXPORT(sqInt)
primitiveIsBigEnder(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_sp;

	/* begin pop:thenPushBool: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), ((VMBIGENDIAN)
		 ? GIV(trueObj)
		 : GIV(falseObj)));
	GIV(stackPointer) = _sp;
	/* end pop:thenPushBool: */
	return 0;
}
/*	Answer if the receiver is pinned, i.e. immobile. */
/* InterpreterPrimitives>>#primitiveIsPinned */
static void
primitiveIsPinned(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _obj;
	char *_sp;
	sqInt _trueOrFalse;

	_obj = unsignedLongAt(GIV(stackPointer));
	if ((_obj & (tagMask())) || (((long64At(_obj)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadReceiver;
			/* end primitiveFailFor: */
			return;
		}
	}
	/* begin pop:thenPushBool: */
	_trueOrFalse = ((((usqInt) (longAt(_obj)) ) >> (pinnedBitShift())) & 1) != 0;
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((_trueOrFalse)
		 ? GIV(trueObj)
		 : GIV(falseObj)));
	GIV(stackPointer) = _sp;
	/* end pop:thenPushBool: */
}
/* InterpreterPrimitives>>#primitiveLessOrEqual */
static void
primitiveLessOrEqual(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerArgument;
	sqInt _integerReceiver;
	char *_sp;

	_integerArgument = unsignedLongAt(GIV(stackPointer));
	_integerReceiver = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if ((_integerReceiver & _integerArgument) & (smallIntegerTag())) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_integerReceiver <= _integerArgument)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	}
}
/*	Primitive comparison operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveLessOrEqualLargeIntegers */
EXPORT(void)
primitiveLessOrEqualLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqLong _integerArg;
	sqLong _integerRcvr;
	char *_sp;

	_integerArg = signed64BitValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	_integerRcvr = signed64BitValueOf(unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord)));
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_integerRcvr <= _integerArg)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	}
}
/* InterpreterPrimitives>>#primitiveLessThan */
static void
primitiveLessThan(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerArgument;
	sqInt _integerReceiver;
	char *_sp;

	_integerArgument = unsignedLongAt(GIV(stackPointer));
	_integerReceiver = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if ((_integerReceiver & _integerArgument) & (smallIntegerTag())) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_integerReceiver < _integerArgument)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	}
}
/*	Primitive comparison operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveLessThanLargeIntegers */
EXPORT(void)
primitiveLessThanLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqLong _integerArg;
	sqLong _integerRcvr;
	char *_sp;

	_integerArg = signed64BitValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	_integerRcvr = signed64BitValueOf(unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord)));
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_integerRcvr < _integerArg)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	}
}
/*	Primitive. Return the n-th builtin module name. */
/* InterpreterPrimitives>>#primitiveListBuiltinModule */
static void
primitiveListBuiltinModule(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classObj;
	sqInt _i;
	sqInt _index;
	sqInt _integerPointer;
	sqInt _length;
	char *_moduleName;
	sqInt _nameOop;
	char *_sp;
	char *_sp2;

	if (!(GIV(argumentCount) == 1)) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	/* begin stackIntegerValue: */
	_integerPointer = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_index = _integerPointer >> 3;
		goto l3;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_index = 0;
		goto l3;
	}
	/* end checkedIntegerValueOf: */
	l3:
	;
	/* end stackIntegerValue: */
	if (_index <= 0) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	_moduleName = ioListBuiltinModule(_index);
	if (_moduleName == null) {
		/* begin pop: */
		GIV(stackPointer) += 2 * BytesPerWord;
		/* end pop: */
		{
			/* begin push: */
			unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
			GIV(stackPointer) = _sp;
			/* end push: */
			return;
		}
	}
	_length = strlen(_moduleName);
	/* begin instantiateClass:indexableSize: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteString ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	_nameOop = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, _length, 0, 0);
	/* end instantiateClass:indexableSize: */
	for (_i = 0; _i < _length; _i += 1) {
		byteAtput((_nameOop + BaseHeaderSize) + _i, _moduleName[_i]);
	}
	forceInterruptCheck();
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp2 = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _nameOop);
	GIV(stackPointer) = _sp2;
	/* end pop:thenPush: */
}
/*	Primitive. Return the n-th loaded external module name. */
/* InterpreterPrimitives>>#primitiveListExternalModule */
static void
primitiveListExternalModule(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classObj;
	sqInt _i;
	sqInt _index;
	sqInt _integerPointer;
	sqInt _length;
	char *_moduleName;
	sqInt _nameOop;
	char *_sp;
	char *_sp2;

	if (!(GIV(argumentCount) == 1)) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	/* begin stackIntegerValue: */
	_integerPointer = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_index = _integerPointer >> 3;
		goto l3;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_index = 0;
		goto l3;
	}
	/* end checkedIntegerValueOf: */
	l3:
	;
	/* end stackIntegerValue: */
	if (_index <= 0) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	_moduleName = ioListLoadedModule(_index);
	if (_moduleName == null) {
		/* begin pop: */
		GIV(stackPointer) += 2 * BytesPerWord;
		/* end pop: */
		{
			/* begin push: */
			unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
			GIV(stackPointer) = _sp;
			/* end push: */
			return;
		}
	}
	_length = strlen(_moduleName);
	/* begin instantiateClass:indexableSize: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteString ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	_nameOop = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, _length, 0, 0);
	/* end instantiateClass:indexableSize: */
	for (_i = 0; _i < _length; _i += 1) {
		byteAtput((_nameOop + BaseHeaderSize) + _i, _moduleName[_i]);
	}
	forceInterruptCheck();
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp2 = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _nameOop);
	GIV(stackPointer) = _sp2;
	/* end pop:thenPush: */
}
/*	Return the value of the microsecond clock in the local timezone as an 
	integer. This is the number of microseconds since the Smalltalk epoch, 
	1901/1/1 12:00am. 
	The microsecond clock is at least 60 bits wide which means it'll get to 
	around August 
	38435 before it wraps around. Be sure to put it on your calendar. This 
	primitive accesses the time as answered by the OS. */
/* InterpreterPrimitives>>#primitiveLocalMicrosecondClock */
static void
primitiveLocalMicrosecondClock(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _oop;
	char *_sp;

	/* begin pop:thenPush: */
	_oop = positive64BitIntegerFor(ioLocalMicrosecondsNow());
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Natural log. 
	N.B. IMO we should be able to assume the receiver is a float because this 
	primitive is specific to floats. eem 2/13/2017 */
/* InterpreterPrimitives>>#primitiveLogN */
static void
primitiveLogN(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aValue;
	double _rcvr;

	/* begin stackFloatValue: */
	_rcvr = floatValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	/* end stackFloatValue: */
	if (!GIV(primFailCode)) {
		/* begin stackTopPut: */
		_aValue = floatObjectOf(log(_rcvr));
		unsignedLongAtput(GIV(stackPointer), _aValue);
		/* end stackTopPut: */
	}
}
/*	Register the low-space semaphore. If the argument is not a  
	Semaphore, unregister the current low-space Semaphore. */
/* InterpreterPrimitives>>#primitiveLowSpaceSemaphore */
static void
primitiveLowSpaceSemaphore(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _arg;

	_arg = unsignedLongAt(GIV(stackPointer));
	if ((_arg == GIV(nilObj)) || (((_arg & (tagMask())) == 0) && (((longAt(_arg)) & (classIndexMask())) == (rawHashBitsOf(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassSemaphore ) << (shiftForWord())) ))))))) {
		/* begin splObj:put: */
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(GIV(specialObjectsOop))));
		if (((GIV(specialObjectsOop) & (tagMask())) == 0) && ((GIV(specialObjectsOop) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_arg & (tagMask())) == 0) && (((_arg & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_arg >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), GIV(specialObjectsOop));
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l5;
		}
		if (_arg & (tagMask())) {
			goto l5;
		}
		if (!(GIV(specialObjectsOop) >= 0x20000000000LL)) {
			goto l5;
		}
		if (_arg >= 0x20000000000LL) {
			goto l5;
		}
		if ((_arg >= GIV(nilObj)) && (_arg <= GIV(trueObj))) {
			goto l5;
		}
		if (!(_arg >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l5;
		}
		remember(getFromPermToNewSpaceRememberedSet(), GIV(specialObjectsOop));
		l5:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) TheLowSpaceSemaphore ) << (shiftForWord())) ), _arg);
		/* end storePointer:ofObject:withValue: */
		/* end splObj:put: */
		/* begin pop: */
		GIV(stackPointer) += 1 * BytesPerWord;
		/* end pop: */
	} else {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		/* end primitiveFailFor: */
	}
}
/* InterpreterPrimitives>>#primitiveMakePoint */
static void
primitiveMakePoint(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _arg;
	sqInt _classFormat;
	sqInt _classIndex;
	sqInt _classObj;
	usqInt _newObj;
	usqInt _numBytes;
	sqInt _numSlots;
	sqInt _objFormat;
	usqInt _pt;
	sqInt _rcvr;
	char *_sp;

	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_arg = unsignedLongAt(GIV(stackPointer));
	if (!(((_arg & (tagMask()))
		 ? !(_arg & (characterTag()))
		 : ((longAt(_arg)) & (classIndexMask())) == ClassFloatCompactIndex))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			return;
		}
	}
	/* begin eeInstantiateSmallClass:numSlots: */
	_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassPoint ) << (shiftForWord())) ));
	_numSlots = YIndex + 1;
	assert((rawHashBitsOf(_classObj)) != 0);
	/* begin eeInstantiateSmallClassIndex:format:numSlots: */
	_classIndex = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask());
	/* begin instSpecOfClassFormat: */
	_classFormat = (unsignedLongAt((_classObj + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	_objFormat = (((usqInt) _classFormat ) >> (fixedFieldsFieldWidth())) & (formatMask());
	/* end instSpecOfClassFormat: */
	assert((_numSlots >= 0) && ((_classIndex != 0) && ((classAtIndex(_classIndex)) != GIV(nilObj))));
	assert((((_objFormat < (firstByteFormat()))
		 ? _objFormat
		 : _objFormat & (byteFormatMask()))) == (instSpecOfClass(classAtIndex(_classIndex))));
	/* begin allocateSmallNewSpaceSlots:format:classIndex: */
	assert(_numSlots < (numSlotsMask()));
	_newObj = GIV(freeStart);
	_numBytes = BaseHeaderSize + (((_numSlots < 1)
		 ? 8
		 : _numSlots * BytesPerOop));
	assert((_numBytes % (allocationUnit())) == 0);
	assert((_newObj % (allocationUnit())) == 0);
	if ((GIV(freeStart) + _numBytes) > GIV(scavengeThreshold)) {
		if (!GIV(needGCFlag)) {
			/* begin scheduleScavenge */
			GIV(needGCFlag) = 1;
			forceInterruptCheck();
			/* end scheduleScavenge */
		}
		if ((GIV(freeStart) + _numBytes) > (((eden()).limit))) {
			error("no room in eden for allocateSmallNewSpaceSlots:format:classIndex:");
			_pt = 0;
			goto l3;
		}
	}
	long64Atput(_newObj, ((((usqLong) _numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) _objFormat ) << (formatShift())) )) + _classIndex);
	GIV(freeStart) += _numBytes;
	_pt = _newObj;
	/* end allocateSmallNewSpaceSlots:format:classIndex: */
	/* end eeInstantiateSmallClassIndex:format:numSlots: */
	l3:
	;
	/* end eeInstantiateSmallClass:numSlots: */
	{
		{
			assert(!(isOopForwarded(_pt)));
			longAtput((_pt + BaseHeaderSize) + ((sqInt) (((usqInt) XIndex ) << (shiftForWord())) ), _rcvr);
		}
		{
			assert(!(isOopForwarded(_pt)));
			longAtput((_pt + BaseHeaderSize) + ((sqInt) (((usqInt) YIndex ) << (shiftForWord())) ), _arg);
		}
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _pt);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* InterpreterPrimitives>>#primitiveMaxIdentityHash */
static void
primitiveMaxIdentityHash(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerVal;
	char *_sp;

	/* begin pop:thenPushInteger: */
	_integerVal = identityHashHalfWordMask();
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), ((((usqInt) _integerVal ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPushInteger: */
}
/*	Return the method an external primitive was defined in */
/* InterpreterPrimitives>>#primitiveMethod */
usqInt
primitiveMethod(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(newMethod);
}
/*	Return the value of the millisecond clock as an integer. Note that the 
	millisecond clock wraps around periodically. On some platforms it can wrap 
	daily. The range is limited to SmallInteger maxVal / 2 to allow delays of 
	up to that length without overflowing a SmallInteger. */
/* InterpreterPrimitives>>#primitiveMillisecondClock */
static void
primitiveMillisecondClock(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _oop;
	char *_sp;

	/* begin pop:thenPush: */
	_oop = ((((usqInt) ((ioMSecs()) & MillisecondClockMask) ) << 3) | 1);
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Provide access to the millisecond clock mask to support calculation 
	of durations based on the millisecond clock value. */
/* InterpreterPrimitives>>#primitiveMillisecondClockMask */
EXPORT(sqInt)
primitiveMillisecondClockMask(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_sp;

	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), ((((usqInt) MillisecondClockMask ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	return 0;
}
/* InterpreterPrimitives>>#primitiveMod */
static void
primitiveMod(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _mod;
	char *_sp;

	_mod = doPrimitiveModby(unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord)), unsignedLongAt(GIV(stackPointer)));
	/* begin pop2AndPushIntegerIfOK: */
	if (!GIV(primFailCode)) {
		if ((((((usqInt) _mod ) >> 60) + 1) & 15) <= 1) {
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((((usqInt) _mod ) << 3) | 1));
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
		} else {
			/* begin success: */
			{
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
			}
			/* end success: */
		}
	}
	/* end pop2AndPushIntegerIfOK: */
}
/*	Primitive arithmetic operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveModLargeIntegers */
EXPORT(void)
primitiveModLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _a;
	sqInt _aIsNegative;
	usqLong _b;
	sqInt _bIsNegative;
	sqInt _oopArg;
	sqInt _oopRcvr;
	sqInt _oopResult;
	usqLong _result;
	char *_sp;

	_oopArg = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	_oopRcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_aIsNegative = isNegativeIntegerValueOf(_oopRcvr);
	_bIsNegative = isNegativeIntegerValueOf(_oopArg);
	_a = magnitude64BitValueOf(_oopRcvr);
	_b = magnitude64BitValueOf(_oopArg);
	if (_b == 0) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	}
	if (GIV(primFailCode)) {
		{
			return;
		}
	}
	_result = _a % _b;
	if (!(_result == 0)) {
		if (!(_bIsNegative == _aIsNegative)) {
			_result = _b - _result;
		}
	}
	_oopResult = magnitude64BitIntegerForneg(_result, _bIsNegative);
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oopResult);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/* InterpreterPrimitives>>#primitiveMultiply */
static void
primitiveMultiply(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerArg;
	sqInt _integerPointer;
	sqInt _integerPointer2;
	sqInt _integerRcvr;
	sqInt _integerResult;
	sqInt _overflow;
	char *_sp;

	/* begin stackIntegerValue: */
	_integerPointer = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_integerRcvr = _integerPointer >> 3;
		goto l2;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerRcvr = 0;
		goto l2;
	}
	/* end checkedIntegerValueOf: */
	l2:
	;
	/* end stackIntegerValue: */
	/* begin stackIntegerValue: */
	_integerPointer2 = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer2 & 7) == 1)) {
		_integerArg = _integerPointer2 >> 3;
		goto l3;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerArg = 0;
		goto l3;
	}
	/* end checkedIntegerValueOf: */
	l3:
	;
	/* end stackIntegerValue: */
	if (!GIV(primFailCode)) {
		if (_integerRcvr > 0) {
			_overflow = ((_integerArg > 0)
				 ? _integerRcvr > (MaxSmallInteger / _integerArg)
				 : _integerArg < (MinSmallInteger / _integerRcvr));
		} else {
			if (_integerArg > 0) {
				_overflow = _integerRcvr < (MinSmallInteger / _integerArg);
			}
 else {
				_overflow = (_integerRcvr < 0) && (_integerArg < (MaxSmallInteger / _integerRcvr));
			}
		}
		if (_overflow) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
		} else {
			_integerResult = _integerRcvr * _integerArg;
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((((usqInt) _integerResult ) << 3) | 1));
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
		}
	}
}
/*	Primitive arithmetic operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveMultiplyLargeIntegers */
EXPORT(void)
primitiveMultiplyLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _a;
	sqInt _aIsNegative;
	usqLong _b;
	sqInt _bIsNegative;
	sqInt _oopArg;
	sqInt _oopRcvr;
	sqInt _oopResult;
	usqLong _result;
	char *_sp;

	_oopArg = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	_oopRcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_aIsNegative = isNegativeIntegerValueOf(_oopRcvr);
	_bIsNegative = isNegativeIntegerValueOf(_oopArg);
	_a = magnitude64BitValueOf(_oopRcvr);
	_b = magnitude64BitValueOf(_oopArg);
	if (GIV(primFailCode)) {
		{
			return;
		}
	}
	if ((_a > 1) && ((_b > 1) && (_a > (0xFFFFFFFFFFFFFFFFULL / _b)))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		{
			return;
		}
	}
	_result = _a * _b;
	_oopResult = magnitude64BitIntegerForneg(_result, _aIsNegative != _bIsNegative);
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oopResult);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/*	Allocate a new fixed-size instance. Fail if the allocation would leave 
	less than lowSpaceThreshold bytes free. This *will not* cause a GC :-) */
/* InterpreterPrimitives>>#primitiveNew */
static void
primitiveNew(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classObj;
	sqInt _obj;
	char *_sp;

	{
		/* begin instantiateClass: */
		_classObj = unsignedLongAt(GIV(stackPointer));
		_obj = instantiateClassisPinnedisOldSpace(_classObj, 0, 0);
		/* end instantiateClass: */
		if (!(_obj == null)) {
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _obj);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
		}
	}
}
/* InterpreterPrimitives>>#primitiveNewMethod */
static void
primitiveNewMethod(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _bytecodeCount;
	sqInt _class;
	sqInt _classFormat;
	sqInt _classIndex;
	sqInt _err;
	sqInt _hash;
	int _hasToScheduleScavenge;
	sqInt _header;
	sqInt _i;
	sqInt _instSpec;
	sqInt _literalCount;
	sqInt _newObj;
	sqInt _newObj2;
	usqInt _numBytes;
	usqInt _numSlots;
	usqInt _p;
	sqInt _reasonCode;
	sqInt _size;
	char *_sp;
	sqInt _theMethod;

	_header = unsignedLongAt(GIV(stackPointer));
	_bytecodeCount = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (!((((_header & 7) == 1)) && ((((_bytecodeCount & 7) == 1)) && (((_bytecodeCount = _bytecodeCount >> 3)) >= 0)))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		/* end primitiveFailFor: */
		return;
	}
	_class = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	{
		assert(((_header & 7) == 1));
		_literalCount = (_header >> 3) & AlternateHeaderNumLiteralsMask;
	}
	_size = ((_literalCount + LiteralStart) * BytesPerOop) + _bytecodeCount;
	/* begin instantiateCompiledMethodClass:indexableSize: */
	_classFormat = (unsignedLongAt((_class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	_instSpec = (((usqInt) _classFormat ) >> (fixedFieldsFieldWidth())) & (formatMask());
	if (_instSpec != (firstCompiledMethodFormat())) {
		_theMethod = null;
		goto l10;
	}
	_numSlots = (_size + 7) / 8;
	_instSpec += (8 - _size) & 7;
	{
		assert(addressCouldBeClassObj(_class));
		_classIndex = ((((_hash = (uint32AtPointer(_class + 4)) & (identityHashHalfWordMask()))) != 0)
			 ? _hash
			 : ((objCouldBeClassObj(_class))
				 ? ((((_err = enterIntoClassTable(_class))) != 0)
					 ? -_err
					 : (/* begin rawHashBitsOf: */ (uint32AtPointer(_class + 4)) & (identityHashHalfWordMask()) /* end rawHashBitsOf: */))
				 : -PrimErrBadReceiver));
	}
	if (_classIndex < 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = -_classIndex;
		/* end primitiveFailFor: */
		_theMethod = null;
		goto l10;
	}
	if (_numSlots > (((GIV(maxSlotsForNewSpaceAlloc) == 0)
		 ? (/* begin fixedFieldsOfClassFormatMask */ (1U << (fixedFieldsFieldWidth())) - 1 /* end fixedFieldsOfClassFormatMask */)
		 : GIV(maxSlotsForNewSpaceAlloc)))) {
		if (_numSlots > 0x10000000000LL) {
			_theMethod = null;
			goto l10;
		}
		_newObj = allocateSlotsInOldSpacebytesformatclassIndex(_numSlots, ((_numSlots == 0)
			 ? 8 + BaseHeaderSize
			 : (_numSlots << (shiftForWord())) + (((_numSlots >= (numSlotsMask()))
				 ? BaseHeaderSize + BaseHeaderSize
				 : BaseHeaderSize))), _instSpec, _classIndex);
	} else {
		/* begin allocateSlots:format:classIndex:isPinned:isOldSpace: */
		if (_numSlots >= (numSlotsMask())) {
			if ((((usqInt) _numSlots ) >> 56) > 0) {
				_newObj = null;
				goto l8;
			}
			_numBytes = (BaseHeaderSize + BaseHeaderSize) + (_numSlots * BytesPerOop);
		} else {
			_numBytes = BaseHeaderSize + (((_numSlots < 1)
				 ? 8
				 : _numSlots * BytesPerOop));
		}
		_hasToScheduleScavenge = (GIV(freeStart) + _numBytes) > GIV(scavengeThreshold);
		if (_hasToScheduleScavenge || 0) {
			if (_hasToScheduleScavenge) {
				if (!GIV(needGCFlag)) {
					/* begin scheduleScavenge */
					GIV(needGCFlag) = 1;
					forceInterruptCheck();
					/* end scheduleScavenge */
				}
			}
			{
				_newObj = allocateSlotsInOldSpacebytesformatclassIndex(_numSlots, _numBytes, _instSpec, _classIndex);
				goto l8;
			}
		}
		_newObj2 = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(GIV(freeStart), _numSlots, _instSpec, _classIndex, 0);
		assert((_numBytes % (allocationUnit())) == 0);
		assert((_newObj2 % (allocationUnit())) == 0);
		GIV(freeStart) += _numBytes;
		_newObj = _newObj2;
		l8:
		;
		/* end allocateSlots:format:classIndex:isPinned:isOldSpace: */
	}
	if (_newObj) {
		/* begin fillObj:numSlots:with: */
		assert(oopisLessThan(((_newObj + BaseHeaderSize) + (_numSlots * BytesPerOop)) - 1, addressAfter(_newObj)));
		for (_p = ((usqInt) (_newObj + BaseHeaderSize) ); _p <= ((usqInt) (((_newObj + BaseHeaderSize) + (_numSlots * BytesPerOop)) - 1) ); _p += 8) {
			longAtput(_p, 0);
		}
		/* end fillObj:numSlots:with: */
	}
	_theMethod = _newObj;
	l10:
	;
	/* end instantiateCompiledMethodClass:indexableSize: */
	if (!_theMethod) {
		/* begin primitiveFailFor: */
		_reasonCode = ((isCompiledMethodFormat(instSpecOfClassFormat((unsignedLongAt((_class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3)))
			 ? PrimErrNoMemory
			 : PrimErrBadReceiver);
		GIV(primFailCode) = _reasonCode;
		/* end primitiveFailFor: */
		return;
	}
	{
		assert(!(isOopForwarded(_theMethod)));
		longAtput((_theMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ), _header);
	}
	for (_i = 1; _i <= _literalCount; _i += 1) {
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_theMethod)));
		if (((_theMethod & (tagMask())) == 0) && ((_theMethod & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((GIV(nilObj) & (tagMask())) == 0) && (((GIV(nilObj) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (GIV(nilObj) >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_theMethod)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _theMethod);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_theMethod)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l4;
		}
		if (GIV(nilObj) & (tagMask())) {
			goto l4;
		}
		if (!(_theMethod >= 0x20000000000LL)) {
			goto l4;
		}
		if (GIV(nilObj) >= 0x20000000000LL) {
			goto l4;
		}
		if ((GIV(nilObj) >= GIV(nilObj)) && (GIV(nilObj) <= GIV(trueObj))) {
			goto l4;
		}
		if (!(GIV(nilObj) >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l4;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _theMethod);
		l4:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_theMethod + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), GIV(nilObj));
		/* end storePointer:ofObject:withValue: */
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((3 - 1) * BytesPerWord)), _theMethod);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Allocate a new pinned fixed-size instance. Fail if the allocation would 
	leave less than lowSpaceThreshold bytes free. This *will not* cause a GC 
	:-)  */
/* InterpreterPrimitives>>#primitiveNewOldSpace */
static void
primitiveNewOldSpace(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _obj;
	sqInt _reasonCode;
	char *_sp;

	{
		_obj = instantiateClassisPinnedisOldSpace(unsignedLongAt(GIV(stackPointer)), 0, 1);
		if (_obj == null) {
			/* begin primitiveFailFor: */
			_reasonCode = ((isFixedSizePointerFormat(instSpecOfClass(unsignedLongAt(GIV(stackPointer)))))
				 ? PrimErrNoMemory
				 : PrimErrBadReceiver);
			GIV(primFailCode) = _reasonCode;
			/* end primitiveFailFor: */
		} else {
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _obj);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
		}
	}
}
/*	Allocate a new pinned fixed-size instance. Fail if the allocation would 
	leave less than lowSpaceThreshold bytes free. This *will not* cause a GC 
	:-)  */
/* InterpreterPrimitives>>#primitiveNewPinned */
static void
primitiveNewPinned(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classObj;
	sqInt _obj;
	sqInt _reasonCode;
	char *_sp;

	{
		/* begin instantiateClass:isPinned: */
		_classObj = unsignedLongAt(GIV(stackPointer));
		_obj = instantiateClassisPinnedisOldSpace(_classObj, 1, 0);
		/* end instantiateClass:isPinned: */
		if (_obj == null) {
			/* begin primitiveFailFor: */
			_reasonCode = ((isFixedSizePointerFormat(instSpecOfClass(unsignedLongAt(GIV(stackPointer)))))
				 ? PrimErrNoMemory
				 : PrimErrBadReceiver);
			GIV(primFailCode) = _reasonCode;
			/* end primitiveFailFor: */
		} else {
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _obj);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
		}
	}
}
/*	Allocate a new indexable instance. Fail if the allocation would leave less 
	than lowSpaceThreshold bytes free. May cause a GC. */
/* InterpreterPrimitives>>#primitiveNewWithArg */
static void
primitiveNewWithArg(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _bs;
	sqInt _ccIndex;
	sqInt _classObj;
	sqInt _classOop;
	sqInt _fmt;
	sqInt _obj;
	sqInt _ok;
	sqInt _oop;
	usqIntptr_t _size;
	char *_sp;
	sqInt _value;

	/* begin positiveMachineIntegerValueOf: */
	_oop = unsignedLongAt(GIV(stackPointer));
	if (((_oop & 7) == 1)) {
		_value = _oop >> 3;
		if (_value < 0) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			_size = null;
			goto l6;
			/* end primitiveFail */
		}
		_size = _value;
		goto l6;
	}
	if (_oop & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_size = 0;
		goto l6;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(_oop)));
	/* begin classIndexOf: */
	_ccIndex = (longAt(_oop)) & (classIndexMask());
	/* end classIndexOf: */
	{
		_ok = ClassLargePositiveIntegerCompactIndex == _ccIndex;
		goto l3;
	}
	l3:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (!_ok) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_size = 0;
		goto l6;
	}
	/* begin numBytesOfBytes: */
	_fmt = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
	assert(_fmt >= (firstByteFormat()));
	_bs = ((numSlotsOf(_oop)) << (shiftForWord())) - (_fmt & 7);
	/* end numBytesOfBytes: */
	if (_bs > (sizeof(usqIntptr_t))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_size = 0;
		goto l6;
	}
	if (((sizeof(usqIntptr_t)) == 8) && (_bs > 4)) {
		_size = SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((_oop + BaseHeaderSize) + (0U << 3)));
		goto l6;
	} else {
		_size = ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_oop + BaseHeaderSize) + (0U << 2)))) );
		goto l6;
	}
	l6:
	;
	/* end positiveMachineIntegerValueOf: */
	if (GIV(primFailCode)) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			return;
		}
	}
	{
		/* begin instantiateClass:indexableSize: */
		_classObj = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
		_obj = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, _size, 0, 0);
		/* end instantiateClass:indexableSize: */
		if (!(_obj == null)) {
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _obj);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
		}
	}
}
/* InterpreterPrimitives>>#primitiveNewWithArgOldSpace */
static void
primitiveNewWithArgOldSpace(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _bs;
	sqInt _ccIndex;
	sqInt _classFormat;
	sqInt _classOop;
	sqInt _classPointer;
	sqInt _fmt;
	sqInt _instSpec;
	sqInt _obj;
	sqInt _ok;
	sqInt _oop;
	sqInt _reasonCode;
	usqIntptr_t _size;
	char *_sp;
	sqInt _value;

	/* begin positiveMachineIntegerValueOf: */
	_oop = unsignedLongAt(GIV(stackPointer));
	if (((_oop & 7) == 1)) {
		_value = _oop >> 3;
		if (_value < 0) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			_size = null;
			goto l7;
			/* end primitiveFail */
		}
		_size = _value;
		goto l7;
	}
	if (_oop & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_size = 0;
		goto l7;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(_oop)));
	/* begin classIndexOf: */
	_ccIndex = (longAt(_oop)) & (classIndexMask());
	/* end classIndexOf: */
	{
		_ok = ClassLargePositiveIntegerCompactIndex == _ccIndex;
		goto l5;
	}
	l5:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (!_ok) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_size = 0;
		goto l7;
	}
	/* begin numBytesOfBytes: */
	_fmt = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
	assert(_fmt >= (firstByteFormat()));
	_bs = ((numSlotsOf(_oop)) << (shiftForWord())) - (_fmt & 7);
	/* end numBytesOfBytes: */
	if (_bs > (sizeof(usqIntptr_t))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_size = 0;
		goto l7;
	}
	if (((sizeof(usqIntptr_t)) == 8) && (_bs > 4)) {
		_size = SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((_oop + BaseHeaderSize) + (0U << 3)));
		goto l7;
	} else {
		_size = ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_oop + BaseHeaderSize) + (0U << 2)))) );
		goto l7;
	}
	l7:
	;
	/* end positiveMachineIntegerValueOf: */
	{
		_obj = instantiateClassindexableSizeisPinnedisOldSpace(unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord)), _size, 0, 1);
		if (_obj == null) {
			/* begin instSpecOfClass: */
			_classPointer = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
			/* begin instSpecOfClassFormat: */
			_classFormat = (unsignedLongAt((_classPointer + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
			_instSpec = (((usqInt) _classFormat ) >> (fixedFieldsFieldWidth())) & (formatMask());
			/* end instSpecOfClassFormat: */
			/* end instSpecOfClass: */
			/* begin primitiveFailFor: */
			_reasonCode = ((((_instSpec >= 2) && ((_instSpec <= (weakArrayFormat())) || (_instSpec >= (sixtyFourBitIndexableFormat())))) && (!(_instSpec >= (firstCompiledMethodFormat()))))
				 ? PrimErrNoMemory
				 : PrimErrBadReceiver);
			GIV(primFailCode) = _reasonCode;
			/* end primitiveFailFor: */
		} else {
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _obj);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
		}
	}
}
/* InterpreterPrimitives>>#primitiveNewWithArgPinned */
static void
primitiveNewWithArgPinned(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _bs;
	sqInt _ccIndex;
	sqInt _classFormat;
	sqInt _classObj;
	sqInt _classOop;
	sqInt _classPointer;
	sqInt _fmt;
	sqInt _instSpec;
	sqInt _obj;
	sqInt _ok;
	sqInt _oop;
	sqInt _reasonCode;
	usqIntptr_t _size;
	char *_sp;
	sqInt _value;

	/* begin positiveMachineIntegerValueOf: */
	_oop = unsignedLongAt(GIV(stackPointer));
	if (((_oop & 7) == 1)) {
		_value = _oop >> 3;
		if (_value < 0) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			_size = null;
			goto l7;
			/* end primitiveFail */
		}
		_size = _value;
		goto l7;
	}
	if (_oop & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_size = 0;
		goto l7;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(_oop)));
	/* begin classIndexOf: */
	_ccIndex = (longAt(_oop)) & (classIndexMask());
	/* end classIndexOf: */
	{
		_ok = ClassLargePositiveIntegerCompactIndex == _ccIndex;
		goto l5;
	}
	l5:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (!_ok) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_size = 0;
		goto l7;
	}
	/* begin numBytesOfBytes: */
	_fmt = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
	assert(_fmt >= (firstByteFormat()));
	_bs = ((numSlotsOf(_oop)) << (shiftForWord())) - (_fmt & 7);
	/* end numBytesOfBytes: */
	if (_bs > (sizeof(usqIntptr_t))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_size = 0;
		goto l7;
	}
	if (((sizeof(usqIntptr_t)) == 8) && (_bs > 4)) {
		_size = SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((_oop + BaseHeaderSize) + (0U << 3)));
		goto l7;
	} else {
		_size = ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_oop + BaseHeaderSize) + (0U << 2)))) );
		goto l7;
	}
	l7:
	;
	/* end positiveMachineIntegerValueOf: */
	{
		/* begin instantiateClass:indexableSize:isPinned: */
		_classObj = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
		_obj = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, _size, 1, 0);
		/* end instantiateClass:indexableSize:isPinned: */
		if (_obj == null) {
			/* begin instSpecOfClass: */
			_classPointer = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
			/* begin instSpecOfClassFormat: */
			_classFormat = (unsignedLongAt((_classPointer + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
			_instSpec = (((usqInt) _classFormat ) >> (fixedFieldsFieldWidth())) & (formatMask());
			/* end instSpecOfClassFormat: */
			/* end instSpecOfClass: */
			/* begin primitiveFailFor: */
			_reasonCode = ((((_instSpec >= 2) && ((_instSpec <= (weakArrayFormat())) || (_instSpec >= (sixtyFourBitIndexableFormat())))) && (!(_instSpec >= (firstCompiledMethodFormat()))))
				 ? PrimErrNoMemory
				 : PrimErrBadReceiver);
			GIV(primFailCode) = _reasonCode;
			/* end primitiveFailFor: */
		} else {
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _obj);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
		}
	}
}
/* InterpreterPrimitives>>#primitiveNextInstance */
static void
primitiveNextInstance(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _actualObj;
	sqInt _address;
	sqInt _classIndex;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	sqInt _limit;
	usqInt _numSlots;
	sqInt _object;
	char *_sp;
	sqInt _subsequentObject;

	_object = unsignedLongAt(GIV(stackPointer));
	if (!(_object & (tagMask()))) {
		/* begin instanceAfter: */
		_actualObj = _object;
		/* begin classIndexOf: */
		_classIndex = (longAt(_object)) & (classIndexMask());
		/* end classIndexOf: */
		if (oopisGreaterThanOrEqualToandLessThan(_object, ((eden()).start), GIV(freeStart))) {
			while (1) {
				/* begin objectAfter:limit: */
				_followingWordAddress = addressAfter(_actualObj);
				if (oopisGreaterThanOrEqualTo(_followingWordAddress, GIV(freeStart))) {
					_actualObj = GIV(freeStart);
					goto l3;
				}
				flag("endianness");
				_followingWord = unsignedLongAt(_followingWordAddress);
				_actualObj = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
					 ? _followingWordAddress + BaseHeaderSize
					 : _followingWordAddress);
				l3:
				;
				/* end objectAfter:limit: */
				if (!(oopisLessThan(_actualObj, GIV(freeStart)))) 
					break;
				if (_classIndex == ((longAt(_actualObj)) & (classIndexMask()))) {
					_subsequentObject = _actualObj;
					goto l7;
				}
			}
			if (oopisGreaterThan(GIV(pastSpaceStart), ((pastSpace()).start))) {
				/* begin objectStartingAt: */
				_address = ((pastSpace()).start);
				_numSlots = byteAt(_address + 7);
				_actualObj = ((_numSlots == (numSlotsMask()))
					 ? _address + BaseHeaderSize
					 : _address);
				/* end objectStartingAt: */
			} else {
				_actualObj = GIV(nilObj);
			}
		}
		if (oopisGreaterThanOrEqualToandLessThan(_actualObj, ((pastSpace()).start), GIV(pastSpaceStart))) {
			while (1) {
				/* begin objectAfter:limit: */
				_followingWordAddress2 = addressAfter(_actualObj);
				if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(pastSpaceStart))) {
					_actualObj = GIV(pastSpaceStart);
					goto l5;
				}
				flag("endianness");
				_followingWord2 = unsignedLongAt(_followingWordAddress2);
				_actualObj = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
					 ? _followingWordAddress2 + BaseHeaderSize
					 : _followingWordAddress2);
				l5:
				;
				/* end objectAfter:limit: */
				if (!(oopisLessThan(_actualObj, GIV(pastSpaceStart)))) 
					break;
				if (_classIndex == ((longAt(_actualObj)) & (classIndexMask()))) {
					_subsequentObject = _actualObj;
					goto l7;
				}
			}
			_actualObj = GIV(nilObj);
		}
		while (1) {
			/* begin objectAfter:limit: */
			_limit = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			_followingWordAddress3 = addressAfter(_actualObj);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress3, _limit)) {
				_actualObj = _limit;
				goto l6;
			}
			flag("endianness");
			_followingWord3 = unsignedLongAt(_followingWordAddress3);
			_actualObj = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress3 + BaseHeaderSize
				 : _followingWordAddress3);
			l6:
			;
			/* end objectAfter:limit: */
			if (!(oopisLessThan(_actualObj, (GIV(memoryMap)->oldSpaceEnd)))) 
				break;
			if (_classIndex == ((longAt(_actualObj)) & (classIndexMask()))) {
				_subsequentObject = _actualObj;
				goto l7;
			}
		}
		_subsequentObject = null;
		l7:
		;
		/* end instanceAfter: */
		if (_subsequentObject) {
			{
				/* begin pop:thenPush: */
				unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _subsequentObject);
				GIV(stackPointer) = _sp;
				/* end pop:thenPush: */
				return;
			}
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
}
/*	Return the object following the receiver in the heap. Return the 
	SmallInteger zero when there are no more objects. */
/* InterpreterPrimitives>>#primitiveNextObject */
static void
primitiveNextObject(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _instance;
	char *_sp;
	char *_sp2;

	{
		_instance = accessibleObjectAfter(unsignedLongAt(GIV(stackPointer)));
		if (_instance == null) {
			/* begin pop:thenPushInteger: */
			unsignedLongAtput((_sp2 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) 0 ) << 3) | 1));
			GIV(stackPointer) = _sp2;
			/* end pop:thenPushInteger: */
		} else {
			assert(isInMemory(_instance));
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _instance);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
		}
	}
}
/* InterpreterPrimitives>>#primitiveNotEqual */
static void
primitiveNotEqual(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerArgument;
	sqInt _integerReceiver;
	int _result;
	char *_sp;
	char *_sp2;

	_integerArgument = unsignedLongAt(GIV(stackPointer));
	_integerReceiver = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if ((_integerReceiver & _integerArgument) & (smallIntegerTag())) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_integerReceiver != _integerArgument)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	} else {
		_result = (signedMachineIntegerValueOf(_integerReceiver)) != (signedMachineIntegerValueOf(_integerArgument));
		if (!GIV(primFailCode)) {
			/* begin pop:thenPushBool: */
			unsignedLongAtput((_sp2 = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_result)
				 ? GIV(trueObj)
				 : GIV(falseObj)));
			GIV(stackPointer) = _sp2;
			/* end pop:thenPushBool: */
		}
	}
}
/*	Primitive comparison operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveNotEqualLargeIntegers */
EXPORT(void)
primitiveNotEqualLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqLong _integerArg;
	sqLong _integerRcvr;
	char *_sp;

	_integerArg = signed64BitValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	_integerRcvr = signed64BitValueOf(unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord)));
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_integerRcvr != _integerArg)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	}
}
/*	is the receiver/first argument not the same object as the (last) 
	argument?. pop argumentCount because this can be used as a mirror 
	primitive.  */
/* InterpreterPrimitives>>#primitiveNotIdentical */
static void
primitiveNotIdentical(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _otherObject;
	sqInt _referent;
	sqInt _referent2;
	char *_sp;
	sqInt _thisObject;

	_otherObject = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_thisObject = unsignedLongAt(GIV(stackPointer));
	if (((_otherObject & (tagMask())) == 0) && (((long64At(_otherObject)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		assert(GIV(argumentCount) > 1);
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(_thisObject));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_thisObject + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		_otherObject = _referent;
		/* end followForwarded: */
	}
	if (((_thisObject & (tagMask())) == 0) && (((long64At(_thisObject)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(_thisObject));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent2 = unsignedLongAt((_thisObject + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent2 & (tagMask())) == 0) && (((long64At(_referent2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent2 = unsignedLongAt((_referent2 + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		_thisObject = _referent2;
		/* end followForwarded: */
	}
	/* begin pop:thenPushBool: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((_thisObject != _otherObject)
		 ? GIV(trueObj)
		 : GIV(falseObj)));
	GIV(stackPointer) = _sp;
	/* end pop:thenPushBool: */
}
/* InterpreterPrimitives>>#primitivePerformInSuperclass */
static void
primitivePerformInSuperclass(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _argumentArray;
	usqInt _arraySize;
	sqInt _currentClass;
	sqInt _delta;
	sqInt _err;
	sqInt _hash;
	sqInt _index;
	sqInt _inInterpreter;
	sqInt _lookupClass;
	sqInt _methodHeader;
	sqInt _nArgs;
	sqInt _nItems;
	usqInt _numSlots;
	sqInt _object;
	sqInt _objOop;
	sqInt _offset;
	sqInt _performArgCount;
	sqInt _rcvr;
	char *_savedFramePointer;
	char *_savedStackPointer;
	sqInt _selector;
	sqInt _selector2;
	char *_sp;
	char *_sp2;
	char *_sp3;
	sqInt _succeeded;
	sqInt _tagBits;
	sqInt _tagBits2;
	sqInt _tagBits3;
	sqInt _top;

	_nArgs = 0;
	_savedFramePointer = ((char *) 0 );
	_savedStackPointer = ((char *) 0 );
	_rcvr = unsignedLongAt(GIV(stackPointer) + (3 * BytesPerWord));
	_lookupClass = unsignedLongAt(GIV(stackPointer));
	if ((GIV(argumentCount) > 3) && (((_rcvr & (tagMask())) == 0) && (((long64At(_rcvr)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	if (((_tagBits = _rcvr & (tagMask()))) != 0) {
		/* begin fetchPointer:ofObject: */
		_currentClass = unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
	} else {
		_currentClass = fetchClassOfNonImm(_rcvr);
	}
	while (_currentClass != _lookupClass) {
		/* begin followField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop = unsignedLongAt((_currentClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_objOop = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _currentClass, _objOop);
		}
		_currentClass = _objOop;
		/* end followField:ofObject: */
		if (_currentClass == GIV(nilObj)) {
			{
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				/* end primitiveFailFor: */
				return;
			}
		}
	}
	/* begin primitiveObject:perform:withArguments:lookedUpIn: */
	_selector = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	_argumentArray = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (!(((_argumentArray & (tagMask())) == 0) && (((((usqInt) (longAt(_argumentArray)) ) >> (formatShift())) & (formatMask())) == 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		goto l18;
		/* end primitiveFailFor: */
	}
	/* begin numSlotsOf: */
	assert((classIndexOf(_argumentArray)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_argumentArray + 7);
	_arraySize = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_argumentArray - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	if (_arraySize > (LargeContextSlots - CtxtTempFrameStart)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadNumArgs;
		goto l18;
		/* end primitiveFailFor: */
	}
	_performArgCount = GIV(argumentCount);
	/* begin push: */
	unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), GIV(newMethod));
	GIV(stackPointer) = _sp2;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), _rcvr);
	GIV(stackPointer) = _sp3;
	/* end push: */
	for (_index = 1; _index <= _arraySize; _index += 1) {
		/* begin push: */
		_object = unsignedLongAt((_argumentArray + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << (shiftForWord())) ));
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
		GIV(stackPointer) = _sp;
		/* end push: */
	}
	GIV(argumentCount) = _arraySize;
	GIV(messageSelector) = _selector;
	/* begin sendBreakpoint:receiver: */
	_selector2 = GIV(messageSelector);
	sendBreakpointreceiver(firstFixedFieldOfMaybeImmediate(_selector2), lengthOfMaybeImmediate(_selector2), _rcvr);
	/* end sendBreakpoint:receiver: */
	if (printOnTrace()) {
		printActivationNameForSelectorstartClass(GIV(messageSelector), ((_lookupClass == null)
			 ? (/* begin fetchClassOf: */ ((((_tagBits3 = _rcvr & (tagMask()))) != 0)
				 ? unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits3 ) << (shiftForWord())) ))
				 : fetchClassOfNonImm(_rcvr)) /* end fetchClassOf: */)
			 : _lookupClass));
		/* begin cr */
		print("\n");
		/* end cr */
	}
	findNewMethodInClassTag(((_lookupClass == null)
		 ? ((((_tagBits2 = _rcvr & (tagMask()))) != 0)
			 ? _tagBits2
			 : (longAt(_rcvr)) & (classIndexMask()))
		 : (assert(addressCouldBeClassObj(_lookupClass)), ((((_hash = (uint32AtPointer(_lookupClass + 4)) & (identityHashHalfWordMask()))) != 0)
			 ? _hash
			 : ((objCouldBeClassObj(_lookupClass))
				 ? ((((_err = enterIntoClassTable(_lookupClass))) != 0)
					 ? -_err
					 : (/* begin rawHashBitsOf: */ (uint32AtPointer(_lookupClass + 4)) & (identityHashHalfWordMask()) /* end rawHashBitsOf: */))
				 : -PrimErrBadReceiver)))));
	if ((((GIV(newMethod) & (tagMask())) == 0) && (((((usqInt) (longAt(GIV(newMethod))) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()))) && ((argumentCountOf(GIV(newMethod))) != GIV(argumentCount))) {
		assert((stackTop()) == (((_arraySize == 0)
			 ? _rcvr
			 : fetchPointerofObject(_arraySize - 1, _argumentArray))));
		assert(GIV(argumentCount) == _arraySize);
		/* begin pop: */
		_nItems = _arraySize + 1;
		GIV(stackPointer) += _nItems * BytesPerWord;
		/* end pop: */
		/* begin popStack */
		_top = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		GIV(newMethod) = _top;
		/* end popStack */
		GIV(argumentCount) = _performArgCount;
		primitiveFunctionPointer = ((_lookupClass == null)
			 ? primitivePerformWithArgs
			 : primitivePerformInSuperclass);
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadNumArgs;
		goto l18;
		/* end primitiveFailFor: */
	}
	_delta = BytesPerWord * (_performArgCount + 2);
	for (_offset = GIV(argumentCount) * BytesPerWord; _offset >= 0; _offset += -BytesPerWord) {
		unsignedLongAtput((GIV(stackPointer) + _offset) + _delta, unsignedLongAt(GIV(stackPointer) + _offset));
	}
	/* begin pop: */
	GIV(stackPointer) += (_performArgCount + 2) * BytesPerWord;
	/* end pop: */
	/* begin executeNewMethod */
	/* begin executeNewMethod: */
	_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	/* begin executePrimitiveFromInterpreter:ifFail: */
	if (primitiveFunctionPointer != 0) {
		if (((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex) {
			executeQuickPrimitive();
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), _inInterpreter);
			/* end returnToExecutive: */
			goto l13;
		}
		/* begin slowPrimitiveResponse */
		if (recordPrimTrace()) {
			/* begin fastLogPrim: */
			GIV(primTraceLog)[GIV(primTraceLogIndex)] = GIV(messageSelector);
			primTraceLogIndex(GIV(primTraceLogIndex) + 1);
			/* end fastLogPrim: */
		}
		assert((remapBufferCount()) == 0);
		{
			_nArgs = GIV(argumentCount);
			_savedStackPointer = GIV(stackPointer);
			_savedFramePointer = GIV(framePointer);
		}
		/* begin initPrimCall */
		GIV(primFailCode) = 0;
		/* end initPrimCall */
		/* begin dispatchFunctionPointer: */
		primitiveFunctionPointer();
		/* end dispatchFunctionPointer: */
		assert(maybeLeakCheckExternalPrimCall(GIV(newMethod)));
		/* begin maybeRetryPrimitiveOnFailure */
		if (GIV(primFailCode)) {
			retryPrimitiveOnFailure();
		}
		/* end maybeRetryPrimitiveOnFailure */
		/* begin maybeFailForLastObjectOverwrite */
		if (checkAllocFiller) {
			if (((freeStart0()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart0())) != (freeStart0()))) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrWritePastObject;
				/* end primitiveFailFor: */
			}
		}
		/* end maybeFailForLastObjectOverwrite */
		if (!GIV(primFailCode) && ((GIV(framePointer) == _savedFramePointer) && (!(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))))) {
			if (GIV(stackPointer) != (_savedStackPointer + (_nArgs * BytesPerWord))) {
				flag("Would be nice to make this a message send of e.g. unbalancedPrimitive to the current process or context");
				failUnbalancedPrimitive();
				GIV(stackPointer) = _savedStackPointer;
			}
		}
		if (GIV(nextProfileTick) > 0) {
			checkProfileTick(GIV(newMethod));
		}
		_succeeded = !GIV(primFailCode);
		goto l9;
		l9:
		;
		/* end slowPrimitiveResponse */
		if (_succeeded) {
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), _inInterpreter);
			/* end returnToExecutive: */
			goto l13;
		}
	}
	{
		{
			/* begin fetchPointer:ofObject: */
			_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (!((assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0))) {
				if (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
					cogselector(GIV(newMethod), GIV(nilObj));
					/* begin fetchPointer:ofObject: */
					_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
				} else {
					maybeFlagMethodAsInterpreted(GIV(newMethod));
				}
			}
		}
		activateNewMethod();
	}
	l13:
	;
	/* end executePrimitiveFromInterpreter:ifFail: */
	/* end executeNewMethod: */
	/* end executeNewMethod */
	/* begin initPrimCall */
	GIV(primFailCode) = 0;
	/* end initPrimCall */
	l18:
	;
	/* end primitiveObject:perform:withArguments:lookedUpIn: */
}
/* InterpreterPrimitives>>#primitivePerformWithArgs */
static void
primitivePerformWithArgs(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _actualReceiver;
	sqInt _argumentArray;
	usqInt _arraySize;
	sqInt _delta;
	sqInt _index;
	sqInt _inInterpreter;
	sqInt _methodHeader;
	sqInt _nArgs;
	sqInt _nItems;
	usqInt _numSlots;
	sqInt _object;
	sqInt _offset;
	sqInt _performArgCount;
	char *_savedFramePointer;
	char *_savedStackPointer;
	sqInt _selector;
	sqInt _selector2;
	char *_sp;
	char *_sp2;
	char *_sp3;
	sqInt _succeeded;
	sqInt _tagBits;
	sqInt _tagBits2;
	sqInt _top;

	/* begin primitiveObject:perform:withArguments:lookedUpIn: */
	_actualReceiver = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	_nArgs = 0;
	_savedFramePointer = ((char *) 0 );
	_savedStackPointer = ((char *) 0 );
	_selector = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_argumentArray = unsignedLongAt(GIV(stackPointer));
	if (!(((_argumentArray & (tagMask())) == 0) && (((((usqInt) (longAt(_argumentArray)) ) >> (formatShift())) & (formatMask())) == 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		goto l14;
		/* end primitiveFailFor: */
	}
	/* begin numSlotsOf: */
	assert((classIndexOf(_argumentArray)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_argumentArray + 7);
	_arraySize = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_argumentArray - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	if (_arraySize > (LargeContextSlots - CtxtTempFrameStart)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadNumArgs;
		goto l14;
		/* end primitiveFailFor: */
	}
	_performArgCount = GIV(argumentCount);
	/* begin push: */
	unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), GIV(newMethod));
	GIV(stackPointer) = _sp2;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), _actualReceiver);
	GIV(stackPointer) = _sp3;
	/* end push: */
	for (_index = 1; _index <= _arraySize; _index += 1) {
		/* begin push: */
		_object = unsignedLongAt((_argumentArray + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << (shiftForWord())) ));
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
		GIV(stackPointer) = _sp;
		/* end push: */
	}
	GIV(argumentCount) = _arraySize;
	GIV(messageSelector) = _selector;
	/* begin sendBreakpoint:receiver: */
	_selector2 = GIV(messageSelector);
	sendBreakpointreceiver(firstFixedFieldOfMaybeImmediate(_selector2), lengthOfMaybeImmediate(_selector2), _actualReceiver);
	/* end sendBreakpoint:receiver: */
	if (printOnTrace()) {
		printActivationNameForSelectorstartClass(GIV(messageSelector), (/* begin fetchClassOf: */ ((((_tagBits = _actualReceiver & (tagMask()))) != 0)
			 ? unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) ))
			 : fetchClassOfNonImm(_actualReceiver)) /* end fetchClassOf: */));
		/* begin cr */
		print("\n");
		/* end cr */
	}
	findNewMethodInClassTag(((((_tagBits2 = _actualReceiver & (tagMask()))) != 0)
		 ? _tagBits2
		 : (longAt(_actualReceiver)) & (classIndexMask())));
	if ((((GIV(newMethod) & (tagMask())) == 0) && (((((usqInt) (longAt(GIV(newMethod))) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()))) && ((argumentCountOf(GIV(newMethod))) != GIV(argumentCount))) {
		assert((stackTop()) == (((_arraySize == 0)
			 ? _actualReceiver
			 : fetchPointerofObject(_arraySize - 1, _argumentArray))));
		assert(GIV(argumentCount) == _arraySize);
		/* begin pop: */
		_nItems = _arraySize + 1;
		GIV(stackPointer) += _nItems * BytesPerWord;
		/* end pop: */
		/* begin popStack */
		_top = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		GIV(newMethod) = _top;
		/* end popStack */
		GIV(argumentCount) = _performArgCount;
		primitiveFunctionPointer = primitivePerformWithArgs;
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadNumArgs;
		goto l14;
		/* end primitiveFailFor: */
	}
	_delta = BytesPerWord * (_performArgCount + 2);
	for (_offset = GIV(argumentCount) * BytesPerWord; _offset >= 0; _offset += -BytesPerWord) {
		unsignedLongAtput((GIV(stackPointer) + _offset) + _delta, unsignedLongAt(GIV(stackPointer) + _offset));
	}
	/* begin pop: */
	GIV(stackPointer) += (_performArgCount + 2) * BytesPerWord;
	/* end pop: */
	/* begin executeNewMethod */
	/* begin executeNewMethod: */
	_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	/* begin executePrimitiveFromInterpreter:ifFail: */
	if (primitiveFunctionPointer != 0) {
		if (((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex) {
			executeQuickPrimitive();
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), _inInterpreter);
			/* end returnToExecutive: */
			goto l13;
		}
		/* begin slowPrimitiveResponse */
		if (recordPrimTrace()) {
			/* begin fastLogPrim: */
			GIV(primTraceLog)[GIV(primTraceLogIndex)] = GIV(messageSelector);
			primTraceLogIndex(GIV(primTraceLogIndex) + 1);
			/* end fastLogPrim: */
		}
		assert((remapBufferCount()) == 0);
		{
			_nArgs = GIV(argumentCount);
			_savedStackPointer = GIV(stackPointer);
			_savedFramePointer = GIV(framePointer);
		}
		/* begin initPrimCall */
		GIV(primFailCode) = 0;
		/* end initPrimCall */
		/* begin dispatchFunctionPointer: */
		primitiveFunctionPointer();
		/* end dispatchFunctionPointer: */
		assert(maybeLeakCheckExternalPrimCall(GIV(newMethod)));
		/* begin maybeRetryPrimitiveOnFailure */
		if (GIV(primFailCode)) {
			retryPrimitiveOnFailure();
		}
		/* end maybeRetryPrimitiveOnFailure */
		/* begin maybeFailForLastObjectOverwrite */
		if (checkAllocFiller) {
			if (((freeStart0()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart0())) != (freeStart0()))) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrWritePastObject;
				/* end primitiveFailFor: */
			}
		}
		/* end maybeFailForLastObjectOverwrite */
		if (!GIV(primFailCode) && ((GIV(framePointer) == _savedFramePointer) && (!(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))))) {
			if (GIV(stackPointer) != (_savedStackPointer + (_nArgs * BytesPerWord))) {
				flag("Would be nice to make this a message send of e.g. unbalancedPrimitive to the current process or context");
				failUnbalancedPrimitive();
				GIV(stackPointer) = _savedStackPointer;
			}
		}
		if (GIV(nextProfileTick) > 0) {
			checkProfileTick(GIV(newMethod));
		}
		_succeeded = !GIV(primFailCode);
		goto l9;
		l9:
		;
		/* end slowPrimitiveResponse */
		if (_succeeded) {
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), _inInterpreter);
			/* end returnToExecutive: */
			goto l13;
		}
	}
	{
		{
			/* begin fetchPointer:ofObject: */
			_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (!((assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0))) {
				if (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
					cogselector(GIV(newMethod), GIV(nilObj));
					/* begin fetchPointer:ofObject: */
					_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
				} else {
					maybeFlagMethodAsInterpreted(GIV(newMethod));
				}
			}
		}
		activateNewMethod();
	}
	l13:
	;
	/* end executePrimitiveFromInterpreter:ifFail: */
	/* end executeNewMethod: */
	/* end executeNewMethod */
	/* begin initPrimCall */
	GIV(primFailCode) = 0;
	/* end initPrimCall */
	l14:
	;
	/* end primitiveObject:perform:withArguments:lookedUpIn: */
}
/*	Primitive. Answer the last primitive method sampled by the profiler. */
/* InterpreterPrimitives>>#primitiveProfilePrimitive */
EXPORT(sqInt)
primitiveProfilePrimitive(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_sp;

	if (!(GIV(argumentCount) == 0)) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), GIV(profileMethod));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	GIV(profileMethod) = GIV(nilObj);
	return 0;
}
/*	Primitive. Answer the last sample taken by the profiler, or nil if the 
	profiler isn't active. 
	See also primitiveProfileStart. */
/* InterpreterPrimitives>>#primitiveProfileSample */
EXPORT(sqInt)
primitiveProfileSample(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_sp;

	if (!(GIV(argumentCount) == 0)) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), GIV(profileProcess));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	GIV(profileProcess) = GIV(nilObj);
	return 0;
}
/*	Primitive. Begin profiling execution every by using the interrupt 
	check-counter instead of a time-based process (which is limited to timing 
	resolution and triggers off the same signal that many of the processes 
	being profiled trigger off leading to consistently wrong results). 
	The argument is the number of interrupt checks (method activations) to let 
	go by before taking a sample. The sample is being stored in the 
	profileSample iVar which can be retrieved by executing 
	primitiveProfileSample. When a sample is taken, it signals the semaphore 
	specified in primitiveProfileSemaphore. 
	If the argument is less or equal to zero, it disables profiling. */
/* InterpreterPrimitives>>#primitiveProfileStart */
EXPORT(sqInt)
primitiveProfileStart(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _deltaTicks;
	sqInt _integerPointer;

	if (!(GIV(argumentCount) == 1)) {
		/* begin success: */
		{
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
		}
		return null;
		/* end success: */
	}
	/* begin stackIntegerValue: */
	_integerPointer = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_deltaTicks = _integerPointer >> 3;
		goto l3;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_deltaTicks = 0;
		goto l3;
	}
	/* end checkedIntegerValueOf: */
	l3:
	;
	/* end stackIntegerValue: */
	if (!GIV(primFailCode)) {
		GIV(nextProfileTick) = (ioHighResClock()) + _deltaTicks;
		/* begin pop: */
		GIV(stackPointer) += 1 * BytesPerWord;
		/* end pop: */
	}
	return 0;
}
/* InterpreterPrimitives>>#primitiveQuit */
static void
primitiveQuit(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (isLogDebug()) {
		logDebug("Quit requested by the image");
		printAllStacks();
	}
	ioExitWithErrorCode(((GIV(argumentCount) == 1)
		 ? (unsignedLongAt(GIV(stackPointer))) >> 3
		 : 0));
}
/*	Rounds negative results towards zero. */
/* InterpreterPrimitives>>#primitiveQuo */
static void
primitiveQuo(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerArg;
	sqInt _integerPointer;
	sqInt _integerPointer2;
	sqInt _integerRcvr;
	sqInt _integerResult;
	char *_sp;

	/* begin stackIntegerValue: */
	_integerPointer = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_integerResult = 0;
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_integerRcvr = _integerPointer >> 3;
		goto l2;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerRcvr = 0;
		goto l2;
	}
	/* end checkedIntegerValueOf: */
	l2:
	;
	/* end stackIntegerValue: */
	/* begin stackIntegerValue: */
	_integerPointer2 = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer2 & 7) == 1)) {
		_integerArg = _integerPointer2 >> 3;
		goto l3;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_integerArg = 0;
		goto l3;
	}
	/* end checkedIntegerValueOf: */
	l3:
	;
	/* end stackIntegerValue: */
	/* begin success: */
	if (!(_integerArg != 0)) {
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
	}
	/* end success: */
	if (!GIV(primFailCode)) {
		if (_integerRcvr > 0) {
			_integerResult = ((_integerArg > 0)
				 ? _integerRcvr / _integerArg
				 : 0 - (_integerRcvr / (0 - _integerArg)));
		}
 else {
			_integerResult = ((_integerArg > 0)
				 ? 0 - ((0 - _integerRcvr) / _integerArg)
				 : (0 - _integerRcvr) / (0 - _integerArg));
		}
	}
	/* begin pop2AndPushIntegerIfOK: */
	if (!GIV(primFailCode)) {
		if ((((((usqInt) _integerResult ) >> 60) + 1) & 15) <= 1) {
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((((usqInt) _integerResult ) << 3) | 1));
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
		} else {
			/* begin success: */
			{
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
			}
			/* end success: */
		}
	}
	/* end pop2AndPushIntegerIfOK: */
}
/*	Primitive arithmetic operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveQuoLargeIntegers */
EXPORT(void)
primitiveQuoLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _a;
	sqInt _aIsNegative;
	usqLong _b;
	sqInt _bIsNegative;
	sqInt _oopArg;
	sqInt _oopRcvr;
	sqInt _oopResult;
	usqLong _result;
	char *_sp;

	_oopArg = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	_oopRcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_aIsNegative = isNegativeIntegerValueOf(_oopRcvr);
	_bIsNegative = isNegativeIntegerValueOf(_oopArg);
	_a = magnitude64BitValueOf(_oopRcvr);
	_b = magnitude64BitValueOf(_oopArg);
	if (_b == 0) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	}
	if (GIV(primFailCode)) {
		{
			return;
		}
	}
	_result = _a / _b;
	_oopResult = magnitude64BitIntegerForneg(_result, _bIsNegative != _aIsNegative);
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oopResult);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/*	Relinquish the processor for up to the given number of microseconds. The 
	exact behavior of this primitive is platform dependent. */
/* InterpreterPrimitives>>#primitiveRelinquishProcessor */
static void
primitiveRelinquishProcessor(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerPointer;
	sqInt _microSecs;

	/* begin stackIntegerValue: */
	_integerPointer = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_microSecs = _integerPointer >> 3;
		goto l3;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_microSecs = 0;
		goto l3;
	}
	/* end checkedIntegerValueOf: */
	l3:
	;
	/* end stackIntegerValue: */
	if (!GIV(primFailCode)) {
		if (GIV(nextProfileTick) == 0) {
			ioRelinquishProcessorForMicroseconds(_microSecs);
		}
		/* begin pop: */
		GIV(stackPointer) += 1 * BytesPerWord;
		/* end pop: */
	}
}
/*	Primitive arithmetic operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveRemLargeIntegers */
EXPORT(void)
primitiveRemLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _a;
	sqInt _aIsNegative;
	usqLong _b;
	sqInt _oopArg;
	sqInt _oopRcvr;
	sqInt _oopResult;
	usqLong _result;
	char *_sp;

	_oopArg = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	_oopRcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_aIsNegative = isNegativeIntegerValueOf(_oopRcvr);
	_a = magnitude64BitValueOf(_oopRcvr);
	_b = magnitude64BitValueOf(_oopArg);
	if (_b == 0) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	}
	if (GIV(primFailCode)) {
		{
			return;
		}
	}
	_result = _a % _b;
	_oopResult = magnitude64BitIntegerForneg(_result, _aIsNegative);
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oopResult);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/*	Return the number of seconds since January 1, 1901 as an integer. */
/* InterpreterPrimitives>>#primitiveSecondsClock */
static void
primitiveSecondsClock(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	unsigned int _integerValue;
	sqInt _oop;
	char *_sp;

	/* begin pop:thenPush: */
	/* begin positive32BitIntegerFor: */
	_integerValue = ((unsigned int) (ioSecondsNow()) );
	{
		_oop = (((((usqInt) _integerValue ) & 0xFFFFFFFFU) << 3) | 1);
		goto l2;
	}
	l2:
	;
	/* end positive32BitIntegerFor: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* InterpreterPrimitives>>#primitiveSetImmutability */

#if IMMUTABILITY
static void
primitiveSetImmutability(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _rcvr;
	char *_sp;
	sqInt _wasImmutable;

	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (_rcvr & (tagMask())) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadReceiver;
			/* end primitiveFailFor: */
			return;
		}
	}
	_wasImmutable = 
#    if IMMUTABILITY
			(/* begin isImmutable: */ ((((usqInt) (longAt(_rcvr)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#    else /* IMMUTABILITY */
			0
#    endif /* IMMUTABILITY */
			;
	if ((unsignedLongAt(GIV(stackPointer))) == GIV(trueObj)) {
		if (!(canBeImmutable(_rcvr))) {
			{
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrInappropriate;
				/* end primitiveFailFor: */
				return;
			}
		}
		/* begin setIsImmutableOf:to: */
		longAtput(_rcvr, (longAt(_rcvr)) | (1U << (immutableBitShift())));
		/* end setIsImmutableOf:to: */
	} else {
		if ((unsignedLongAt(GIV(stackPointer))) == GIV(falseObj)) {
			/* begin setIsImmutableOf:to: */
			longAtput(_rcvr, (longAt(_rcvr)) & (~((usqIntptr_t) (1U << (immutableBitShift())) )));
			/* end setIsImmutableOf:to: */
		} else {
			{
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				/* end primitiveFailFor: */
				return;
			}
		}
	}
	/* begin pop:thenPushBool: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((_wasImmutable)
		 ? GIV(trueObj)
		 : GIV(falseObj)));
	GIV(stackPointer) = _sp;
	/* end pop:thenPushBool: */
}
#endif /* IMMUTABILITY */
/* InterpreterPrimitives>>#primitiveSetOrHasIdentityHash */
static void
primitiveSetOrHasIdentityHash(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _hasHash;
	sqInt _hash;
	sqInt _hash2;
	sqInt _hash3;
	sqInt _integerPointer;
	sqInt _isReceiverAClass;
	sqInt _obj;
	sqInt _oldHash;
	sqInt _oop;
	char *_sp;
	char *_sp2;
	sqInt _thisReceiver;

	if (GIV(argumentCount) == 0) {
		_hasHash = (isNonImmediate(unsignedLongAt(GIV(stackPointer)))) && (hasIdentityHash(unsignedLongAt(GIV(stackPointer))));
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((_hasHash)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
		return;
	}
	if (GIV(argumentCount) == 2) {
		/* begin booleanValueOf: */
		_obj = unsignedLongAt(GIV(stackPointer));
		if (_obj == GIV(trueObj)) {
			_isReceiverAClass = 1;
			goto l3;
		}
		if (_obj == GIV(falseObj)) {
			_isReceiverAClass = 0;
			goto l3;
		}
		/* begin success: */
		{
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
		}
		/* end success: */
		_isReceiverAClass = null;
		l3:
		;
		/* end booleanValueOf: */
		if (GIV(primFailCode)) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
		}
	} else {
		_isReceiverAClass = 0;
	}
	/* begin stackIntegerValue: */
	_integerPointer = unsignedLongAt(GIV(stackPointer) + ((GIV(argumentCount) - 1) * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_hash = _integerPointer >> 3;
		goto l5;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_hash = 0;
		goto l5;
	}
	/* end checkedIntegerValueOf: */
	l5:
	;
	/* end stackIntegerValue: */
	/* begin stackObjectValue: */
	_oop = unsignedLongAt(GIV(stackPointer) + (GIV(argumentCount) * BytesPerWord));
	if (_oop & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_thisReceiver = null;
		goto l4;
	}
	_thisReceiver = _oop;
	l4:
	;
	/* end stackObjectValue: */
	if (!GIV(primFailCode)) {
		/* begin hashBitsOf: */
		_hash3 = (uint32AtPointer(_thisReceiver + 4)) & (identityHashHalfWordMask());
		if (_hash3 == 0) {
			/* begin newHashBitsOf: */
			_hash2 = (newObjectHash()) & (identityHashHalfWordMask());
			/* begin setHashBitsOf:to: */
			assert((_hash2 >= 0) && (_hash2 <= (identityHashHalfWordMask())));
			uint32AtPointerput(_thisReceiver + 4, (((uint32AtPointer(_thisReceiver + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + _hash2);
			/* end setHashBitsOf:to: */
			_hash3 = _hash2;
			/* end newHashBitsOf: */
		}
		_oldHash = _hash3;
		/* end hashBitsOf: */
		/* begin setHashBitsOf:to: */
		assert((_hash >= 0) && (_hash <= (identityHashHalfWordMask())));
		uint32AtPointerput(_thisReceiver + 4, (((uint32AtPointer(_thisReceiver + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + _hash);
		/* end setHashBitsOf:to: */
		if (_isReceiverAClass) {
			classAtIndexput(_hash, _thisReceiver);
			allInstancesOf(_thisReceiver);
		}
		/* begin pop:thenPushInteger: */
		unsignedLongAtput((_sp2 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _oldHash ) << 3) | 1));
		GIV(stackPointer) = _sp2;
		/* end pop:thenPushInteger: */
	}
}
/*	Treat the receiver, which can be indexible by either bytes or words, as 
	an array of signed 16-bit values. Answer the contents of the given index. 
	Note that the index specifies the i-th 16-bit entry, not the i-th byte or 
	word.  */
/* InterpreterPrimitives>>#primitiveShortAt */
static void
primitiveShortAt(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	_index = unsignedLongAt(GIV(stackPointer));
	if (!(((_index & 7) == 1))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			return;
		}
	}
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (!(((_rcvr & (tagMask())) == 0) && (isPureBitsFormat((((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask()))))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrInappropriate;
			/* end primitiveFailFor: */
			return;
		}
	}
	_index = _index >> 3;
	if (!((_index >= 1) && (_index <= (((usqInt) (numBytesOf(_rcvr)) ) >> 1)))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadIndex;
			/* end primitiveFailFor: */
			return;
		}
	}
	_value = shortAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << 1) ));
	/* begin pop:thenPushInteger: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((((usqInt) _value ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPushInteger: */
}
/*	Treat the receiver, which can be indexible by either bytes or words, as an 
	array of signed 16-bit values. Set the contents of the given index to the 
	given value. 
	Note that the index specifies the i-th 16-bit entry, not the i-th byte or 
	word.  */
/* InterpreterPrimitives>>#primitiveShortAtPut */
static void
primitiveShortAtPut(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	_value = unsignedLongAt(GIV(stackPointer));
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (!((((_value & 7) == 1)) && ((((_index & 7) == 1)) && (((_value = _value >> 3), (_value >= -32768) && (_value <= 0x7FFF)))))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			return;
		}
	}
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	if (!(((_rcvr & (tagMask())) == 0) && (isPureBitsFormat((((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask()))))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrInappropriate;
			/* end primitiveFailFor: */
			return;
		}
	}
	if (
#    if IMMUTABILITY
			(/* begin isImmutable: */ ((((usqInt) (longAt(_rcvr)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#    else /* IMMUTABILITY */
			0
#    endif /* IMMUTABILITY */
			) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrNoModification;
			/* end primitiveFailFor: */
			return;
		}
	}
	_index = _index >> 3;
	if (!((_index >= 1) && (_index <= (((usqInt) (numBytesOf(_rcvr)) ) >> 1)))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadIndex;
			/* end primitiveFailFor: */
			return;
		}
	}
	shortAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << 1) ), _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((3 - 1) * BytesPerWord)), ((((usqInt) _value ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Set the low-water mark for free space. When the free space falls 
	below this level, the new and new: primitives fail and system attempts 
	to allocate space (e.g., to create a method context) cause the low-space 
	semaphore (if one is registered) to be signalled. */
/* InterpreterPrimitives>>#primitiveSignalAtBytesLeft */
static void
primitiveSignalAtBytesLeft(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _bytes;

	_bytes = unsignedLongAt(GIV(stackPointer));
	if ((((_bytes & 7) == 1)) && (((_bytes = _bytes >> 3)) >= 0)) {
		/* begin lowSpaceThreshold: */
		GIV(lowSpaceThreshold) = _bytes;
		if ((_bytes > 0) && (GIV(totalFreeOldSpace) < _bytes)) {
			growOldSpaceByAtLeastcallingOperation(_bytes - GIV(totalFreeOldSpace), "ensuring enough space after setting lowSpaceThreshold");
		}
		assert(GIV(totalFreeOldSpace) >= GIV(lowSpaceThreshold));
		/* end lowSpaceThreshold: */
		/* begin pop: */
		GIV(stackPointer) += 1 * BytesPerWord;
		/* end pop: */
	} else {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		/* end primitiveFailFor: */
	}
}
/*	N.B. IMO we should be able to assume the receiver is a float because this 
	primitive is specific to floats. eem 2/13/2017 */
/* InterpreterPrimitives>>#primitiveSine */
static void
primitiveSine(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aValue;
	double _rcvr;

	/* begin stackFloatValue: */
	_rcvr = floatValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	/* end stackFloatValue: */
	if (!GIV(primFailCode)) {
		/* begin stackTopPut: */
		_aValue = floatObjectOf(sin(_rcvr));
		unsignedLongAtput(GIV(stackPointer), _aValue);
		/* end stackTopPut: */
	}
}
/* InterpreterPrimitives>>#primitiveSize */
static void
primitiveSize(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _class;
	sqInt _classFormat;
	sqInt _fixedFields;
	usqLong _fmt;
	sqLong _hdr;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _rcvr;
	char *_sp;
	sqInt _totalLength;

	_rcvr = unsignedLongAt(GIV(stackPointer));
	if ((_rcvr & (tagMask())) || ((((long64At(_rcvr)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) || (((_hdr = long64At(_rcvr)), ((_fmt = (((unsigned sqLong) _hdr ) >> (formatShift())) & (formatMask()))) < 2)))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadReceiver;
			/* end primitiveFailFor: */
			return;
		}
	}
	if ((_fmt == (indexablePointersFormat())) && ((_hdr & (classIndexMask())) == ClassMethodContextCompactIndex)) {
		{
			primitiveContextSize();
			return;
		}
	}
	/* begin lengthOf:format: */
	/* begin numSlotsOfAny: */
	_numSlots2 = byteAt(_rcvr + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOfAny: */
	if (_fmt <= 5) {
		_totalLength = _numSlots;
		goto l4;
	}
	if (_fmt >= (firstByteFormat())) {
		_totalLength = (_numSlots << (shiftForWord())) - (_fmt & 7);
		goto l4;
	}
	if (_fmt >= (firstShortFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
		goto l4;
	}
	if (_fmt >= (firstLongFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
		goto l4;
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		_totalLength = _numSlots;
		goto l4;
	}
	_totalLength = 0;
	l4:
	;
	/* end lengthOf:format: */
	/* begin fixedFieldsOf:format:length: */
	if ((_fmt >= (sixtyFourBitIndexableFormat())) || (_fmt == 2)) {
		_fixedFields = 0;
		goto l5;
	}
	if (_fmt < 2) {
		_fixedFields = _totalLength;
		goto l5;
	}
	_class = fetchClassOfNonImm(_rcvr);
	/* begin fixedFieldsOfClassFormat: */
	_classFormat = (unsignedLongAt((_class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	_fixedFields = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	/* end fixedFieldsOfClassFormat: */
	l5:
	;
	/* end fixedFieldsOf:format:length: */
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) (_totalLength - _fixedFields) ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* InterpreterPrimitives>>#primitiveSizeInBytes */
static void
primitiveSizeInBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _byteSize;
	sqInt _oop;
	sqInt _oop2;
	char *_sp;

	/* begin totalByteSizeOf: */
	_oop2 = unsignedLongAt(GIV(stackPointer));
	_byteSize = ((_oop2 & (tagMask()))
		 ? 0
		 : bytesInObject(_oop2));
	/* end totalByteSizeOf: */
	/* begin pop:thenPush: */
	_oop = positive64BitIntegerFor(_byteSize);
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Answer the byte size of an instance of the receiver. If num args > 0 
	then the last argument is a variable size and the size answered is the 
	size of an instance of the receiver with that many indexable elements. */
/* InterpreterPrimitives>>#primitiveSizeInBytesOfInstance */
static void
primitiveSizeInBytesOfInstance(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _byteSize;
	sqInt _classFormat;
	sqInt _classFormat2;
	sqInt _classObj;
	sqInt _classObj2;
	sqInt _code;
	sqInt _err;
	sqInt _instSpec;
	sqInt _instSpec2;
	sqInt _nElements;
	usqInt _numSlots;
	sqInt _numSlots2;
	sqInt _oop;
	char *_sp;
	char *_sp2;

	if (GIV(argumentCount) > 1) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadNumArgs;
			/* end primitiveFailFor: */
			return;
		}
	}
	_err = -1;
	if (GIV(argumentCount) >= 1) {
		if (!((((unsignedLongAt(GIV(stackPointer))) & 7) == 1))) {
			{
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				/* end primitiveFailFor: */
				return;
			}
		}
		/* begin byteSizeOfInstanceOf:withIndexableSlots:errInto: */
		_classObj = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
		_nElements = (unsignedLongAt(GIV(stackPointer))) >> 3;
		_classFormat = (unsignedLongAt((_classObj + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
		_instSpec = (((usqInt) _classFormat ) >> (fixedFieldsFieldWidth())) & (formatMask());
		switch (_instSpec) {
			case 2:
			{
				_numSlots = _nElements;
			}
			break;
			case indexablePointersFormat():
			case weakArrayFormat():
			{
				_numSlots = (_classFormat & ((1U << (fixedFieldsFieldWidth())) - 1)) + _nElements;
			}
			break;
			case sixtyFourBitIndexableFormat():
			{
				_numSlots = _nElements;
			}
			break;
			case firstLongFormat():
			{
				_numSlots = (_nElements + 1) / 2;
			}
			break;
			case firstShortFormat():
			{
				_numSlots = (_nElements + 3) / 4;
			}
			break;
			case firstByteFormat():
			case firstCompiledMethodFormat():
			{
				_numSlots = (_nElements + (BytesPerOop - 1)) / BytesPerOop;
			}
			break;
			default:
			{
				{
					_byteSize = (_err = PrimErrBadReceiver);
				}
				goto l6;
			}
		}
		if (_numSlots >= (((usqInt) 1 ) << ((BytesPerOop * 8) - 3))) {
			{
				_code = ((_nElements < 0)
					 ? PrimErrBadArgument
					 : PrimErrLimitExceeded);
				_byteSize = (_err = _code);
			}
			goto l6;
		}
		_byteSize = ((_numSlots == 0)
			 ? 8 + BaseHeaderSize
			 : (_numSlots << (shiftForWord())) + (((_numSlots >= (numSlotsMask()))
				 ? BaseHeaderSize + BaseHeaderSize
				 : BaseHeaderSize)));
		l6:
		;
		/* end byteSizeOfInstanceOf:withIndexableSlots:errInto: */
		if (_err >= 0) {
			{
				/* begin primitiveFailFor: */
				GIV(primFailCode) = _err;
				/* end primitiveFailFor: */
				return;
			}
		}
		{
			/* begin pop:thenPush: */
			_oop = positive64BitIntegerFor(_byteSize);
			unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
			return;
		}
	}
	/* begin byteSizeOfInstanceOf:errInto: */
	_classObj2 = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	_classFormat2 = (unsignedLongAt((_classObj2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	_instSpec2 = (((usqInt) _classFormat2 ) >> (fixedFieldsFieldWidth())) & (formatMask());
	if (!((_instSpec2 <= 1) || (_instSpec2 == 5))) {
		{
			_byteSize = (_err = PrimErrBadReceiver);
		}
		goto l7;
	}
	_numSlots2 = _classFormat2 & ((1U << (fixedFieldsFieldWidth())) - 1);
	_byteSize = ((_numSlots2 == 0)
		 ? 8 + BaseHeaderSize
		 : ((sqInt) (((usqInt) _numSlots2 ) << (shiftForWord())) ) + (((_numSlots2 >= (numSlotsMask()))
			 ? BaseHeaderSize + BaseHeaderSize
			 : BaseHeaderSize)));
	l7:
	;
	/* end byteSizeOfInstanceOf:errInto: */
	if (_err >= 0) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = _err;
			/* end primitiveFailFor: */
			return;
		}
	}
	/* begin pop:thenPushInteger: */
	unsignedLongAtput((_sp2 = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), ((_byteSize << 3) | 1));
	GIV(stackPointer) = _sp2;
	/* end pop:thenPushInteger: */
}
/* InterpreterPrimitives>>#primitiveSmallFloatAdd */
static void
primitiveSmallFloatAdd(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	double _arg;
	usqLong _bits;
	usqLong _bits2;
	sqInt _floatOrIntOop;
	sqInt _floatOrIntOop2;
	double _rcvr;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	if (((_tagBits = _floatOrIntOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop));
			_rot = ((usqInt) ((usqInt) _floatOrIntOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l5;
			}
			_rcvr = null;
			goto l5;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop ) << _shift) ) ) >> _shift) == _floatOrIntOop))) {
			_rcvr = ((double) (_floatOrIntOop >> 3) );
			goto l5;
		}
	} else {
		if (((longAt(_floatOrIntOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l5;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l5:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop2 = unsignedLongAt(GIV(stackPointer));
	if (((_tagBits2 = _floatOrIntOop2 & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop2));
			_rot2 = ((usqInt) ((usqInt) _floatOrIntOop2 ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l8;
			}
			_arg = null;
			goto l8;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop2 ) << _shift2) ) ) >> _shift2) == _floatOrIntOop2))) {
			_arg = ((double) (_floatOrIntOop2 >> 3) );
			goto l8;
		}
	} else {
		if (((longAt(_floatOrIntOop2)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop2 + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l8;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l8:
	;
	/* end loadFloatOrIntFrom: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushFloat: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), floatObjectOf(_rcvr + _arg));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushFloat: */
	} else {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		/* end primitiveFailFor: */
	}
}
/* InterpreterPrimitives>>#primitiveSmallFloatArctan */
static void
primitiveSmallFloatArctan(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aValue;
	usqLong _bits;
	sqInt _oop;
	double _rcvr;
	usqLong _rot;
	double _value;

	/* begin smallFloatValueOf: */
	_oop = unsignedLongAt(GIV(stackPointer));
	_value = 0;
	/* begin smallFloatBitsOf: */
	assert(isImmediateFloat(_oop));
	_rot = ((usqInt) ((usqInt) _oop ) ) >> (numTagBits());
	if (_rot > 1) {
		_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
	}
	/* begin rotateRight: */
	_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
	/* end rotateRight: */
	_bits = _rot;
	/* end smallFloatBitsOf: */
	memcpy(&_value, &_bits, sizeof(_value));
	_rcvr = _value;
	goto l5;
	l5:
	;
	/* end smallFloatValueOf: */
	/* begin stackTopPut: */
	_aValue = floatObjectOf(atan(_rcvr));
	unsignedLongAtput(GIV(stackPointer), _aValue);
	/* end stackTopPut: */
}
/* InterpreterPrimitives>>#primitiveSmallFloatDivide */
static void
primitiveSmallFloatDivide(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	double _arg;
	usqLong _bits;
	usqLong _bits2;
	sqInt _floatOrIntOop;
	sqInt _floatOrIntOop2;
	double _rcvr;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	if (((_tagBits = _floatOrIntOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop));
			_rot = ((usqInt) ((usqInt) _floatOrIntOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l5;
			}
			_rcvr = null;
			goto l5;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop ) << _shift) ) ) >> _shift) == _floatOrIntOop))) {
			_rcvr = ((double) (_floatOrIntOop >> 3) );
			goto l5;
		}
	} else {
		if (((longAt(_floatOrIntOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l5;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l5:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop2 = unsignedLongAt(GIV(stackPointer));
	if (((_tagBits2 = _floatOrIntOop2 & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop2));
			_rot2 = ((usqInt) ((usqInt) _floatOrIntOop2 ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l8;
			}
			_arg = null;
			goto l8;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop2 ) << _shift2) ) ) >> _shift2) == _floatOrIntOop2))) {
			_arg = ((double) (_floatOrIntOop2 >> 3) );
			goto l8;
		}
	} else {
		if (((longAt(_floatOrIntOop2)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop2 + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l8;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l8:
	;
	/* end loadFloatOrIntFrom: */
	if (_arg == 0.0) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	}
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushFloat: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), floatObjectOf(_rcvr / _arg));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushFloat: */
	} else {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		/* end primitiveFailFor: */
	}
}
/* InterpreterPrimitives>>#primitiveSmallFloatEqual */
static void
primitiveSmallFloatEqual(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	double _arg;
	usqLong _bits;
	usqLong _bits2;
	sqInt _floatOrIntOop;
	sqInt _floatOrIntOop2;
	double _rcvr;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	if (((_tagBits = _floatOrIntOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop));
			_rot = ((usqInt) ((usqInt) _floatOrIntOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l5;
			}
			_rcvr = null;
			goto l5;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop ) << _shift) ) ) >> _shift) == _floatOrIntOop))) {
			_rcvr = ((double) (_floatOrIntOop >> 3) );
			goto l5;
		}
	} else {
		if (((longAt(_floatOrIntOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l5;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l5:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop2 = unsignedLongAt(GIV(stackPointer));
	if (((_tagBits2 = _floatOrIntOop2 & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop2));
			_rot2 = ((usqInt) ((usqInt) _floatOrIntOop2 ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l8;
			}
			_arg = null;
			goto l8;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop2 ) << _shift2) ) ) >> _shift2) == _floatOrIntOop2))) {
			_arg = ((double) (_floatOrIntOop2 >> 3) );
			goto l8;
		}
	} else {
		if (((longAt(_floatOrIntOop2)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop2 + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l8;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l8:
	;
	/* end loadFloatOrIntFrom: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_rcvr == _arg)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	} else {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		/* end primitiveFailFor: */
	}
}
/*	Computes E raised to the receiver power. 
	Since SmallFloats cannot represent NaNs there's no need to special case. */
/* InterpreterPrimitives>>#primitiveSmallFloatExp */
static void
primitiveSmallFloatExp(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aValue;

	/* begin stackTopPut: */
	_aValue = floatObjectOf(exp(smallFloatValueOf(unsignedLongAt(GIV(stackPointer)))));
	unsignedLongAtput(GIV(stackPointer), _aValue);
	/* end stackTopPut: */
}
/*	Answer the exponent part of this float. */
/* InterpreterPrimitives>>#primitiveSmallFloatExponent */
static void
primitiveSmallFloatExponent(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aValue;

	/* begin stackTopPut: */
	_aValue = ((((exponentOfSmallFloat(unsignedLongAt(GIV(stackPointer)))) - 1) << 3) | 1);
	unsignedLongAtput(GIV(stackPointer), _aValue);
	/* end stackTopPut: */
}
/* InterpreterPrimitives>>#primitiveSmallFloatFractionalPart */
static void
primitiveSmallFloatFractionalPart(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aValue;
	usqLong _bits;
	double _frac;
	sqInt _oop;
	double _rcvr;
	usqLong _rot;
	double _trunc;
	double _value;

	/* begin smallFloatValueOf: */
	_oop = unsignedLongAt(GIV(stackPointer));
	_trunc = 0;
	_value = 0;
	/* begin smallFloatBitsOf: */
	assert(isImmediateFloat(_oop));
	_rot = ((usqInt) ((usqInt) _oop ) ) >> (numTagBits());
	if (_rot > 1) {
		_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
	}
	/* begin rotateRight: */
	_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
	/* end rotateRight: */
	_bits = _rot;
	/* end smallFloatBitsOf: */
	memcpy(&_value, &_bits, sizeof(_value));
	_rcvr = _value;
	goto l5;
	l5:
	;
	/* end smallFloatValueOf: */
	_frac = modf(_rcvr, &_trunc);
	/* begin stackTopPut: */
	_aValue = floatObjectOf(_frac);
	unsignedLongAtput(GIV(stackPointer), _aValue);
	/* end stackTopPut: */
}
/* InterpreterPrimitives>>#primitiveSmallFloatGreaterOrEqual */
static void
primitiveSmallFloatGreaterOrEqual(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	double _arg;
	usqLong _bits;
	usqLong _bits2;
	sqInt _floatOrIntOop;
	sqInt _floatOrIntOop2;
	double _rcvr;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	if (((_tagBits = _floatOrIntOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop));
			_rot = ((usqInt) ((usqInt) _floatOrIntOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l5;
			}
			_rcvr = null;
			goto l5;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop ) << _shift) ) ) >> _shift) == _floatOrIntOop))) {
			_rcvr = ((double) (_floatOrIntOop >> 3) );
			goto l5;
		}
	} else {
		if (((longAt(_floatOrIntOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l5;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l5:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop2 = unsignedLongAt(GIV(stackPointer));
	if (((_tagBits2 = _floatOrIntOop2 & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop2));
			_rot2 = ((usqInt) ((usqInt) _floatOrIntOop2 ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l8;
			}
			_arg = null;
			goto l8;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop2 ) << _shift2) ) ) >> _shift2) == _floatOrIntOop2))) {
			_arg = ((double) (_floatOrIntOop2 >> 3) );
			goto l8;
		}
	} else {
		if (((longAt(_floatOrIntOop2)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop2 + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l8;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l8:
	;
	/* end loadFloatOrIntFrom: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_rcvr >= _arg)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	} else {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		/* end primitiveFailFor: */
	}
}
/* InterpreterPrimitives>>#primitiveSmallFloatGreaterThan */
static void
primitiveSmallFloatGreaterThan(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	double _arg;
	usqLong _bits;
	usqLong _bits2;
	sqInt _floatOrIntOop;
	sqInt _floatOrIntOop2;
	double _rcvr;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	if (((_tagBits = _floatOrIntOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop));
			_rot = ((usqInt) ((usqInt) _floatOrIntOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l5;
			}
			_rcvr = null;
			goto l5;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop ) << _shift) ) ) >> _shift) == _floatOrIntOop))) {
			_rcvr = ((double) (_floatOrIntOop >> 3) );
			goto l5;
		}
	} else {
		if (((longAt(_floatOrIntOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l5;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l5:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop2 = unsignedLongAt(GIV(stackPointer));
	if (((_tagBits2 = _floatOrIntOop2 & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop2));
			_rot2 = ((usqInt) ((usqInt) _floatOrIntOop2 ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l8;
			}
			_arg = null;
			goto l8;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop2 ) << _shift2) ) ) >> _shift2) == _floatOrIntOop2))) {
			_arg = ((double) (_floatOrIntOop2 >> 3) );
			goto l8;
		}
	} else {
		if (((longAt(_floatOrIntOop2)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop2 + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l8;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l8:
	;
	/* end loadFloatOrIntFrom: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_rcvr > _arg)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	} else {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		/* end primitiveFailFor: */
	}
}
/* InterpreterPrimitives>>#primitiveSmallFloatLessOrEqual */
static void
primitiveSmallFloatLessOrEqual(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	double _arg;
	usqLong _bits;
	usqLong _bits2;
	sqInt _floatOrIntOop;
	sqInt _floatOrIntOop2;
	double _rcvr;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	if (((_tagBits = _floatOrIntOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop));
			_rot = ((usqInt) ((usqInt) _floatOrIntOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l5;
			}
			_rcvr = null;
			goto l5;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop ) << _shift) ) ) >> _shift) == _floatOrIntOop))) {
			_rcvr = ((double) (_floatOrIntOop >> 3) );
			goto l5;
		}
	} else {
		if (((longAt(_floatOrIntOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l5;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l5:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop2 = unsignedLongAt(GIV(stackPointer));
	if (((_tagBits2 = _floatOrIntOop2 & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop2));
			_rot2 = ((usqInt) ((usqInt) _floatOrIntOop2 ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l8;
			}
			_arg = null;
			goto l8;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop2 ) << _shift2) ) ) >> _shift2) == _floatOrIntOop2))) {
			_arg = ((double) (_floatOrIntOop2 >> 3) );
			goto l8;
		}
	} else {
		if (((longAt(_floatOrIntOop2)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop2 + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l8;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l8:
	;
	/* end loadFloatOrIntFrom: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_rcvr <= _arg)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	} else {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		/* end primitiveFailFor: */
	}
}
/* InterpreterPrimitives>>#primitiveSmallFloatLessThan */
static void
primitiveSmallFloatLessThan(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	double _arg;
	usqLong _bits;
	usqLong _bits2;
	sqInt _floatOrIntOop;
	sqInt _floatOrIntOop2;
	double _rcvr;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	if (((_tagBits = _floatOrIntOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop));
			_rot = ((usqInt) ((usqInt) _floatOrIntOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l4;
			}
			_rcvr = null;
			goto l4;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop ) << _shift) ) ) >> _shift) == _floatOrIntOop))) {
			_rcvr = ((double) (_floatOrIntOop >> 3) );
			goto l4;
		}
	} else {
		if (((longAt(_floatOrIntOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l4;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l4:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop2 = unsignedLongAt(GIV(stackPointer));
	if (((_tagBits2 = _floatOrIntOop2 & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop2));
			_rot2 = ((usqInt) ((usqInt) _floatOrIntOop2 ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l7;
			}
			_arg = null;
			goto l7;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop2 ) << _shift2) ) ) >> _shift2) == _floatOrIntOop2))) {
			_arg = ((double) (_floatOrIntOop2 >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(_floatOrIntOop2)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop2 + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l7;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l7:
	;
	/* end loadFloatOrIntFrom: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_rcvr < _arg)
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	}
}
/*	Natural log. */
/* InterpreterPrimitives>>#primitiveSmallFloatLogN */
static void
primitiveSmallFloatLogN(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aValue;
	usqLong _bits;
	sqInt _oop;
	double _rcvr;
	usqLong _rot;
	double _value;

	/* begin smallFloatValueOf: */
	_oop = unsignedLongAt(GIV(stackPointer));
	_value = 0;
	/* begin smallFloatBitsOf: */
	assert(isImmediateFloat(_oop));
	_rot = ((usqInt) ((usqInt) _oop ) ) >> (numTagBits());
	if (_rot > 1) {
		_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
	}
	/* begin rotateRight: */
	_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
	/* end rotateRight: */
	_bits = _rot;
	/* end smallFloatBitsOf: */
	memcpy(&_value, &_bits, sizeof(_value));
	_rcvr = _value;
	goto l5;
	l5:
	;
	/* end smallFloatValueOf: */
	/* begin stackTopPut: */
	_aValue = floatObjectOf(log(_rcvr));
	unsignedLongAtput(GIV(stackPointer), _aValue);
	/* end stackTopPut: */
}
/* InterpreterPrimitives>>#primitiveSmallFloatMultiply */
static void
primitiveSmallFloatMultiply(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	double _arg;
	usqLong _bits;
	usqLong _bits2;
	sqInt _floatOrIntOop;
	sqInt _floatOrIntOop2;
	double _rcvr;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	if (((_tagBits = _floatOrIntOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop));
			_rot = ((usqInt) ((usqInt) _floatOrIntOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l5;
			}
			_rcvr = null;
			goto l5;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop ) << _shift) ) ) >> _shift) == _floatOrIntOop))) {
			_rcvr = ((double) (_floatOrIntOop >> 3) );
			goto l5;
		}
	} else {
		if (((longAt(_floatOrIntOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l5;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l5:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop2 = unsignedLongAt(GIV(stackPointer));
	if (((_tagBits2 = _floatOrIntOop2 & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop2));
			_rot2 = ((usqInt) ((usqInt) _floatOrIntOop2 ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l8;
			}
			_arg = null;
			goto l8;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop2 ) << _shift2) ) ) >> _shift2) == _floatOrIntOop2))) {
			_arg = ((double) (_floatOrIntOop2 >> 3) );
			goto l8;
		}
	} else {
		if (((longAt(_floatOrIntOop2)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop2 + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l8;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l8:
	;
	/* end loadFloatOrIntFrom: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushFloat: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), floatObjectOf(_rcvr * _arg));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushFloat: */
	} else {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		/* end primitiveFailFor: */
	}
}
/* InterpreterPrimitives>>#primitiveSmallFloatNotEqual */
static void
primitiveSmallFloatNotEqual(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	double _arg;
	usqLong _bits;
	usqLong _bits2;
	sqInt _floatOrIntOop;
	sqInt _floatOrIntOop2;
	double _rcvr;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	if (((_tagBits = _floatOrIntOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop));
			_rot = ((usqInt) ((usqInt) _floatOrIntOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l5;
			}
			_rcvr = null;
			goto l5;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop ) << _shift) ) ) >> _shift) == _floatOrIntOop))) {
			_rcvr = ((double) (_floatOrIntOop >> 3) );
			goto l5;
		}
	} else {
		if (((longAt(_floatOrIntOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l5;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l5:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop2 = unsignedLongAt(GIV(stackPointer));
	if (((_tagBits2 = _floatOrIntOop2 & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop2));
			_rot2 = ((usqInt) ((usqInt) _floatOrIntOop2 ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l8;
			}
			_arg = null;
			goto l8;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop2 ) << _shift2) ) ) >> _shift2) == _floatOrIntOop2))) {
			_arg = ((double) (_floatOrIntOop2 >> 3) );
			goto l8;
		}
	} else {
		if (((longAt(_floatOrIntOop2)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop2 + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l8;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l8:
	;
	/* end loadFloatOrIntFrom: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushBool: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((!(_rcvr == _arg))
			 ? GIV(trueObj)
			 : GIV(falseObj)));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushBool: */
	} else {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		/* end primitiveFailFor: */
	}
}
/* InterpreterPrimitives>>#primitiveSmallFloatSine */
static void
primitiveSmallFloatSine(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aValue;
	usqLong _bits;
	sqInt _oop;
	double _rcvr;
	usqLong _rot;
	double _value;

	/* begin smallFloatValueOf: */
	_oop = unsignedLongAt(GIV(stackPointer));
	_value = 0;
	/* begin smallFloatBitsOf: */
	assert(isImmediateFloat(_oop));
	_rot = ((usqInt) ((usqInt) _oop ) ) >> (numTagBits());
	if (_rot > 1) {
		_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
	}
	/* begin rotateRight: */
	_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
	/* end rotateRight: */
	_bits = _rot;
	/* end smallFloatBitsOf: */
	memcpy(&_value, &_bits, sizeof(_value));
	_rcvr = _value;
	goto l5;
	l5:
	;
	/* end smallFloatValueOf: */
	/* begin stackTopPut: */
	_aValue = floatObjectOf(sin(_rcvr));
	unsignedLongAtput(GIV(stackPointer), _aValue);
	/* end stackTopPut: */
}
/* InterpreterPrimitives>>#primitiveSmallFloatSquareRoot */
static void
primitiveSmallFloatSquareRoot(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aValue;
	usqLong _bits;
	sqInt _oop;
	double _rcvr;
	usqLong _rot;
	double _value;

	/* begin smallFloatValueOf: */
	_oop = unsignedLongAt(GIV(stackPointer));
	_value = 0;
	/* begin smallFloatBitsOf: */
	assert(isImmediateFloat(_oop));
	_rot = ((usqInt) ((usqInt) _oop ) ) >> (numTagBits());
	if (_rot > 1) {
		_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
	}
	/* begin rotateRight: */
	_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
	/* end rotateRight: */
	_bits = _rot;
	/* end smallFloatBitsOf: */
	memcpy(&_value, &_bits, sizeof(_value));
	_rcvr = _value;
	goto l5;
	l5:
	;
	/* end smallFloatValueOf: */
	if (_rcvr >= 0.0) {
		/* begin stackTopPut: */
		_aValue = floatObjectOf(sqrt(_rcvr));
		unsignedLongAtput(GIV(stackPointer), _aValue);
		/* end stackTopPut: */
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	}
}
/* InterpreterPrimitives>>#primitiveSmallFloatSubtract */
static void
primitiveSmallFloatSubtract(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	double _arg;
	usqLong _bits;
	usqLong _bits2;
	sqInt _floatOrIntOop;
	sqInt _floatOrIntOop2;
	double _rcvr;
	double _result;
	double _result2;
	usqLong _rot;
	usqLong _rot2;
	sqInt _shift;
	sqInt _shift2;
	char *_sp;
	sqInt _tagBits;
	sqInt _tagBits2;
	double _value;
	double _value2;

	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_result = 0;
	_result2 = 0;
	_value = 0;
	_value2 = 0;
	if (((_tagBits = _floatOrIntOop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop));
			_rot = ((usqInt) ((usqInt) _floatOrIntOop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				_rcvr = _value;
				goto l5;
			}
			_rcvr = null;
			goto l5;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop ) << _shift) ) ) >> _shift) == _floatOrIntOop))) {
			_rcvr = ((double) (_floatOrIntOop >> 3) );
			goto l5;
		}
	} else {
		if (((longAt(_floatOrIntOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop + BaseHeaderSize, _result);
			_rcvr = _result;
			goto l5;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_rcvr = 0.0;
	l5:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	_floatOrIntOop2 = unsignedLongAt(GIV(stackPointer));
	if (((_tagBits2 = _floatOrIntOop2 & (tagMask()))) != 0) {
		if (_tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrIntOop2));
			_rot2 = ((usqInt) ((usqInt) _floatOrIntOop2 ) ) >> (numTagBits());
			if (_rot2 > 1) {
				_rot2 += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot2 = (_rot2 << 0x3F) + (((usqInt) ((usqInt) _rot2 ) ) >> 1);
			/* end rotateRight: */
			_bits2 = _rot2;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value2, &_bits2, sizeof(_value2));
				_arg = _value2;
				goto l8;
			}
			_arg = null;
			goto l8;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits2 == (smallIntegerTag())) && (((_shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrIntOop2 ) << _shift2) ) ) >> _shift2) == _floatOrIntOop2))) {
			_arg = ((double) (_floatOrIntOop2 >> 3) );
			goto l8;
		}
	} else {
		if (((longAt(_floatOrIntOop2)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrIntOop2 + BaseHeaderSize, _result2);
			_arg = _result2;
			goto l8;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	_arg = 0.0;
	l8:
	;
	/* end loadFloatOrIntFrom: */
	if (!GIV(primFailCode)) {
		/* begin pop:thenPushFloat: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), floatObjectOf(_rcvr - _arg));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushFloat: */
	} else {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		/* end primitiveFailFor: */
	}
}
/*	Multiply the receiver by the power of the argument. */
/* InterpreterPrimitives>>#primitiveSmallFloatTimesTwoPower */
static void
primitiveSmallFloatTimesTwoPower(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _arg;
	sqInt _rcvr;
	sqInt _result;
	char *_sp;
	int _twiceMaxExponent;

	_arg = unsignedLongAt(GIV(stackPointer));
	if (!(((_arg & 7) == 1))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			return;
		}
	}
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if ((assert(isImmediateFloat(_rcvr)), ((usqInt) _rcvr ) <= ((1U << (numTagBits())) + (smallFloatTag())))) {
		_result = _rcvr;
	} else {
		_arg = _arg >> 3;
		_twiceMaxExponent = 2 * (1U << 11);
		if (_arg < -_twiceMaxExponent) {
			{
				assert(isImmediateFloat(_rcvr));
				_result = _rcvr & ((1U << (numTagBits())) + (tagMask()));
			}
		} else {
			if (_arg > _twiceMaxExponent) {
				_arg = _twiceMaxExponent;
			}
			_result = floatObjectOf(ldexp(smallFloatValueOf(_rcvr), ((int) _arg )));
		}
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _result);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* InterpreterPrimitives>>#primitiveSmallFloatTruncated */
static void
primitiveSmallFloatTruncated(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _bits;
	sqInt _oop;
	double _rcvr;
	usqLong _rot;
	double _trunc;
	double _value;

	/* begin smallFloatValueOf: */
	_oop = unsignedLongAt(GIV(stackPointer));
	_trunc = 0;
	_value = 0;
	/* begin smallFloatBitsOf: */
	assert(isImmediateFloat(_oop));
	_rot = ((usqInt) ((usqInt) _oop ) ) >> (numTagBits());
	if (_rot > 1) {
		_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
	}
	/* begin rotateRight: */
	_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
	/* end rotateRight: */
	_bits = _rot;
	/* end smallFloatBitsOf: */
	memcpy(&_value, &_bits, sizeof(_value));
	_rcvr = _value;
	goto l4;
	l4:
	;
	/* end smallFloatValueOf: */
	modf(_rcvr, &_trunc);
	if (((_trunc >= ((double) MinSmallInteger )) && (_trunc <= ((double) MaxSmallInteger ))) && ((((((usqInt) ((sqInt) _trunc ) ) >> 60) + 1) & 15) <= 1)) {
		unsignedLongAtput(GIV(stackPointer), ((((usqInt) ((sqInt) _trunc ) ) << 3) | 1));
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	}
}
/* InterpreterPrimitives>>#primitiveSomeInstance */
static void
primitiveSomeInstance(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _class;
	sqInt _instance;
	char *_sp;

	_class = unsignedLongAt(GIV(stackPointer));
	_instance = initialInstanceOf(_class);
	if (_instance == null) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	} else {
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _instance);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/*	Return the first object in the heap. */
/* InterpreterPrimitives>>#primitiveSomeObject */
static void
primitiveSomeObject(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _object;
	char *_sp;

	/* begin pop: */
	GIV(stackPointer) += (GIV(argumentCount) + 1) * BytesPerWord;
	/* end pop: */
	/* begin push: */
	_object = firstAccessibleObject();
	unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
	GIV(stackPointer) = _sp;
	/* end push: */
}
/*	Return the oop of the SpecialObjectsArray. */
/* InterpreterPrimitives>>#primitiveSpecialObjectsOop */
static void
primitiveSpecialObjectsOop(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_sp;

	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), GIV(specialObjectsOop));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	N.B. IMO we should be able to assume the receiver is a float because this 
	primitive is specific to floats. eem 2/13/2017 */
/* InterpreterPrimitives>>#primitiveSquareRoot */
static void
primitiveSquareRoot(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aValue;
	double _rcvr;

	/* begin stackFloatValue: */
	_rcvr = floatValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	/* end stackFloatValue: */
	if (!GIV(primFailCode) && (_rcvr >= 0.0)) {
		/* begin stackTopPut: */
		_aValue = floatObjectOf(sqrt(_rcvr));
		unsignedLongAtput(GIV(stackPointer), _aValue);
		/* end stackTopPut: */
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	}
}
/* InterpreterPrimitives>>#primitiveStringAt */
static void
primitiveStringAt(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _class;
	sqInt _classFormat;
	sqInt _fixedFields;
	sqInt _fmt;
	sqInt _index;
	unsigned int _integerValue;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _rcvr;
	sqInt _reasonCode;
	sqInt _result;
	char *_sp;
	sqInt _sp2;
	sqInt _sp3;
	sqInt _stSize;
	sqInt _totalLength;

	/* begin commonAt: */
	/* begin initPrimCall */
	GIV(primFailCode) = 0;
	/* end initPrimCall */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_index = unsignedLongAt(GIV(stackPointer));
	if (_rcvr & (tagMask())) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrInappropriate;
		goto l10;
		/* end primitiveFailFor: */
	}
	if (((_index & (smallIntegerTag())) == 0) || ((GIV(argumentCount) > 1) && (((long64At(_rcvr)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		goto l10;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin stObject:at: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin lengthOf:format: */
	/* begin numSlotsOfAny: */
	_numSlots2 = byteAt(_rcvr + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOfAny: */
	if (_fmt <= 5) {
		_totalLength = _numSlots;
		goto l4;
	}
	if (_fmt >= (firstByteFormat())) {
		_totalLength = (_numSlots << (shiftForWord())) - (_fmt & 7);
		goto l4;
	}
	if (_fmt >= (firstShortFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
		goto l4;
	}
	if (_fmt >= (firstLongFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
		goto l4;
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		_totalLength = _numSlots;
		goto l4;
	}
	_totalLength = 0;
	l4:
	;
	/* end lengthOf:format: */
	/* begin fixedFieldsOf:format:length: */
	if ((_fmt >= (sixtyFourBitIndexableFormat())) || (_fmt == 2)) {
		_fixedFields = 0;
		goto l5;
	}
	if (_fmt < 2) {
		_fixedFields = _totalLength;
		goto l5;
	}
	_class = fetchClassOfNonImm(_rcvr);
	/* begin fixedFieldsOfClassFormat: */
	_classFormat = (unsignedLongAt((_class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	_fixedFields = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	/* end fixedFieldsOfClassFormat: */
	l5:
	;
	/* end fixedFieldsOf:format:length: */
	if ((_fmt == (indexablePointersFormat())) && (((long64At(_rcvr)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
		/* begin stackPointerForMaybeMarriedContext: */
		if (((((unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_rcvr)))) {
			_sp3 = stackPointerIndexForFrame(frameOfMarriedContext(_rcvr));
			assert((ReceiverIndex + (_sp3 >> 3)) < (lengthOf(_rcvr)));
			_stSize = _sp3;
			goto l7;
		}
		/* begin fetchStackPointerOf: */
		/* begin fetchPointer:ofObject: */
		_sp2 = unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (!(((_sp2 & 7) == 1))) {
			_stSize = 0;
			goto l7;
		}
		assert((ReceiverIndex + (_sp2 >> 3)) < (lengthOf(_rcvr)));
		_stSize = _sp2 >> 3;
		/* end fetchStackPointerOf: */
		l7:
		;
		/* end stackPointerForMaybeMarriedContext: */
		if ((oopisGreaterThanOrEqualTo(_index, 1)) && ((oopisLessThanOrEqualTo(_index, _stSize)) && (((((unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_rcvr)))))) {
			_result = noInlineTemporaryin(_index - 1, frameOfMarriedContext(_rcvr));
			goto l9;
		}
	} else {
		_stSize = _totalLength - _fixedFields;
	}
	if ((oopisGreaterThanOrEqualTo(_index, ((_fmt >= (firstCompiledMethodFormat()))
		 ? (((literalCountOf(_rcvr)) + LiteralStart) * BytesPerOop) + 1
		 : 1))) && (oopisLessThanOrEqualTo(_index, _stSize))) {
		/* begin subscript:with:format: */
		if (_fmt <= 5) {
			/* begin fetchPointer:ofObject: */
			_result = unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << (shiftForWord())) ));
			goto l9;
			/* end fetchPointer:ofObject: */
		}
		if (_fmt >= (firstByteFormat())) {
			_result = ((((usqInt) (byteAt((_rcvr + BaseHeaderSize) + ((_index + _fixedFields) - 1))) ) << 3) | 1);
			goto l9;
		}
		if (_fmt >= (firstShortFormat())) {
			_result = ((((usqInt) ((unsigned short) (shortAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 1) ))) ) ) << 3) | 1);
			goto l9;
		}
		if (_fmt == (sixtyFourBitIndexableFormat())) {
			_result = positive64BitIntegerFor(long64At((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 3) )));
			goto l9;
		}
		/* begin positive32BitIntegerFor: */
		_integerValue = long32At((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 2) ));
		{
			_result = (((((usqInt) _integerValue ) & 0xFFFFFFFFU) << 3) | 1);
			goto l9;
		}
		/* end positive32BitIntegerFor: */
		/* end subscript:with:format: */
	}
	/* begin primitiveFailFor: */
	_reasonCode = ((_fmt <= 1)
		 ? PrimErrBadReceiver
		 : PrimErrBadIndex);
	GIV(primFailCode) = _reasonCode;
	/* end primitiveFailFor: */
	_result = 0;
	l9:
	;
	/* end stObject:at: */
	if (!GIV(primFailCode)) {
		{
			if (!((_result >= 0) && (_result <= ((1U << 30) - 1)))) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadReceiver;
				goto l10;
				/* end primitiveFailFor: */
			}
			/* begin characterForAscii: */
			_result = ((sqInt) (((usqInt) (_result >> 3) ) << (numTagBits())) ) + (characterTag());
			/* end characterForAscii: */
		}
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _result);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
	l10:
	;
	/* end commonAt: */
}
/* InterpreterPrimitives>>#primitiveStringAtPut */
static void
primitiveStringAtPut(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _charToPut;
	sqInt _class;
	sqInt _classFormat;
	sqInt _fixedFields;
	sqInt _fmt;
	sqInt _index;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _rcvr;
	sqInt _reasonCode;
	sqInt _signedValueToStore;
	char *_sp;
	sqInt _stSize;
	sqInt _totalLength;
	usqLong _unsigned64BitValueToStore;
	unsigned int _unsignedValueToStore;
	sqInt _value;

	/* begin commonAtPut: */
	/* begin initPrimCall */
	GIV(primFailCode) = 0;
	/* end initPrimCall */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_value = unsignedLongAt(GIV(stackPointer));
	if (_rcvr & (tagMask())) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrInappropriate;
		goto l27;
		/* end primitiveFailFor: */
	}
	if (((_index & (smallIntegerTag())) == 0) || ((GIV(argumentCount) > 2) && (((long64At(_rcvr)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		goto l27;
		/* end primitiveFailFor: */
	}
	if (
#    if IMMUTABILITY
			(/* begin isImmutable: */ ((((usqInt) (longAt(_rcvr)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#    else /* IMMUTABILITY */
			0
#    endif /* IMMUTABILITY */
			) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrNoModification;
		goto l27;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	{
		if (_value & (characterTag())) {
			_charToPut = _value - ((characterTag()) - (smallIntegerTag()));
			/* begin stObject:at:put: */
			if (((long64At(_rcvr)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadReceiver;
				goto l14;
				/* end primitiveFailFor: */
			}
			_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
			/* begin lengthOf:format: */
			/* begin numSlotsOfAny: */
			_numSlots2 = byteAt(_rcvr + 7);
			_numSlots = ((_numSlots2 == (numSlotsMask()))
				 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
				 : _numSlots2);
			/* end numSlotsOfAny: */
			if (_fmt <= 5) {
				_totalLength = _numSlots;
				goto l4;
			}
			if (_fmt >= (firstByteFormat())) {
				_totalLength = (_numSlots << (shiftForWord())) - (_fmt & 7);
				goto l4;
			}
			if (_fmt >= (firstShortFormat())) {
				_totalLength = (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
				goto l4;
			}
			if (_fmt >= (firstLongFormat())) {
				_totalLength = (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
				goto l4;
			}
			if (_fmt == (sixtyFourBitIndexableFormat())) {
				_totalLength = _numSlots;
				goto l4;
			}
			_totalLength = 0;
			l4:
			;
			/* end lengthOf:format: */
			/* begin fixedFieldsOf:format:length: */
			if ((_fmt >= (sixtyFourBitIndexableFormat())) || (_fmt == 2)) {
				_fixedFields = 0;
				goto l5;
			}
			if (_fmt < 2) {
				_fixedFields = _totalLength;
				goto l5;
			}
			_class = fetchClassOfNonImm(_rcvr);
			/* begin fixedFieldsOfClassFormat: */
			_classFormat = (unsignedLongAt((_class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
			_fixedFields = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
			/* end fixedFieldsOfClassFormat: */
			l5:
			;
			/* end fixedFieldsOf:format:length: */
			_stSize = _totalLength - _fixedFields;
			if ((oopisGreaterThanOrEqualTo(_index, ((_fmt >= (firstCompiledMethodFormat()))
				 ? (((literalCountOf(_rcvr)) + LiteralStart) * BytesPerOop) + 1
				 : 1))) && (oopisLessThanOrEqualTo(_index, _stSize))) {
				/* begin subscript:with:storing:format: */
				if (_fmt <= 5) {
					/* begin storePointer:ofObject:withValue: */
					assert(!(isForwarded(_rcvr)));
					if (((_rcvr & (tagMask())) == 0) && ((_rcvr & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
						if (((_charToPut & (tagMask())) == 0) && (((_charToPut & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_charToPut >= ((GIV(memoryMap)->newSpaceStart))))) {
							/* begin possibleOldObjectStoreInto: */
							if (!(((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0)) {
								remember(GIV(fromOldSpaceRememberedSet), _rcvr);
							}
							/* end possibleOldObjectStoreInto: */
						}
					}
					/* begin possiblePermObjectStoreInto:value: */
					if (((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0) {
						goto l6;
					}
					if (_charToPut & (tagMask())) {
						goto l6;
					}
					if (!(_rcvr >= 0x20000000000LL)) {
						goto l6;
					}
					if (_charToPut >= 0x20000000000LL) {
						goto l6;
					}
					if ((_charToPut >= GIV(nilObj)) && (_charToPut <= GIV(trueObj))) {
						goto l6;
					}
					if (!(_charToPut >= (startOfObjectMemory(GIV(memoryMap))))) {
						goto l6;
					}
					remember(getFromPermToNewSpaceRememberedSet(), _rcvr);
					l6:
					;
					/* end possiblePermObjectStoreInto:value: */
					unsignedLongAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << (shiftForWord())) ), _charToPut);
					/* end storePointer:ofObject:withValue: */
					goto l12;
				}
				if (_fmt >= (firstByteFormat())) {
					if (!(((_charToPut & 7) == 1))) {
						GIV(primFailCode) = PrimErrBadArgument;
						goto l12;
					}
					_signedValueToStore = _charToPut >> 3;
					if (!((_signedValueToStore >= 0) && (_signedValueToStore <= 0xFF))) {
						GIV(primFailCode) = PrimErrBadArgument;
						goto l12;
					}
					/* begin storeByte:ofObject:withValue: */
					byteAtput((_rcvr + BaseHeaderSize) + ((_index + _fixedFields) - 1), _signedValueToStore);
					/* end storeByte:ofObject:withValue: */
					goto l12;
				}
				if (_fmt >= (firstShortFormat())) {
					if (!(((_charToPut & 7) == 1))) {
						GIV(primFailCode) = PrimErrBadArgument;
						goto l12;
					}
					_signedValueToStore = _charToPut >> 3;
					if (!((_signedValueToStore >= 0) && (_signedValueToStore <= 0xFFFF))) {
						GIV(primFailCode) = PrimErrBadArgument;
						goto l12;
					}
					/* begin storeShort16:ofObject:withValue: */
					shortAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 1) ), _signedValueToStore);
					/* end storeShort16:ofObject:withValue: */
					goto l12;
				}
				if (_fmt == (sixtyFourBitIndexableFormat())) {
					_unsigned64BitValueToStore = positive64BitValueOf(_charToPut);
					if (!GIV(primFailCode)) {
						/* begin storeLong64:ofObject:withValue: */
						long64Atput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 3) ), _unsigned64BitValueToStore);
						/* end storeLong64:ofObject:withValue: */
					}
					goto l12;
				}
				_unsignedValueToStore = positive32BitValueOf(_charToPut);
				if (!GIV(primFailCode)) {
					/* begin storeLong32:ofObject:withValue: */
					uint32AtPointerput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 2) ), _unsignedValueToStore);
					/* end storeLong32:ofObject:withValue: */
				}
				l12:
				;
				/* end subscript:with:storing:format: */
			} else {
				/* begin primitiveFailFor: */
				_reasonCode = ((_fmt <= 1)
					 ? PrimErrBadReceiver
					 : PrimErrBadIndex);
				GIV(primFailCode) = _reasonCode;
				/* end primitiveFailFor: */
			}
			l14:
			;
			/* end stObject:at:put: */
		} else {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			goto l27;
			/* end primitiveFailFor: */
		}
	}
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _value);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
	l27:
	;
	/* end commonAtPut: */
}
/*	<string1> primitiveCompareWith: string2 [collated: order]1 - fetch the parameters from the stack */
/* InterpreterPrimitives>>#primitiveStringCompareWith */
EXPORT(void)
primitiveStringCompareWith(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _c1;
	sqInt _c12;
	sqInt _c2;
	sqInt _c22;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _i;
	sqInt _i2;
	sqInt _min;
	sqInt _min2;
	sqInt _order;
	sqInt _result;
	char *_sp;
	sqInt _string1;
	sqInt _string2;
	sqInt _strLength1;
	sqInt _strLength2;

	_order = 0;
	if (!(GIV(argumentCount) == 1)) {
		if (GIV(argumentCount) != 2) {
			{
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadNumArgs;
				/* end primitiveFailFor: */
				return;
			}
		}
		_order = unsignedLongAt(GIV(stackPointer));
		if (!((((_order & (tagMask())) == 0) && (((((usqInt) (longAt(_order)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat()))) && ((numBytesOfBytes(_order)) == 256))) {
			{
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				/* end primitiveFailFor: */
				return;
			}
		}
	}
	_string1 = unsignedLongAt(GIV(stackPointer) + (GIV(argumentCount) * BytesPerWord));
	_string2 = unsignedLongAt(GIV(stackPointer) + ((GIV(argumentCount) - 1) * BytesPerWord));
	if (!((((_string1 & (tagMask())) == 0) && (((((usqInt) (longAt(_string1)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat()))) && (((_string2 & (tagMask())) == 0) && (((((usqInt) (longAt(_string2)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat()))))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			return;
		}
	}
	/* begin numBytesOfBytes: */
	_fmt = (((usqInt) (longAt(_string1)) ) >> (formatShift())) & (formatMask());
	assert(_fmt >= (firstByteFormat()));
	_strLength1 = ((numSlotsOf(_string1)) << (shiftForWord())) - (_fmt & 7);
	/* end numBytesOfBytes: */
	/* begin numBytesOfBytes: */
	_fmt2 = (((usqInt) (longAt(_string2)) ) >> (formatShift())) & (formatMask());
	assert(_fmt2 >= (firstByteFormat()));
	_strLength2 = ((numSlotsOf(_string2)) << (shiftForWord())) - (_fmt2 & 7);
	/* end numBytesOfBytes: */
	if (_order == null) {
		/* begin rawCompare:length:with:length:accessBlock: */
		_min = ((_strLength1 < _strLength2) ? _strLength1 : _strLength2);
		for (_i = 0; _i < _min; _i += 1) {
			{
				_c1 = byteAt((_string1 + BaseHeaderSize) + _i);
			}
			{
				_c2 = byteAt((_string2 + BaseHeaderSize) + _i);
			}
			if (!(_c1 == _c2)) {
				_result = _c1 - _c2;
				goto l5;
			}
		}
		_result = _strLength1 - _strLength2;
		l5:
		;
		/* end rawCompare:length:with:length:accessBlock: */
	} else {
		/* begin rawCompare:length:with:length:accessBlock: */
		_min2 = ((_strLength1 < _strLength2) ? _strLength1 : _strLength2);
		for (_i2 = 0; _i2 < _min2; _i2 += 1) {
			{
				/* begin fetchByte:ofObject: */
				_c12 = byteAt((_order + BaseHeaderSize) + (byteAt((_string1 + BaseHeaderSize) + _i2)));
				/* end fetchByte:ofObject: */
			}
			{
				/* begin fetchByte:ofObject: */
				_c22 = byteAt((_order + BaseHeaderSize) + (byteAt((_string2 + BaseHeaderSize) + _i2)));
				/* end fetchByte:ofObject: */
			}
			if (!(_c12 == _c22)) {
				_result = _c12 - _c22;
				goto l7;
			}
		}
		_result = _strLength1 - _strLength2;
		l7:
		;
		/* end rawCompare:length:with:length:accessBlock: */
	}
	/* begin methodReturnInteger: */
	/* begin pop:thenPushInteger: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _result ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPushInteger: */
	/* end methodReturnInteger: */
}
/*	<array> primReplaceFrom: start to: stop with: replacement startingAt: 
	repStart  
	<primitive: 105> */
/* InterpreterPrimitives>>#primitiveStringReplace */
static void
primitiveStringReplace(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _array;
	sqInt _arrayFmt;
	sqInt _arrayInstSize;
	sqInt _arrayLength;
	sqInt _class;
	sqInt _class2;
	sqInt _classFormat;
	sqInt _classFormat2;
	sqInt _i;
	int _mustRemember;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots22;
	usqInt _numSlots3;
	sqInt _oop;
	sqInt _repl;
	sqInt _replFmt;
	sqInt _replInstSize;
	sqInt _replLength;
	sqInt _replStart;
	sqInt _srcDelta;
	sqInt _start;
	sqInt _stop;
	sqInt _valuePointer;

	_array = unsignedLongAt(GIV(stackPointer) + (4 * BytesPerWord));
	_start = unsignedLongAt(GIV(stackPointer) + (3 * BytesPerWord));
	_stop = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	_repl = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_replStart = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	if (((_start & (smallIntegerTag())) == 0) || (((_stop & (smallIntegerTag())) == 0) || (((_replStart & (smallIntegerTag())) == 0) || (_repl & (tagMask()))))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			return;
		}
	}
	_start = _start >> 3;
	_stop = _stop >> 3;
	_replStart = _replStart >> 3;
	if ((_stop >= _start) && (
#    if IMMUTABILITY
			(/* begin isImmutable: */ ((((usqInt) (longAt(_array)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#    else /* IMMUTABILITY */
			0
#    endif /* IMMUTABILITY */
			)) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrNoModification;
			/* end primitiveFailFor: */
			return;
		}
	}
	_arrayFmt = (((usqInt) (longAt(_array)) ) >> (formatShift())) & (formatMask());
	/* begin lengthOf:format: */
	/* begin numSlotsOfAny: */
	_numSlots2 = byteAt(_array + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_array - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOfAny: */
	if (_arrayFmt <= 5) {
		_arrayLength = _numSlots;
		goto l17;
	}
	if (_arrayFmt >= (firstByteFormat())) {
		_arrayLength = (_numSlots << (shiftForWord())) - (_arrayFmt & 7);
		goto l17;
	}
	if (_arrayFmt >= (firstShortFormat())) {
		_arrayLength = (_numSlots << ((shiftForWord()) - 1)) - (_arrayFmt & 3);
		goto l17;
	}
	if (_arrayFmt >= (firstLongFormat())) {
		_arrayLength = (_numSlots << ((shiftForWord()) - 2)) - (_arrayFmt & 1);
		goto l17;
	}
	if (_arrayFmt == (sixtyFourBitIndexableFormat())) {
		_arrayLength = _numSlots;
		goto l17;
	}
	_arrayLength = 0;
	l17:
	;
	/* end lengthOf:format: */
	/* begin classFormatFromInstFormat: */
	if (_arrayFmt >= (firstByteFormat())) {
		_arrayFmt = _arrayFmt & -8;
		goto l18;
	}
	if (_arrayFmt <= (sixtyFourBitIndexableFormat())) {
		goto l18;
	}
	if (_arrayFmt < (firstShortFormat())) {
		_arrayFmt = _arrayFmt & -2;
		goto l18;
	}
	_arrayFmt = _arrayFmt & -4;
	l18:
	;
	/* end classFormatFromInstFormat: */
	_replFmt = (((usqInt) (longAt(_repl)) ) >> (formatShift())) & (formatMask());
	/* begin lengthOf:format: */
	/* begin numSlotsOfAny: */
	_numSlots22 = byteAt(_repl + 7);
	_numSlots3 = ((_numSlots22 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_repl - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots22);
	/* end numSlotsOfAny: */
	if (_replFmt <= 5) {
		_replLength = _numSlots3;
		goto l20;
	}
	if (_replFmt >= (firstByteFormat())) {
		_replLength = (_numSlots3 << (shiftForWord())) - (_replFmt & 7);
		goto l20;
	}
	if (_replFmt >= (firstShortFormat())) {
		_replLength = (_numSlots3 << ((shiftForWord()) - 1)) - (_replFmt & 3);
		goto l20;
	}
	if (_replFmt >= (firstLongFormat())) {
		_replLength = (_numSlots3 << ((shiftForWord()) - 2)) - (_replFmt & 1);
		goto l20;
	}
	if (_replFmt == (sixtyFourBitIndexableFormat())) {
		_replLength = _numSlots3;
		goto l20;
	}
	_replLength = 0;
	l20:
	;
	/* end lengthOf:format: */
	/* begin classFormatFromInstFormat: */
	if (_replFmt >= (firstByteFormat())) {
		_replFmt = _replFmt & -8;
		goto l21;
	}
	if (_replFmt <= (sixtyFourBitIndexableFormat())) {
		goto l21;
	}
	if (_replFmt < (firstShortFormat())) {
		_replFmt = _replFmt & -2;
		goto l21;
	}
	_replFmt = _replFmt & -4;
	l21:
	;
	/* end classFormatFromInstFormat: */
	if (!((_arrayFmt == _replFmt) && (_arrayFmt < (firstCompiledMethodFormat())))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrInappropriate;
			/* end primitiveFailFor: */
			return;
		}
	}
	if (_arrayFmt <= 5) {
		/* begin fixedFieldsOf:format:length: */
		if ((_arrayFmt >= (sixtyFourBitIndexableFormat())) || (_arrayFmt == 2)) {
			_arrayInstSize = 0;
			goto l14;
		}
		if (_arrayFmt < 2) {
			_arrayInstSize = _arrayLength;
			goto l14;
		}
		_class = fetchClassOfNonImm(_array);
		/* begin fixedFieldsOfClassFormat: */
		_classFormat = (unsignedLongAt((_class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
		_arrayInstSize = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
		/* end fixedFieldsOfClassFormat: */
		l14:
		;
		/* end fixedFieldsOf:format:length: */
		/* begin fixedFieldsOf:format:length: */
		if ((_replFmt >= (sixtyFourBitIndexableFormat())) || (_replFmt == 2)) {
			_replInstSize = 0;
			goto l15;
		}
		if (_replFmt < 2) {
			_replInstSize = _replLength;
			goto l15;
		}
		_class2 = fetchClassOfNonImm(_repl);
		/* begin fixedFieldsOfClassFormat: */
		_classFormat2 = (unsignedLongAt((_class2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
		_replInstSize = _classFormat2 & ((1U << (fixedFieldsFieldWidth())) - 1);
		/* end fixedFieldsOfClassFormat: */
		l15:
		;
		/* end fixedFieldsOf:format:length: */
		if (!((_start >= 1) && (((_start - 1) <= _stop) && (((_stop + _arrayInstSize) <= _arrayLength) && ((_replStart >= 1) && ((((_stop - _start) + _replStart) + _replInstSize) <= _replLength)))))) {
			{
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadIndex;
				/* end primitiveFailFor: */
				return;
			}
		}
		_start += _arrayInstSize;
		_stop += _arrayInstSize;
		_srcDelta = (_replStart + _replInstSize) - _start;
		if ((_array & (((getMemoryMap())->spaceMaskToUse))) == (((getMemoryMap())->oldSpaceMask))) {
			_mustRemember = 0;
			for (_i = _start - 1; _i < _stop; _i += 1) {
				_oop = unsignedLongAt((_repl + BaseHeaderSize) + ((sqInt) (((usqInt) (_srcDelta + _i) ) << (shiftForWord())) ));
				if (((_oop & (tagMask())) == 0) && (((_oop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_oop >= ((GIV(memoryMap)->newSpaceStart))))) {
					_mustRemember = 1;
				}
				{
					assert(!(isOopForwarded(_array)));
					longAtput((_array + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _oop);
				}
			}
			if (_mustRemember) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_array)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _array);
				}
				/* end possibleOldObjectStoreInto: */
			}
		} else {
			for (_i = _start - 1; _i < _stop; _i += 1) {
				/* begin storePointerUnchecked:ofObject:withValue: */
				_valuePointer = unsignedLongAt((_repl + BaseHeaderSize) + ((sqInt) (((usqInt) (_srcDelta + _i) ) << (shiftForWord())) ));
				assert(!(isOopForwarded(_array)));
				longAtput((_array + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _valuePointer);
				/* end storePointerUnchecked:ofObject:withValue: */
			}
		}
	} else {
		if (!((_start >= 1) && (((_start - 1) <= _stop) && ((_stop <= _arrayLength) && ((_replStart >= 1) && (((_stop - _start) + _replStart) <= _replLength)))))) {
			{
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadIndex;
				/* end primitiveFailFor: */
				return;
			}
		}
		_srcDelta = _replStart - _start;
		if (_arrayFmt >= (firstShortFormat())) {
			if (_arrayFmt >= (firstByteFormat())) {
				for (_i = _start - 1; _i < _stop; _i += 1) {
					/* begin storeByte:ofObject:withValue: */
					byteAtput((_array + BaseHeaderSize) + _i, byteAt((_repl + BaseHeaderSize) + (_srcDelta + _i)));
					/* end storeByte:ofObject:withValue: */
				}
			}
 else {
				for (_i = _start - 1; _i < _stop; _i += 1) {
					/* begin storeShort16:ofObject:withValue: */
					shortAtput((_array + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << 1) ), shortAt((_repl + BaseHeaderSize) + ((sqInt) (((usqInt) (_srcDelta + _i) ) << 1) )));
					/* end storeShort16:ofObject:withValue: */
				}
			}
		}
 else {
			if (_arrayFmt >= (firstLongFormat())) {
				for (_i = _start - 1; _i < _stop; _i += 1) {
					/* begin storeLong32:ofObject:withValue: */
					uint32AtPointerput((_array + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << 2) ), long32At((_repl + BaseHeaderSize) + ((sqInt) (((usqInt) (_srcDelta + _i) ) << 2) )));
					/* end storeLong32:ofObject:withValue: */
				}
			}
 else {
				for (_i = _start - 1; _i < _stop; _i += 1) {
					/* begin storeLong64:ofObject:withValue: */
					long64Atput((_array + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << 3) ), long64At((_repl + BaseHeaderSize) + ((sqInt) (((usqInt) (_srcDelta + _i) ) << 3) )));
					/* end storeLong64:ofObject:withValue: */
				}
			}
		}
	}
	/* begin pop: */
	GIV(stackPointer) += GIV(argumentCount) * BytesPerWord;
	/* end pop: */
}
/* InterpreterPrimitives>>#primitiveSubtract */
static void
primitiveSubtract(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerResult;
	char *_sp;

	/* begin pop2AndPushIntegerIfOK: */
	_integerResult = (stackIntegerValue(1)) - (stackIntegerValue(0));
	if (!GIV(primFailCode)) {
		if ((((((usqInt) _integerResult ) >> 60) + 1) & 15) <= 1) {
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((((usqInt) _integerResult ) << 3) | 1));
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
		} else {
			/* begin success: */
			{
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
			}
			/* end success: */
		}
	}
	/* end pop2AndPushIntegerIfOK: */
}
/*	Primitive arithmetic operations for large integers in 64 bit range */
/* InterpreterPrimitives>>#primitiveSubtractLargeIntegers */
EXPORT(void)
primitiveSubtractLargeIntegers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _a;
	sqInt _aIsNegative;
	usqLong _b;
	sqInt _bIsNegative;
	sqInt _oopArg;
	sqInt _oopRcvr;
	sqInt _oopResult;
	usqLong _result;
	sqInt _resultIsNegative;
	char *_sp;

	_oopArg = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	_oopRcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_aIsNegative = isNegativeIntegerValueOf(_oopRcvr);
	_bIsNegative = isNegativeIntegerValueOf(_oopArg);
	_a = magnitude64BitValueOf(_oopRcvr);
	_b = magnitude64BitValueOf(_oopArg);
	if (GIV(primFailCode)) {
		{
			return;
		}
	}
	if (_aIsNegative != _bIsNegative) {
		if (_a > (0xFFFFFFFFFFFFFFFFULL - _b)) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			{
				return;
			}
		}
		_result = _a + _b;
		_resultIsNegative = _aIsNegative;
	} else {
		if (_a >= _b) {
			_result = _a - _b;
			_resultIsNegative = _aIsNegative;
		} else {
			_result = _b - _a;
			_resultIsNegative = !_aIsNegative;
		}
	}
	_oopResult = magnitude64BitIntegerForneg(_result, _resultIsNegative);
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oopResult);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	}
}
/*	Attempt to test-and-set the ownership of the critical section. If not 
	owned, set the owner to the current process and answer false. If owned by 
	the current process answer true. If owned by some other process answer 
	nil. For simulation if there is an argument it is taken to be the 
	effective activeProcess 
	(see Process>>effectiveProcess). */
/* InterpreterPrimitives>>#primitiveTestAndSetOwnershipOfCriticalSection */
static void
primitiveTestAndSetOwnershipOfCriticalSection(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeProc;
	sqInt _criticalSection;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _owningProcess;
	sqInt _owningProcessIndex;
	char *_sp;
	char *_sp2;
	char *_sp3;

	if (GIV(argumentCount) > 0) {
		_criticalSection = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
		_activeProc = unsignedLongAt(GIV(stackPointer));
	} else {
		_criticalSection = unsignedLongAt(GIV(stackPointer));
		/* begin memoryActiveProcess */
		/* begin fetchPointer:ofObject: */
		/* begin fetchPointer:ofObject: */
		/* begin splObj: */
		/* begin fetchPointer:ofObject: */
		_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		_activeProc = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end memoryActiveProcess */
	}
	_owningProcessIndex = ExcessSignalsIndex;
	_owningProcess = unsignedLongAt((_criticalSection + BaseHeaderSize) + ((sqInt) (((usqInt) _owningProcessIndex ) << (shiftForWord())) ));
	if (_owningProcess == GIV(nilObj)) {
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_criticalSection)));
		if (((_criticalSection & (tagMask())) == 0) && ((_criticalSection & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_activeProc & (tagMask())) == 0) && (((_activeProc & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_activeProc >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_criticalSection)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _criticalSection);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_criticalSection)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l4;
		}
		if (_activeProc & (tagMask())) {
			goto l4;
		}
		if (!(_criticalSection >= 0x20000000000LL)) {
			goto l4;
		}
		if (_activeProc >= 0x20000000000LL) {
			goto l4;
		}
		if ((_activeProc >= GIV(nilObj)) && (_activeProc <= GIV(trueObj))) {
			goto l4;
		}
		if (!(_activeProc >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l4;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _criticalSection);
		l4:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_criticalSection + BaseHeaderSize) + ((sqInt) (((usqInt) _owningProcessIndex ) << (shiftForWord())) ), _activeProc);
		/* end storePointer:ofObject:withValue: */
		{
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), GIV(falseObj));
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
			return;
		}
	}
	if (_owningProcess == _activeProc) {
		{
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp2 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), GIV(trueObj));
			GIV(stackPointer) = _sp2;
			/* end pop:thenPush: */
			return;
		}
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp3 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), GIV(nilObj));
	GIV(stackPointer) = _sp3;
	/* end pop:thenPush: */
}
/*	Multiply the receiver by the power of the argument. */
/* InterpreterPrimitives>>#primitiveTimesTwoPower */
static void
primitiveTimesTwoPower(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _arg;
	double _rcvr;
	double _result;
	char *_sp;
	int _twiceMaxExponent;

	_arg = unsignedLongAt(GIV(stackPointer));
	if (!(((_arg & 7) == 1))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			return;
		}
	}
	_arg = _arg >> 3;
	{
		_twiceMaxExponent = 2 * (1U << 11);
		if (_arg < -_twiceMaxExponent) {
			_arg = -_twiceMaxExponent;
		} else {
			if (_arg > _twiceMaxExponent) {
				_arg = _twiceMaxExponent;
			}
		}
	}
	_rcvr = floatValueOf(unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord)));
	_result = ldexp(_rcvr, ((int) _arg ));
	/* begin pop:thenPushFloat: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), floatObjectOf(_result));
	GIV(stackPointer) = _sp;
	/* end pop:thenPushFloat: */
}
/*	N.B. IMO we should be able to assume the receiver is a float because this 
	primitive is specific to floats. eem 2/13/2017 */
/* InterpreterPrimitives>>#primitiveTruncated */
static void
primitiveTruncated(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	double _rcvr;
	double _trunc;

	/* begin stackFloatValue: */
	_rcvr = floatValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	_trunc = 0;
	/* end stackFloatValue: */
	if (!GIV(primFailCode)) {
		modf(_rcvr, &_trunc);
		if ((_trunc >= ((double) MinSmallInteger )) && (_trunc <= ((double) MaxSmallInteger ))) {
			unsignedLongAtput(GIV(stackPointer), ((((usqInt) ((sqInt) _trunc ) ) << 3) | 1));
		} else {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
		}
	}
}
/*	Primitive. Unload the module with the given name.Reloading of the module will happen *later* automatically, when a  
	function from it is called. This is ensured by invalidating current 
	sessionID.  */
/* InterpreterPrimitives>>#primitiveUnloadModule */
static void
primitiveUnloadModule(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	sqInt _i;
	sqInt _i2;
	usqInt _limit;
	sqInt _limit2;
	sqInt _moduleName;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	if (!(GIV(argumentCount) == 1)) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	_moduleName = unsignedLongAt(GIV(stackPointer));
	if (!(((_moduleName & (tagMask())) == 0) && (((((usqInt) (longAt(_moduleName)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())))) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	if (!(ioUnloadModuleOfLength(oopForPointer(firstIndexableField(_moduleName)), byteSizeOf(_moduleName)))) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	/* begin flushExternalPrimitives */
	/* begin allObjectsDo: */
	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop2 = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop2, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
					flushExternalPrimitiveOf(_objOop2);
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop2 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
					flushExternalPrimitiveOf(_objOop2);
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop2 = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	/* begin allOldSpaceObjectsDo: */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop22 = GIV(nilObj);
	while (1) {
		assert((_objOop22 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop22)) != 0);
		{
			if (isEnumerableObject(_objOop22)) {
				{
					if (((((usqInt) (longAt(_objOop22)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
						flushExternalPrimitiveOf(_objOop22);
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop22 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	/* end allOldSpaceObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (((((usqInt) (longAt(_currentObject)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
					flushExternalPrimitiveOf(_currentObject);
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
	/* begin flushMethodCache */
	for (_i = 1; _i <= MethodCacheSize; _i += 1) {
		GIV(methodCache)[_i] = 0;
	}
	GIV(lastMethodCacheProbeWrite) = 0;
	/* end flushMethodCache */
	/* begin flushExternalPrimitiveTable */
	for (_i2 = 0; _i2 < MaxExternalPrimitiveTableSize; _i2 += 1) {
		externalPrimitiveTable[_i2] = 0;
	}
	GIV(externalPrimitiveTableFirstFreeIndex) = 0;
	/* end flushExternalPrimitiveTable */
	/* end flushExternalPrimitives */
	forceInterruptCheck();
	/* begin pop: */
	GIV(stackPointer) += 1 * BytesPerWord;
	/* end pop: */
}
/*	Update the VMs notion of the current timezone. The VM sets its notion 
	of the timezone once at start-up. If one wants the VM to keep its notion 
	up-to-date arrange to invoke this primitive periodically. */
/* InterpreterPrimitives>>#primitiveUpdateTimezone */
static void
primitiveUpdateTimezone(void)
{
	ioUpdateVMTimezone();
}
/*	Return the value of the microsecond clock in UTC as an integer. 
	This is the number of microseconds since the Smalltalk epoch, 1901/1/1 
	12:00am. The microsecond clock is at least 60 bits wide which means it'll 
	get to around August 
	38435 before it wraps around. Be sure to put it on your calendar. This 
	primitive accesses the time as answered by the OS. */
/* InterpreterPrimitives>>#primitiveUTCMicrosecondClock */
static void
primitiveUTCMicrosecondClock(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _oop;
	char *_sp;

	/* begin pop:thenPush: */
	_oop = positive64BitIntegerFor(ioUTCMicrosecondsNow());
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Answer an array with UTC microseconds since the Smalltalk epoch and the 
	current seconds offset from GMT in the local time zone. Any pointer object 
	with two or more slots) may be supplied as a parameter. */
/* InterpreterPrimitives>>#primitiveUtcAndTimezoneOffset */
static void
primitiveUtcAndTimezoneOffset(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classObj;
	sqInt _resultArray;
	char *_sp;
	sqInt _valuePointer;
	sqInt _valuePointer2;

	if (GIV(argumentCount) > 0) {
		if (GIV(argumentCount) > 1) {
			{
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadNumArgs;
				/* end primitiveFailFor: */
				return;
			}
		}
		_resultArray = unsignedLongAt(GIV(stackPointer));
		if (!((((_resultArray & (tagMask())) == 0) && (((((usqInt) (longAt(_resultArray)) ) >> (formatShift())) & (formatMask())) <= 5)) && ((lengthOfformat(_resultArray, (((usqInt) (longAt(_resultArray)) ) >> (formatShift())) & (formatMask()))) >= 2))) {
			{
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				/* end primitiveFailFor: */
				return;
			}
		}
	} else {
		/* begin instantiateClass:indexableSize: */
		/* begin splObj: */
		/* begin fetchPointer:ofObject: */
		_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		_resultArray = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, 2, 0, 0);
		/* end instantiateClass:indexableSize: */
	}
	{
		/* begin storePointerUnchecked:ofObject:withValue: */
		_valuePointer = ((((usqInt) (ioLocalSecondsOffset()) ) << 3) | 1);
		assert(!(isOopForwarded(_resultArray)));
		longAtput((_resultArray + BaseHeaderSize) + (1U << (shiftForWord())), _valuePointer);
		/* end storePointerUnchecked:ofObject:withValue: */
		/* begin storePointer:ofObject:withValue: */
		_valuePointer2 = positive64BitIntegerFor(ioUTCMicroseconds());
		assert(!(isForwarded(_resultArray)));
		if (((_resultArray & (tagMask())) == 0) && ((_resultArray & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_valuePointer2 & (tagMask())) == 0) && (((_valuePointer2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_valuePointer2 >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_resultArray)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _resultArray);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_resultArray)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l5;
		}
		if (_valuePointer2 & (tagMask())) {
			goto l5;
		}
		if (!(_resultArray >= 0x20000000000LL)) {
			goto l5;
		}
		if (_valuePointer2 >= 0x20000000000LL) {
			goto l5;
		}
		if ((_valuePointer2 >= GIV(nilObj)) && (_valuePointer2 <= GIV(trueObj))) {
			goto l5;
		}
		if (!(_valuePointer2 >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l5;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _resultArray);
		l5:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_resultArray + BaseHeaderSize) + (0U << (shiftForWord())), _valuePointer2);
		/* end storePointer:ofObject:withValue: */
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _resultArray);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Answer an array with UTC microseconds since the Posix epoch and the 
	current seconds offset from GMT in the local time zone. An empty two 
	element array (or any object with two or more slots) may be supplied 
	as a parameter. 
	This is a named (not numbered) primitive in the null module (ie the VM) */
/* InterpreterPrimitives>>#primitiveUtcWithOffset */
EXPORT(sqInt)
primitiveUtcWithOffset(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classObj;
	static usqLong _epochDelta = 2177452800000000ULL;
	sqInt _resultArray;
	char *_sp;
	sqInt _valuePointer;
	sqInt _valuePointer2;

	if (GIV(argumentCount) > 0) {
		if (GIV(argumentCount) > 1) {
			/* begin primitiveFailFor: */
			return (GIV(primFailCode) = PrimErrBadNumArgs);
			/* end primitiveFailFor: */
		}
		_resultArray = unsignedLongAt(GIV(stackPointer));
		if (!((((_resultArray & (tagMask())) == 0) && (((((usqInt) (longAt(_resultArray)) ) >> (formatShift())) & (formatMask())) <= 5)) && ((lengthOfformat(_resultArray, (((usqInt) (longAt(_resultArray)) ) >> (formatShift())) & (formatMask()))) >= 2))) {
			/* begin primitiveFailFor: */
			return (GIV(primFailCode) = PrimErrBadArgument);
			/* end primitiveFailFor: */
		}
	} else {
		/* begin instantiateClass:indexableSize: */
		/* begin splObj: */
		/* begin fetchPointer:ofObject: */
		_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		_resultArray = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, 2, 0, 0);
		/* end instantiateClass:indexableSize: */
	}
	{
		/* begin storePointerUnchecked:ofObject:withValue: */
		_valuePointer = ((((usqInt) (ioLocalSecondsOffset()) ) << 3) | 1);
		assert(!(isOopForwarded(_resultArray)));
		longAtput((_resultArray + BaseHeaderSize) + (1U << (shiftForWord())), _valuePointer);
		/* end storePointerUnchecked:ofObject:withValue: */
		/* begin storePointer:ofObject:withValue: */
		_valuePointer2 = positive64BitIntegerFor((ioUTCMicroseconds()) - _epochDelta);
		assert(!(isForwarded(_resultArray)));
		if (((_resultArray & (tagMask())) == 0) && ((_resultArray & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_valuePointer2 & (tagMask())) == 0) && (((_valuePointer2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_valuePointer2 >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_resultArray)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _resultArray);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_resultArray)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l3;
		}
		if (_valuePointer2 & (tagMask())) {
			goto l3;
		}
		if (!(_resultArray >= 0x20000000000LL)) {
			goto l3;
		}
		if (_valuePointer2 >= 0x20000000000LL) {
			goto l3;
		}
		if ((_valuePointer2 >= GIV(nilObj)) && (_valuePointer2 <= GIV(trueObj))) {
			goto l3;
		}
		if (!(_valuePointer2 >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l3;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _resultArray);
		l3:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_resultArray + BaseHeaderSize) + (0U << (shiftForWord())), _valuePointer2);
		/* end storePointer:ofObject:withValue: */
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _resultArray);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	return 0;
}
/*	Return a string containing the path name of VM's directory. */
/* InterpreterPrimitives>>#primitiveVMPath */
static void
primitiveVMPath(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classObj;
	sqInt _s;
	char *_sp;
	sqInt _sz;

	_sz = vmPathSize();
	/* begin instantiateClass:indexableSize: */
	_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteString ) << (shiftForWord())) ));
	_s = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, _sz, 0, 0);
	/* end instantiateClass:indexableSize: */
	vmPathGetLength(_s + BaseHeaderSize, _sz);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), _s);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* InterpreterPrimitives>>#primitiveWait */
static void
primitiveWait(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeProc;
	sqInt _excessSignals;
	sqInt _inInterpreter;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _sema;

	_sema = unsignedLongAt(GIV(stackPointer));
	/* begin doWaitSemaphore: */
	/* begin doWaitSemaphore:reEnterInterpreter: */
	_excessSignals = fetchIntegerofObject(ExcessSignalsIndex, _sema);
	if (_excessSignals > 0) {
		/* begin storeInteger:ofObject:withValue: */
		if ((((((usqInt) (_excessSignals - 1) ) >> 60) + 1) & 15) <= 1) {
			/* begin storePointerUnchecked:ofObject:withValue: */
			assert(!(isOopForwarded(_sema)));
			longAtput((_sema + BaseHeaderSize) + ((sqInt) (((usqInt) ExcessSignalsIndex ) << (shiftForWord())) ), ((((usqInt) (_excessSignals - 1) ) << 3) | 1));
			/* end storePointerUnchecked:ofObject:withValue: */
		} else {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
		}
		/* end storeInteger:ofObject:withValue: */
	} else {
		_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
		/* begin memoryActiveProcess */
		/* begin fetchPointer:ofObject: */
		/* begin fetchPointer:ofObject: */
		/* begin splObj: */
		/* begin fetchPointer:ofObject: */
		_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		_activeProc = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end memoryActiveProcess */
		addLastLinktoList(_activeProc, _sema);
		transferTofrom(wakeHighestPriority(), CSWait);
		{
			/* begin forProcessPrimitiveReturnToExecutivePostContextSwitch: */
			if (GIV(nextProfileTick) > 0) {
				checkProfileTick(GIV(newMethod));
			}
			returnToExecutivepostContextSwitch(_inInterpreter, 1);
			/* end forProcessPrimitiveReturnToExecutivePostContextSwitch: */
		}
	}
	/* end doWaitSemaphore:reEnterInterpreter: */
	/* end doWaitSemaphore: */
}
/*	Signal the given semaphore from within the interpreter. Used to serialize 
	callbacks.  */
/* InterpreterPrimitives>>#signalNoResume: */
sqInt
signalNoResume(sqInt _aSemaphore)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _empty;

	{
		assert(!(isForwarded(_aSemaphore)));
		_empty = (unsignedLongAt((_aSemaphore + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ))) == GIV(nilObj);
	}
	if (!_empty) {
		putToSleepyieldingIf(removeFirstLinkOfList(_aSemaphore), 1);
	}
	return _empty;
}
/*	Convert the given object into an integer value. 
	The object may be either a SmallInteger or a four-byte LargeInteger. */
/* InterpreterPrimitives>>#signed32BitValueOf: */
int
signed32BitValueOf(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _value64;

	{
		if (((_oop & 7) == 1)) {
			_value64 = _oop >> 3;
			if (((int) _value64 ) != _value64) {
				/* begin primitiveFail */
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
				/* end primitiveFail */
				_value64 = 0;
			}
			return _value64;
		}
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
}
/*	Convert the given object into an integer value. 
	The object may be either a positive SmallInteger or a eight-byte 
	LargeInteger.  */
/* InterpreterPrimitives>>#signed64BitValueOf: */
sqLong
signed64BitValueOf(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _ccIndex;
	sqInt _ccIndex2;
	sqInt _classOop;
	sqInt _classOop2;
	sqInt _fmt;
	usqLong _magnitude;
	int _negative;
	sqInt _ok;
	sqInt _sz;
	sqLong _value;

	if (((_oop & 7) == 1)) {
		return ((sqLong) (_oop >> 3) );
	}
	if (_oop & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	_classOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(_oop)));
	/* begin classIndexOf: */
	_ccIndex2 = (longAt(_oop)) & (classIndexMask());
	/* end classIndexOf: */
	{
		_ok = ClassLargePositiveIntegerCompactIndex == _ccIndex2;
		goto l5;
	}
	l5:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (_ok) {
		_negative = 0;
	} else {
		_negative = 1;
		/* begin isClassOfNonImm:equalTo:compactClassIndex: */
		_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargeNegativeInteger ) << (shiftForWord())) ));
		assert(!(isImmediate(_oop)));
		/* begin classIndexOf: */
		_ccIndex = (longAt(_oop)) & (classIndexMask());
		/* end classIndexOf: */
		{
			_ok = ClassLargeNegativeIntegerCompactIndex == _ccIndex;
			goto l3;
		}
		l3:
		;
		/* end isClassOfNonImm:equalTo:compactClassIndex: */
		if (!_ok) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return 0;
		}
	}
	/* begin numBytesOfBytes: */
	_fmt = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
	assert(_fmt >= (firstByteFormat()));
	_sz = ((numSlotsOf(_oop)) << (shiftForWord())) - (_fmt & 7);
	/* end numBytesOfBytes: */
	if (_sz > (sizeof(sqLong))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	if (_sz > 4) {
		_magnitude = SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((_oop + BaseHeaderSize) + (0U << 3)));
	} else {
		_magnitude = ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_oop + BaseHeaderSize) + (0U << 2)))) );
	}
	if (((_negative)
		 ? _magnitude > 0x8000000000000000ULL
		 : _magnitude >= 0x8000000000000000ULL)) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	if (_negative) {
		_value = 0 - _magnitude;
	} else {
		_value = _magnitude;
	}
	return _value;
}
/*	Answer a signed value of an integer up to the size of a machine word. 
	The object may be either a positive SmallInteger or a LargeInteger of size 
	<= word size. */
/* InterpreterPrimitives>>#signedMachineIntegerValueOf: */
sqIntptr_t
signedMachineIntegerValueOf(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _bs;
	sqInt _ccIndex;
	sqInt _ccIndex2;
	sqInt _classOop;
	sqInt _classOop2;
	sqInt _fmt;
	usqIntptr_t _limit;
	usqIntptr_t _magnitude;
	int _negative;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _ok;
	sqInt _value;

	if (((_oop & 7) == 1)) {
		return _oop >> 3;
	}
	if (_oop & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	_classOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(_oop)));
	/* begin classIndexOf: */
	_ccIndex2 = (longAt(_oop)) & (classIndexMask());
	/* end classIndexOf: */
	{
		_ok = ClassLargePositiveIntegerCompactIndex == _ccIndex2;
		goto l5;
	}
	l5:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (_ok) {
		_negative = 0;
	} else {
		_negative = 1;
		/* begin isClassOfNonImm:equalTo:compactClassIndex: */
		_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargeNegativeInteger ) << (shiftForWord())) ));
		assert(!(isImmediate(_oop)));
		/* begin classIndexOf: */
		_ccIndex = (longAt(_oop)) & (classIndexMask());
		/* end classIndexOf: */
		{
			_ok = ClassLargeNegativeIntegerCompactIndex == _ccIndex;
			goto l3;
		}
		l3:
		;
		/* end isClassOfNonImm:equalTo:compactClassIndex: */
		if (!_ok) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			return null;
			/* end primitiveFail */
		}
	}
	/* begin numBytesOf: */
	_fmt = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_oop)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_oop + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_oop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt >= (firstByteFormat())) {
		_bs = _numBytes - (_fmt & 7);
		goto l7;
	}
	if (_fmt <= (sixtyFourBitIndexableFormat())) {
		_bs = _numBytes;
		goto l7;
	}
	if (_fmt >= (firstShortFormat())) {
		_bs = _numBytes - ((sqInt) (((usqInt) (_fmt & 3) ) << 1) );
		goto l7;
	}
	_bs = _numBytes - ((sqInt) (((usqInt) (_fmt & 1) ) << 2) );
	l7:
	;
	/* end numBytesOf: */
	if (_bs > (sizeof(usqIntptr_t))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	if (((sizeof(sqIntptr_t)) == 8) && (_bs > 4)) {
		_magnitude = SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((_oop + BaseHeaderSize) + (0U << 3)));
	} else {
		_magnitude = ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_oop + BaseHeaderSize) + (0U << 2)))) );
	}
	_limit = ((usqIntptr_t) 1 ) << (((sizeof(sqIntptr_t)) * 8) - 1);
	if (((_negative)
		 ? _magnitude > _limit
		 : _magnitude >= _limit)) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	if (_negative) {
		_value = 0 - _magnitude;
	} else {
		_value = _magnitude;
	}
	return _value;
}
/*	Set the state of the primitive failure code/success flag, iff 
	successBoolean is false. If primFailCode is non-zero a primitive has 
	failed. If primFailCode 
	is greater than one then its value indicates the reason for failure.Use returnTypeC: #sqInt because that's the way it is defined in sq.h. 
	Use no explicit return so that Slang doesn't fail an inlining type-check 
	when a primitive with return type void uses ^self success: false to exit. */
/* InterpreterPrimitives>>#success: */
sqInt
success(sqInt _successBoolean)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (!_successBoolean) {
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
	}
	return 0;
}
/* Spur64BitCoMemoryManager>>#ceScheduleScavenge */
void
ceScheduleScavenge(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	assert(GIV(freeStart) >= GIV(scavengeThreshold));
	/* begin scheduleScavenge */
	GIV(needGCFlag) = 1;
	forceInterruptCheck();
	/* end scheduleScavenge */
}
/* Spur64BitCoMemoryManager>>#classSmallFloat */
sqInt
classSmallFloat(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _fieldIndex;

	/* begin fetchPointer:ofObject: */
	_fieldIndex = smallFloatTag();
	return unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/*	Perform an integrity/leak check using the heapMap. Set a bit at each 
	object's header.Perform an integrity/leak check using the heapMap. Set a bit at each 
	object's header. 
	Override to set a bit at each Cog method */
/* Spur64BitCoMemoryManager>>#clearLeakMapAndMapAccessibleObjects */
static void
clearLeakMapAndMapAccessibleObjects(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	{
		clearHeapMap();
		/* begin allObjectsDo: */
		/* begin allNewSpaceObjectsDo: */
		/* begin allNewSpaceEntitiesDo: */
		_prevPrevObj = (_prevObj = null);
		assert((((pastSpace()).start)) < (((eden()).start)));
		/* begin objectStartingAt: */
		_address = ((pastSpace()).start);
		_numSlots = byteAt(_address + 7);
		_objOop2 = ((_numSlots == (numSlotsMask()))
			 ? _address + BaseHeaderSize
			 : _address);
		/* end objectStartingAt: */
		_limit = GIV(pastSpaceStart);
		while (oopisLessThan(_objOop2, _limit)) {
			{
				assert(isEnumerableObjectNoAssert(_objOop2));
				{
					heapMapAtWordPut(pointerForOop(_objOop2), 1);
				}
			}
			_prevPrevObj = _prevObj;
			_prevObj = _objOop2;
			/* begin objectAfter:limit: */
			_followingWordAddress = addressAfter(_objOop2);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
				_objOop2 = _limit;
				goto l2;
			}
			flag("endianness");
			_followingWord = unsignedLongAt(_followingWordAddress);
			_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress + BaseHeaderSize
				 : _followingWordAddress);
			l2:
			;
			/* end objectAfter:limit: */
		}
		/* begin objectStartingAt: */
		_address2 = ((eden()).start);
		_numSlots2 = byteAt(_address2 + 7);
		_objOop2 = ((_numSlots2 == (numSlotsMask()))
			 ? _address2 + BaseHeaderSize
			 : _address2);
		/* end objectStartingAt: */
		while (oopisLessThan(_objOop2, GIV(freeStart))) {
			{
				assert(isEnumerableObjectNoAssert(_objOop2));
				{
					heapMapAtWordPut(pointerForOop(_objOop2), 1);
				}
			}
			_prevPrevObj = _prevObj;
			_prevObj = _objOop2;
			/* begin objectAfter:limit: */
			_followingWordAddress2 = addressAfter(_objOop2);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
				_objOop2 = GIV(freeStart);
				goto l3;
			}
			flag("endianness");
			_followingWord2 = unsignedLongAt(_followingWordAddress2);
			_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress2 + BaseHeaderSize
				 : _followingWordAddress2);
			l3:
			;
			/* end objectAfter:limit: */
		}
		/* end allNewSpaceEntitiesDo: */
		/* end allNewSpaceObjectsDo: */
		/* begin allOldSpaceObjectsDo: */
		/* begin allOldSpaceObjectsFrom:do: */
		/* begin allOldSpaceEntitiesFrom:do: */
		assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
		_prevPrevObj2 = (_prevObj2 = null);
		_objOop22 = GIV(nilObj);
		while (1) {
			assert((_objOop22 % (allocationUnit())) == 0);
			if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
				break;
			assert((uint64AtPointer(_objOop22)) != 0);
			{
				if (isEnumerableObject(_objOop22)) {
					{
						heapMapAtWordPut(pointerForOop(_objOop22), 1);
					}
				}
			}
			_prevPrevObj2 = _prevObj2;
			_prevObj2 = _objOop22;
			/* begin objectAfter:limit: */
			_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			_followingWordAddress4 = addressAfter(_objOop22);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
				_objOop22 = _limit2;
				goto l7;
			}
			flag("endianness");
			_followingWord4 = unsignedLongAt(_followingWordAddress4);
			_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress4 + BaseHeaderSize
				 : _followingWordAddress4);
			l7:
			;
			/* end objectAfter:limit: */
		}
		/* end allOldSpaceEntitiesFrom:do: */
		/* end allOldSpaceObjectsFrom:do: */
		/* end allOldSpaceObjectsDo: */
		/* begin allPermSpaceObjectsDo: */
		_currentObject = (GIV(memoryMap)->permSpaceStart);
		while (!(_currentObject == GIV(permSpaceFreeStart))) {
			if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
				{
					heapMapAtWordPut(pointerForOop(_currentObject), 1);
				}
			}
			/* begin objectAfter:limit: */
			_followingWordAddress3 = addressAfter(_currentObject);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
				_currentObject = GIV(permSpaceFreeStart);
				goto l6;
			}
			flag("endianness");
			_followingWord3 = unsignedLongAt(_followingWordAddress3);
			_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress3 + BaseHeaderSize
				 : _followingWordAddress3);
			l6:
			;
			/* end objectAfter:limit: */
		}
		/* end allPermSpaceObjectsDo: */
		/* end allObjectsDo: */
	}
	addCogMethodsToHeapMap();
}
/*	Ensure there are no forwarded literals in the argument. */
/* Spur64BitCoMemoryManager>>#ensureNoForwardedLiteralsIn: */
void
ensureNoForwardedLiteralsIn(sqInt _aMethodObj)
{
	followForwardedObjectFieldstoDepth(_aMethodObj, 0);
}
/* Spur64BitCoMemoryManager>>#freeStartAddress */
usqInt
freeStartAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((usqInt) &GIV(freeStart) );
}
/* Spur64BitCoMemoryManager>>#getScavengeThreshold */
usqInt
getScavengeThreshold(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(scavengeThreshold);
}
/*	Answer the header of the argument even though 
	it may have its header word in a forwarding block 
	(which shouldn't happen with Spur). */
/* Spur64BitCoMemoryManager>>#headerWhileForwardingOf: */
static sqLong NoDbgRegParms
headerWhileForwardingOf(sqInt _aCompiledMethodObjOop)
{
	assert(!(isForwarded(_aCompiledMethodObjOop)));
	return long64At(_aCompiledMethodObjOop);
}
/*	A lenient tester of forwarded class indices for inline cache management in 
	the Cogit. */
/* Spur64BitCoMemoryManager>>#isForwardedClassIndex: */
sqInt
isForwardedClassIndex(sqInt _maybeClassIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt entry;
	sqInt _classTablePage;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;

	if (((usqInt) _maybeClassIndex ) >= (1U << (22 - (classTableMajorIndexShift())))) {
		return 0;
	}
	/* begin fetchPointer:ofObject: */
	_fieldIndex = ((usqInt) _maybeClassIndex ) >> (classTableMajorIndexShift());
	_classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_classTablePage == GIV(nilObj)) {
		return 0;
	}
	/* begin fetchPointer:ofObject: */
	_fieldIndex2 = _maybeClassIndex & ((1U << (classTableMajorIndexShift())) - 1);
	entry = unsignedLongAt((_classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	return ((long64At(entry)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
}
/* Spur64BitCoMemoryManager>>#isImmediateClass: */
sqInt
isImmediateClass(sqInt _classObj)
{
	return (instSpecOfClassFormat((unsignedLongAt((_classObj + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3)) == 7;
}
/*	Answer the method header of a CompiledMethod object. 
	If the method has been cogged then the header is a pointer to 
	the CogMethod and the real header will be stored in the CogMethod. */
/* Spur64BitCoMemoryManager>>#methodHeaderOf: */
sqInt
methodHeaderOf(sqInt _methodObj)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _header;

	assert(isCompiledMethod(_methodObj));
	/* begin fetchPointer:ofObject: */
	_header = unsignedLongAt((_methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	return ((((_header & 7) == 1))
		 ? _header
		 : (assert(((usqInt) _header ) < ((GIV(memoryMap)->newSpaceStart))), assert((((((CogMethod *) _header ))->objectHeader)) == (nullHeaderForMachineCodeMethod())), ((((CogMethod *) _header ))->methodHeader)));
}
/* Spur64BitCoMemoryManager>>#needGCFlagAddress */
usqInt
needGCFlagAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((usqInt) &GIV(needGCFlag) );
}
/*	Answer the tag bits for the receiver based on the method's methodClass, if 
	any.  */
/* Spur64BitCoMemoryManager>>#receiverTagBitsForMethod: */
sqInt
receiverTagBitsForMethod(sqInt _aMethodObj)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _literal;
	sqInt _methodClassOrNil;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _offset;

	/* begin methodClassOf: */
	/* begin followLiteral:ofMethod: */
	_offset = (literalCountOfMethodHeader(methodHeaderOf(_aMethodObj))) - 1;
	/* begin followField:ofObject: */
	/* begin fetchPointer:ofObject: */
	_objOop2 = unsignedLongAt((_aMethodObj + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset + LiteralStart) ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_objOop2 & (tagMask())) == 0) && (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		_objOop2 = fixFollowedFieldofObjectwithInitialValue(_offset + LiteralStart, _aMethodObj, _objOop2);
	}
	_literal = _objOop2;
	/* end followField:ofObject: */
	/* end followLiteral:ofMethod: */
	if ((_literal != GIV(nilObj)) && (((_literal & (tagMask())) == 0) && (((((usqInt) (longAt(_literal)) ) >> (formatShift())) & (formatMask())) <= 5))) {
		assert((numSlotsOf(_literal)) > ValueIndex);
		/* begin followField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop = unsignedLongAt((_literal + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_objOop = fixFollowedFieldofObjectwithInitialValue(ValueIndex, _literal, _objOop);
		}
		_methodClassOrNil = _objOop;
		/* end followField:ofObject: */
	} else {
		/* begin nilObject */
		_methodClassOrNil = GIV(nilObj);
		/* end nilObject */
	}
	/* end methodClassOf: */
	if ((_methodClassOrNil == GIV(nilObj)) || ((instSpecOfClassFormat((unsignedLongAt((_methodClassOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3)) != 7)) {
		return 0;
	}
	if (_methodClassOrNil == (fetchPointerofObject(smallIntegerTag(), GIV(classTableFirstPage)))) {
		return smallIntegerTag();
	}
	if (_methodClassOrNil == (fetchPointerofObject(characterTag(), GIV(classTableFirstPage)))) {
		return characterTag();
	}
	assert(_methodClassOrNil == (fetchPointerofObject(smallFloatTag(), GIV(classTableFirstPage))));
	return smallFloatTag();
}
/* Spur64BitCoMemoryManager>>#scavengeThresholdAddress */
usqInt
scavengeThresholdAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((usqInt) &GIV(scavengeThreshold) );
}
/* Spur64BitCoMemoryManager>>#specialObjectsArrayAddress */
usqInt
specialObjectsArrayAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((usqInt) &GIV(specialObjectsOop) );
}
/*	For the purposes of become: send selector to the cogit with obj1, obj2 
	and aBool and answer the result. Undo forwarding for the selector. */
/* Spur64BitCoMemoryManager>>#withoutForwardingOn:and:with:sendToCogit: */
sqInt
withoutForwardingOnandwithsendToCogit(sqInt _obj1, sqInt _obj2, sqInt _aBool, sqInt (*_selector)(sqInt,sqInt,sqInt))
{
	sqInt _referent;
	sqInt _referent2;
	sqInt _targetA;
	sqInt _targetB;

	/* begin followForwarded: */
	assert(isUnambiguouslyForwarder(_obj1));
	/* begin fetchPointer:ofMaybeForwardedObject: */
	_referent = unsignedLongAt((_obj1 + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofMaybeForwardedObject: */
	while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
	}
	_targetA = _referent;
	/* end followForwarded: */
	/* begin followForwarded: */
	assert(isUnambiguouslyForwarder(_obj2));
	/* begin fetchPointer:ofMaybeForwardedObject: */
	_referent2 = unsignedLongAt((_obj2 + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofMaybeForwardedObject: */
	while (((_referent2 & (tagMask())) == 0) && (((long64At(_referent2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent2 = unsignedLongAt((_referent2 + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
	}
	_targetB = _referent2;
	/* end followForwarded: */
	return _selector(_targetA, _targetB, _aBool);
}
/*	Answer the address immediately following an object. */
/* Spur64BitMemoryManager>>#addressAfter: */
static usqInt NoDbgRegParms
addressAfter(sqInt _objOop)
{
	usqInt _numSlots;

	_numSlots = byteAt(_objOop + 7);
	if (_numSlots == 0) {
		return (_objOop + 8) + BaseHeaderSize;
	}
	if (_numSlots == (numSlotsMask())) {
		_numSlots = ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8;
	}
	return (_objOop + BaseHeaderSize) + (((usqInt) _numSlots ) << 3);
}
/*	Answer the given integer with its bytes in the reverse order. */
/* Spur64BitMemoryManager>>#byteSwapped: */
sqInt
byteSwapped(sqInt _w)
{
	return SQ_SWAP_8_BYTES(_w);
}
/*	Answer the total number of bytes in an object including header and 
	possible overflow size header. */
/* Spur64BitMemoryManager>>#bytesInObject: */
static usqInt NoDbgRegParms
bytesInObject(sqInt _objOop)
{
	usqLong _header;
	usqLong _headerNumSlots;
	usqLong _numSlots;

	flag("endianness");
	_header = long64At(_objOop);
	_headerNumSlots = _header >> (numSlotsFullShift());
	if (_headerNumSlots == (numSlotsMask())) {
		_numSlots = ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8;
	} else {
		_numSlots = ((_headerNumSlots == 0)
			 ? 1
			 : _headerNumSlots);
	}
	return (_numSlots << (shiftForWord())) + (((_headerNumSlots == (numSlotsMask()))
		 ? BaseHeaderSize + BaseHeaderSize
		 : BaseHeaderSize));
}
/*	Answer the C double precision floating point value of the argument, 
	or if it is not, answer 0. */
/* Spur64BitMemoryManager>>#dbgFloatValueOf: */
static double NoDbgRegParms
dbgFloatValueOf(sqInt _oop)
{
	usqLong _bits;
	double _result;
	usqLong _rot;
	sqInt _tagBits;
	double _value;

	_result = 0;
	_value = 0;
	if (((_tagBits = _oop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_oop));
			_rot = ((usqInt) ((usqInt) _oop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				return _value;
			}
			return null;
			/* end smallFloatValueOf: */
		}
	}
 else {
		if (((longAt(_oop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_oop + BaseHeaderSize, _result);
			return _result;
		}
	}
	return 0.0;
}
/*	Answer the default amount of memory to allocate for the eden space. 
	The actual value can be set via vmParameterAt: and/or a preference in the 
	ini file. 
	The shootout tests seem to plateau at 5 or 6Mb. 
	 
	Originally, both the 32-bit and 64-bit versions used the same 4Mb default. 
	Measuring the simulator on image start-up, the 64-bit system's eden at the 
	same point in start-up 
	(the first copyBits) is only 8% larger in bytes because it allocates 26% 
	fewer objects. 
	Some 21% of the objects in the 32-bit version's eden are large integers 
	and floats that 
	are representable as 64-bit immediates. 
	 
	But when running benchmarks such as the computer language shootout's 
	binary trees, 
	using the same amount of memory for the 64-bit system causes a significant 
	slow-down and a lot of compactions. So we now use 4Mb for 32-bits and 7Mb 
	for 64-bits. */
/* Spur64BitMemoryManager>>#defaultEdenBytes */
static sqInt
defaultEdenBytes(void)
{
	return (7 * 1024) * 1024;
}
/*	Answer the exponent of the argument, a SmallFloat. 
	See section 61-bit Immediate Floats in the SpurMemoryManager class 
	comment. msb lsb  
	[8expsubset][52mantissa][1s][3tags] */
/* Spur64BitMemoryManager>>#exponentOfSmallFloat: */
static usqInt NoDbgRegParms
exponentOfSmallFloat(sqInt _oop)
{
	usqInt _exp;

	assert((_oop & (tagMask())) == (smallFloatTag()));
	return ((((usqInt) _oop ) <= 15)
		 ? 0
		 : ((_exp = ((usqInt) ((usqInt) _oop ) ) >> (((numTagBits()) + (smallFloatMantissaBits())) + 1)), (_exp + (smallFloatExponentOffset())) - 0x3FE));
}
/* Spur64BitMemoryManager>>#fetchClassTagOf: */
sqInt
fetchClassTagOf(sqInt _oop)
{
	sqInt _tagBits;

	return ((((_tagBits = _oop & (tagMask()))) != 0)
		 ? _tagBits
		 : (longAt(_oop)) & (classIndexMask()));
}
/*	index by word size, and return a pointer as long as the word size */
/* Spur64BitMemoryManager>>#fetchLong32:ofFloatObject: */
static usqInt NoDbgRegParms
fetchLong32ofFloatObject(sqInt _fieldIndex, sqInt _oop)
{
	usqLong _bits;
	usqLong _rot;

	if (!(_oop & (smallFloatTag()))) {
		return long32At((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << 2) ));
	}
	/* begin smallFloatBitsOf: */
	assert(isImmediateFloat(_oop));
	_rot = ((usqInt) ((usqInt) _oop ) ) >> (numTagBits());
	if (_rot > 1) {
		_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
	}
	/* begin rotateRight: */
	_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
	/* end rotateRight: */
	_bits = _rot;
	/* end smallFloatBitsOf: */
	return ((_fieldIndex == 0)
		 ? _bits & 0xFFFFFFFFU
		 : _bits >> 32);
}
/* Spur64BitMemoryManager>>#floatObjectOf: */
sqInt
floatObjectOf(double _aFloat)
{
	usqLong _rawFloat;
	usqLong _rot;

	_rawFloat = 0;
	if (isSmallFloatValue(_aFloat)) {
		/* begin smallFloatObjectOf: */
		assert(isSmallFloatValue(_aFloat));
		memcpy(&_rawFloat, &_aFloat, sizeof(_rawFloat));
		/* begin rotateLeft: */
		_rot = ((_rawFloat >> 0x3F) & 1) + (_rawFloat << 1);
		/* end rotateLeft: */
		if (_rot > 1) {
			_rot -= ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			assert(_rot > 0);
		}
		return (_rot << (numTagBits())) + (smallFloatTag());
		/* end smallFloatObjectOf: */
	}
	return boxedFloatObjectOf(_aFloat);
}
/*	Answer the C double precision floating point value of the argument, 
	or fail if it is not a Float, and answer 0. 
	Note: May be called by translated primitive code. */
/* Spur64BitMemoryManager>>#floatValueOf: */
double
floatValueOf(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _bits;
	double _result;
	usqLong _rot;
	sqInt _tagBits;
	double _value;

	_result = 0;
	_value = 0;
	if (((_tagBits = _oop & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_oop));
			_rot = ((usqInt) ((usqInt) _oop ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				return _value;
			}
			return null;
			/* end smallFloatValueOf: */
		}
	}
 else {
		if (((longAt(_oop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_oop + BaseHeaderSize, _result);
			return _result;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	return 0.0;
}
/*	must have room for a header (single or double) plus the next free pointer */
/* Spur64BitMemoryManager>>#initFreeChunkWithBytes:at: */
static sqInt NoDbgRegParms
initFreeChunkWithBytesat(usqLong _numBytes, sqInt _address)
{
	sqLong _numSlots;

	assert(((_numBytes % (allocationUnit())) == 0) && (_numBytes >= (BaseHeaderSize + BytesPerOop)));
	if (_numBytes >= (((sqInt) (((usqInt) (numSlotsMask()) ) << (shiftForWord())) ) + BaseHeaderSize)) {
		_numSlots = ((usqInt) ((_numBytes - BaseHeaderSize) - BaseHeaderSize) ) >> (shiftForWord());
		{
			longAtput(_address, ((sqInt) (((usqInt) (numSlotsMask()) ) << (numSlotsFullShift())) ) + _numSlots);
			longAtput(_address + 8, ((sqInt) (((usqInt) (numSlotsMask()) ) << (numSlotsFullShift())) ));
		}
		return _address + 8;
	}
	_numSlots = ((usqInt) (_numBytes - BaseHeaderSize) ) >> (shiftForWord());
	assert(_numSlots < (numSlotsMask()));
	longAtput(_address, ((sqLong) (((usqLong) _numSlots ) << (numSlotsFullShift())) ));
	return _address;
}
/*	must have room for a double header */
/* Spur64BitMemoryManager>>#initSegmentBridgeWithBytes:at: */
static void NoDbgRegParms
initSegmentBridgeWithBytesat(usqLong _numBytes, sqInt _address)
{
	sqLong _numSlots;

	assert(((_numBytes % (allocationUnit())) == 0) && (_numBytes >= (BaseHeaderSize + BaseHeaderSize)));
	_numSlots = ((usqInt) ((_numBytes - BaseHeaderSize) - BaseHeaderSize) ) >> (shiftForWord());
	if (_numSlots == 0) {
		longAtput(_address, (((1U << (pinnedBitShift())) + (1ULL << (markedBitFullShift()))) + ((sqInt) (((usqInt) (sixtyFourBitIndexableFormat()) ) << (formatShift())) )) + (segmentBridgePun()));
	} else {
		{
			longAtput(_address, ((sqInt) (((usqInt) (numSlotsMask()) ) << (numSlotsFullShift())) ) + _numSlots);
			longAtput(_address + BaseHeaderSize, (((((sqInt) (((usqInt) (numSlotsMask()) ) << (numSlotsFullShift())) ) + (1U << (pinnedBitShift()))) + (1ULL << (markedBitFullShift()))) + ((sqInt) (((usqInt) (sixtyFourBitIndexableFormat()) ) << (formatShift())) )) + (segmentBridgePun()));
		}
	}
}
/*	Allocate an instance of a variable class, excepting CompiledMethod. */
/* Spur64BitMemoryManager>>#instantiateClass:indexableSize:isPinned:isOldSpace: */
sqInt
instantiateClassindexableSizeisPinnedisOldSpace(sqInt _classObj, usqInt _nElements, sqInt _isPinned, sqInt _isOldSpace)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classFormat;
	sqInt _classFormat2;
	sqInt _classIndex;
	sqInt _classObj2;
	sqInt _err;
	sqInt _fillValue;
	sqInt _hash;
	int _hasToScheduleScavenge;
	sqInt _instSpec;
	sqInt _newObj;
	sqInt _newObj2;
	usqInt _numBytes;
	usqInt _numSlots;
	usqInt _p;

	/* begin formatOfClassSafe: */
	_classObj2 = ((((_classObj & (tagMask())) == 0) && (((long64At(_classObj)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))
		 ? noInlineFollowForwarded(_classObj)
		 : _classObj);
	if (!((_classObj2 & (tagMask())) == 0)) {
		_classFormat = -1;
		goto l11;
	}
	if (!((numSlotsOfAny(_classObj2)) >= InstanceSpecificationIndex)) {
		_classFormat = -1;
		goto l11;
	}
	/* begin fetchPointer:ofObject: */
	_classFormat2 = unsignedLongAt((_classObj2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (!(((_classFormat2 & 7) == 1))) {
		_classFormat = -1;
		goto l11;
	}
	_classFormat = _classFormat2 >> 3;
	l11:
	;
	/* end formatOfClassSafe: */
	if (_classFormat == -1) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadReceiver;
		/* end primitiveFailFor: */
		return null;
	}
	_instSpec = (((usqInt) _classFormat ) >> (fixedFieldsFieldWidth())) & (formatMask());
	_classIndex = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask());
	_fillValue = 0;
	switch (_instSpec) {
		case 2:
		{
			_numSlots = _nElements;
			_fillValue = GIV(nilObj);
		}
		break;
		case indexablePointersFormat():
		case weakArrayFormat():
		{
			_numSlots = (_classFormat & ((1U << (fixedFieldsFieldWidth())) - 1)) + _nElements;
			_fillValue = GIV(nilObj);
		}
		break;
		case sixtyFourBitIndexableFormat():
		{
			_numSlots = _nElements;
		}
		break;
		case firstLongFormat():
		{
			if ((_classIndex == ClassFloatCompactIndex) && (_nElements != 2)) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadReceiver;
				/* end primitiveFailFor: */
				return null;
			}
			_numSlots = (_nElements + 1) / 2;
			_instSpec += _nElements & 1;
		}
		break;
		case firstShortFormat():
		{
			_numSlots = (_nElements + 3) / 4;
			_instSpec += (4 - _nElements) & 3;
		}
		break;
		case firstByteFormat():
		{
			_numSlots = (_nElements + 7) / 8;
			_instSpec += (8 - _nElements) & 7;
		}
		break;
		default:
		{
			if ((_nElements != 0) || (_instSpec > 5)) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadReceiver;
				/* end primitiveFailFor: */
				return null;
			}
			_numSlots = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
			_fillValue = GIV(nilObj);
		}
	}
	if (_classIndex == 0) {
		{
			assert(addressCouldBeClassObj(_classObj));
			_classIndex = ((((_hash = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask()))) != 0)
				 ? _hash
				 : ((objCouldBeClassObj(_classObj))
					 ? ((((_err = enterIntoClassTable(_classObj))) != 0)
						 ? -_err
						 : (/* begin rawHashBitsOf: */ (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask()) /* end rawHashBitsOf: */))
					 : -PrimErrBadReceiver));
		}
		if (_classIndex < 0) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = -_classIndex;
			/* end primitiveFailFor: */
			return null;
		}
	}
	if ((_numSlots > (((GIV(maxSlotsForNewSpaceAlloc) == 0)
		 ? (/* begin fixedFieldsOfClassFormatMask */ (1U << (fixedFieldsFieldWidth())) - 1 /* end fixedFieldsOfClassFormatMask */)
		 : GIV(maxSlotsForNewSpaceAlloc)))) || (_isPinned || _isOldSpace)) {
		if (_numSlots > 0x10000000000LL) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrUnsupported;
			/* end primitiveFailFor: */
			return null;
		}
		_newObj = ((_isPinned)
			 ? allocateSlotsForPinningInOldSpacebytesformatclassIndex(_numSlots, ((_numSlots == 0)
				 ? 8 + BaseHeaderSize
				 : (_numSlots << (shiftForWord())) + (((_numSlots >= (numSlotsMask()))
					 ? BaseHeaderSize + BaseHeaderSize
					 : BaseHeaderSize))), _instSpec, _classIndex)
			 : allocateSlotsInOldSpacebytesformatclassIndex(_numSlots, ((_numSlots == 0)
				 ? 8 + BaseHeaderSize
				 : (_numSlots << (shiftForWord())) + (((_numSlots >= (numSlotsMask()))
					 ? BaseHeaderSize + BaseHeaderSize
					 : BaseHeaderSize))), _instSpec, _classIndex));
	} else {
		/* begin allocateSlots:format:classIndex:isPinned:isOldSpace: */
		if (_numSlots >= (numSlotsMask())) {
			if ((((usqInt) _numSlots ) >> 56) > 0) {
				_newObj = null;
				goto l12;
			}
			_numBytes = (BaseHeaderSize + BaseHeaderSize) + (_numSlots * BytesPerOop);
		} else {
			_numBytes = BaseHeaderSize + (((_numSlots < 1)
				 ? 8
				 : _numSlots * BytesPerOop));
		}
		_hasToScheduleScavenge = (GIV(freeStart) + _numBytes) > GIV(scavengeThreshold);
		if (_hasToScheduleScavenge || 0) {
			if (_hasToScheduleScavenge) {
				if (!GIV(needGCFlag)) {
					/* begin scheduleScavenge */
					GIV(needGCFlag) = 1;
					forceInterruptCheck();
					/* end scheduleScavenge */
				}
			}
			{
				_newObj = allocateSlotsInOldSpacebytesformatclassIndex(_numSlots, _numBytes, _instSpec, _classIndex);
				goto l12;
			}
		}
		_newObj2 = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(GIV(freeStart), _numSlots, _instSpec, _classIndex, 0);
		assert((_numBytes % (allocationUnit())) == 0);
		assert((_newObj2 % (allocationUnit())) == 0);
		GIV(freeStart) += _numBytes;
		_newObj = _newObj2;
		l12:
		;
		/* end allocateSlots:format:classIndex:isPinned:isOldSpace: */
	}
	if (_newObj == null) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrNoMemory;
		/* end primitiveFailFor: */
	} else {
		/* begin fillObj:numSlots:with: */
		assert(oopisLessThan(((_newObj + BaseHeaderSize) + (_numSlots * BytesPerOop)) - 1, addressAfter(_newObj)));
		for (_p = ((usqInt) (_newObj + BaseHeaderSize) ); _p <= ((usqInt) (((_newObj + BaseHeaderSize) + (_numSlots * BytesPerOop)) - 1) ); _p += 8) {
			longAtput(_p, _fillValue);
		}
		/* end fillObj:numSlots:with: */
	}
	return _newObj;
}
/*	Convert the integer value, assumed to be in SmallInteger range, into a 
	tagged SmallInteger object. 
	In C, use a shift and an add to set the tag bit. 
	In Smalltalk we have to work harder because the simulator works with 
	strictly positive bit patterns. */
/* Spur64BitMemoryManager>>#integerObjectOf: */
sqInt
integerObjectOf(sqInt _value)
{
	return (((usqInt) _value ) << (numTagBits())) + 1;
}
/*	Translator produces 'oop >> 3' */
/* Spur64BitMemoryManager>>#integerValueOf: */
sqInt
integerValueOf(sqInt _oop)
{
	return (((((usqInt) _oop ) >> 63) == 1)
		 ? ((((((-(numTagBits())) < 0) ? (((usqInt) _oop ) >> (-(-(numTagBits())))) : (((usqInt) _oop ) << (-(numTagBits()))))) & 0x1FFFFFFFFFFFFFFFLL) - 0x1FFFFFFFFFFFFFFFLL) - 1
		 : (((-(numTagBits())) < 0) ? (((usqInt) _oop ) >> (-(-(numTagBits())))) : (((usqInt) _oop ) << (-(numTagBits())))));
}
/* Spur64BitMemoryManager>>#isImmediateFloat: */
static sqInt NoDbgRegParms
isImmediateFloat(sqInt _oop)
{
	return _oop & (smallFloatTag());
}
/* Spur64BitMemoryManager>>#isIntegerObject: */
sqInt
isIntegerObject(sqInt _oop)
{
	return _oop & (smallIntegerTag());
}
/*	Answer if the given value can be represented as a Smalltalk integer value. 
	In 64-bits we use a 3 bit tag which leaves 61 bits for 2's complement 
	signed integers. In C, use a shift add and mask to test if the top 4 bits 
	are all the same. 
	Since 16rFFFFFFFFFFFFFFFF >> 60 = 16rF the computation intValue >> 60 + 1 
	bitAnd: 16rF 
	maps in-range -ve values to 0 and in-range +ve values to 1. */
/* Spur64BitMemoryManager>>#isIntegerValue: */
sqInt
isIntegerValue(sqInt _intValue)
{
	return (((((usqInt) _intValue ) >> 60) + 1) & 15) <= 1;
}
/*	To have a prev pointer, which follows the next pointer, we need at least 
	two slots. */
/* Spur64BitMemoryManager>>#isLilliputianSize: */
static sqInt NoDbgRegParms
isLilliputianSize(sqInt _chunkBytes)
{
	assert(_chunkBytes >= (BaseHeaderSize + (allocationUnit())));
	return _chunkBytes == (BaseHeaderSize + 8);
}
/* Spur64BitMemoryManager>>#isMarked: */
sqInt
isMarked(sqInt _objOop)
{
	return ((((usqInt) (longAt(_objOop)) ) >> (markedBitFullShift())) & 1) != 0;
}
/* Spur64BitMemoryManager>>#isSmallFloatValue: */
static sqInt NoDbgRegParms
isSmallFloatValue(double _aFloat)
{
	usqLong _exponent;
	usqLong _rawFloat;

	_rawFloat = 0;
	memcpy(&_rawFloat, &_aFloat, sizeof(_rawFloat));
	_exponent = (_rawFloat >> (smallFloatMantissaBits())) & 0x7FF;
	return ((_exponent > (smallFloatExponentOffset()))
		 ? _exponent <= (0xFF + (smallFloatExponentOffset()))
		 : (((_rawFloat & ((1ULL << (smallFloatMantissaBits())) - 1)) == 0)
			 ? _exponent == 0
			 : _exponent == (smallFloatExponentOffset())));
}
/*	Answer the number of indexable units in the given object. 
	For a CompiledMethod, the size of the method header (in bytes) 
	should be subtracted from the result of this method. */
/* Spur64BitMemoryManager>>#lengthOf:format: */
static sqInt NoDbgRegParms
lengthOfformat(sqInt _objOop, sqInt _fmt)
{
	usqInt _numSlots;
	usqInt _numSlots2;

	/* begin numSlotsOfAny: */
	_numSlots2 = byteAt(_objOop + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOfAny: */
	if (_fmt <= 5) {
		return _numSlots;
	}
	if (_fmt >= (firstByteFormat())) {
		return (_numSlots << (shiftForWord())) - (_fmt & 7);
	}
	if (_fmt >= (firstShortFormat())) {
		return (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
	}
	if (_fmt >= (firstLongFormat())) {
		return (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		return _numSlots;
	}
	return 0;
}
/*	Answer the maximum number of slots we are willing to attempt to allocate 
	in an object. 
	Must fit in 56-bits; c.f. bytesInObject: */
/* Spur64BitMemoryManager>>#maxSlotsForAlloc */
static sqInt
maxSlotsForAlloc(void)
{
	return 0x10000000000LL;
}
/*	Answer the number of free lists. We use freeListsMask, a bitmap, to avoid 
	reading empty list heads. This should fit in a machine word to end up in a 
	register during free chunk allocation. */
/* Spur64BitMemoryManager>>#numFreeLists */
static sqInt
numFreeLists(void)
{
	return 64;
}
/*	Reduce the number of indexable fields in objOop, a pointer object, to 
	nSlots. Convert the 
	unused residual to a free chunk. Without changes to 
	numSlotsForShortening:toIndexableSize: this only works for arrayFormat and 
	longFormat objects. 
	Answer the number of bytes returned to free memory, which may be zero if 
	no change 
	was possible. */
/* Spur64BitMemoryManager>>#shorten:toIndexableSize: */
sqInt
shortentoIndexableSize(sqInt _objOop, sqInt _indexableSize)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _bytesBefore;
	sqInt _classIndex;
	sqInt _classIndex2;
	sqInt _classIndex3;
	sqInt _copy;
	sqInt _delta;
	sqInt _format;
	sqInt _formatField;
	sqInt _freeChunk;
	int _hasToScheduleScavenge;
	sqInt _i;
	sqInt _newObj;
	usqInt _numBytes;
	sqInt _numSlots;
	sqInt _valuePointer;

	switch ((((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask())) {
		case 2:
		{
			_numSlots = _indexableSize;
		}
		break;
		case firstLongFormat():
		case (firstLongFormat()) + 1:
		{
			_numSlots = ((_indexableSize * 4) + (BytesPerWord - 1)) / BytesPerWord;
		}
		break;
		default:
		error("Case not found and no otherwise clause");
		_numSlots = -1;
	}
	if (_numSlots == (numSlotsOf(_objOop))) {
		return 0;
	}
	_bytesBefore = bytesInObject(_objOop);
	_delta = _bytesBefore - (((_numSlots == 0)
		 ? 8 + BaseHeaderSize
		 : ((sqInt) (((usqInt) _numSlots ) << (shiftForWord())) ) + (((_numSlots >= (numSlotsMask()))
			 ? BaseHeaderSize + BaseHeaderSize
			 : BaseHeaderSize))));
	flag("this should update format for 32-bit indexable words; too lazy today.");
	if (_delta == 0) {
		return 0;
	}
	if (_delta <= 8) {
		/* begin allocateSlots:format:classIndex: */
		_formatField = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
		_classIndex3 = (longAt(_objOop)) & (classIndexMask());
		/* begin allocateSlots:format:classIndex:isPinned:isOldSpace: */
		if (_numSlots >= (numSlotsMask())) {
			if ((((usqInt) _numSlots ) >> 56) > 0) {
				_copy = null;
				goto l6;
			}
			_numBytes = (BaseHeaderSize + BaseHeaderSize) + (_numSlots * BytesPerOop);
		} else {
			_numBytes = BaseHeaderSize + (((_numSlots < 1)
				 ? 8
				 : _numSlots * BytesPerOop));
		}
		_hasToScheduleScavenge = (GIV(freeStart) + _numBytes) > GIV(scavengeThreshold);
		if (_hasToScheduleScavenge || 0) {
			if (_hasToScheduleScavenge) {
				if (!GIV(needGCFlag)) {
					/* begin scheduleScavenge */
					GIV(needGCFlag) = 1;
					forceInterruptCheck();
					/* end scheduleScavenge */
				}
			}
			{
				_copy = allocateSlotsInOldSpacebytesformatclassIndex(_numSlots, _numBytes, _formatField, _classIndex3);
				goto l6;
			}
		}
		_newObj = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(GIV(freeStart), _numSlots, _formatField, _classIndex3, 0);
		assert((_numBytes % (allocationUnit())) == 0);
		assert((_newObj % (allocationUnit())) == 0);
		GIV(freeStart) += _numBytes;
		_copy = _newObj;
		/* end allocateSlots:format:classIndex:isPinned:isOldSpace: */
		l6:
		;
		/* end allocateSlots:format:classIndex: */
		if (!_copy) {
			error("shorten:toIndexableSize: attempted to shorten to allocationUnit!");
		}
		for (_i = 0; _i < _numSlots; _i += 1) {
			/* begin storePointerUnchecked:ofObject:withValue: */
			_valuePointer = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
			assert(!(isOopForwarded(_copy)));
			longAtput((_copy + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _valuePointer);
			/* end storePointerUnchecked:ofObject:withValue: */
		}
		if (((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0) {
			remember(GIV(fromOldSpaceRememberedSet), _copy);
		}
		/* begin forward:to: */
		/* begin set:classIndexTo:formatTo: */
		_classIndex2 = isForwardedObjectClassIndexPun();
		assert((_classIndex2 >= 0) && (_classIndex2 <= (classIndexMask())));
		assert((7 >= 0) && (7 <= (formatMask())));
		longAtput(_objOop, ((longAt(_objOop)) & (~((usqIntptr_t) (((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) + (classIndexMask())) ))) + (_classIndex2 + (7U << (formatShift()))));
		/* end set:classIndexTo:formatTo: */
		
#    if IMMUTABILITY
		{
			/* begin setIsImmutableOf:to: */
			longAtput(_objOop, (longAt(_objOop)) & (~((usqIntptr_t) (1U << (immutableBitShift())) )));
			/* end setIsImmutableOf:to: */
		}
#    endif /* IMMUTABILITY */
		/* begin storePointer:ofForwarder:withValue: */
		assert(isForwarded(_objOop));
		assert(!(isOopForwarded(_copy)));
		if ((_objOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask))) {
			if (((_copy & (tagMask())) == 0) && (((_copy & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_copy >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _objOop);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l5;
		}
		if (_copy & (tagMask())) {
			goto l5;
		}
		if (!(_objOop >= 0x20000000000LL)) {
			goto l5;
		}
		if (_copy >= 0x20000000000LL) {
			goto l5;
		}
		if ((_copy >= GIV(nilObj)) && (_copy <= GIV(trueObj))) {
			goto l5;
		}
		if (!(_copy >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l5;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _objOop);
		l5:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_objOop + BaseHeaderSize) + (0U << (shiftForWord())), _copy);
		/* end storePointer:ofForwarder:withValue: */
		if ((byteAt(_objOop + 7)) == 0) {
			byteAtput(_objOop + 7, 1);
		}
		/* end forward:to: */
		return 0;
	}
	if ((byteAt(_objOop + 7)) == (numSlotsMask())) {
		/* begin rawOverflowSlotsOf:put: */
		longAtput(_objOop - BaseHeaderSize, ((sqInt) (((usqInt) (numSlotsMask()) ) << 56) ) + _numSlots);
		/* end rawOverflowSlotsOf:put: */
		if (_numSlots < (numSlotsMask())) {
			_delta -= 8;
		}
	} else {
		assert(_numSlots < (numSlotsMask()));
		byteAtput(_objOop + 7, _numSlots);
	}
	_freeChunk = initFreeChunkWithBytesat(_delta, addressAfter(_objOop));
	assert((addressAfter(_freeChunk)) <= ((GIV(memoryMap)->oldSpaceEnd)));
	if (oopisGreaterThanOrEqualToandLessThan(_objOop, (GIV(memoryMap)->oldSpaceStart), (GIV(memoryMap)->oldSpaceEnd))) {
		GIV(totalFreeOldSpace) += _delta;
		addToFreeListbytes(_freeChunk, _delta);
	} else {
		{
			/* begin setClassIndexOf:to: */
			_classIndex = sixtyFourBitLongsClassIndexPun();
			assert((_classIndex >= 0) && (_classIndex <= (classIndexMask())));
			longAtput(_freeChunk, ((longAt(_freeChunk)) & (~((usqIntptr_t) (classIndexMask()) ))) + _classIndex);
			/* end setClassIndexOf:to: */
			/* begin setFormatOf:to: */
			_format = firstLongFormat();
			assert((_format >= 0) && (_format <= (formatMask())));
			longAtput(_freeChunk, ((longAt(_freeChunk)) & (~((usqIntptr_t) ((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) ))) + ((sqInt) (((usqInt) _format ) << (formatShift())) ));
			/* end setFormatOf:to: */
		}
	}
	return _delta;
}
/*	Answer the C double precision floating point value of the argument, a 
	SmallFloat. See section 61-bit Immediate Floats in the SpurMemoryManager 
	class comment. 
	msb lsb  
	Decode:				[8expsubset][52mantissa][1s][3tags]  
	shift away tags:		[ 000 ][8expsubset][52mantissa][1s]  
	add exponent offset:	[ 11 exponent ][52mantissa][1s]  
	rot sign:				[1s][ 11 exponent ][52mantissa] */
/* Spur64BitMemoryManager>>#smallFloatValueOf: */
static double NoDbgRegParms
smallFloatValueOf(sqInt _oop)
{
	usqLong _bits;
	usqLong _rot;
	double _value;

	/* begin smallFloatBitsOf: */
	assert(isImmediateFloat(_oop));
	_value = 0;
	_rot = ((usqInt) ((usqInt) _oop ) ) >> (numTagBits());
	if (_rot > 1) {
		_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
	}
	/* begin rotateRight: */
	_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
	/* end rotateRight: */
	_bits = _rot;
	/* end smallFloatBitsOf: */
	{
		memcpy(&_value, &_bits, sizeof(_value));
		return _value;
	}
	return 0;
}
/*	Answer the total number of bytes in an object without an overflow header, 
	including header bytes. */
/* Spur64BitMemoryManager>>#smallObjectBytesForSlots: */
usqInt
smallObjectBytesForSlots(sqInt _numSlots)
{
	return BaseHeaderSize + (((_numSlots < 1)
		 ? 8
		 : _numSlots * BytesPerOop));
}
/* Spur64BitMemoryManager>>#wordIndexableFormat */
static sqInt
wordIndexableFormat(void)
{
	return sixtyFourBitIndexableFormat();
}
/*	ephemeronCorpse is the corpse of an ephemeron that was copied and 
	forwarded. Later on its surviving copy must be scanned to nil weak 
	references. Thread the corpse onto the weakList. Later, the weakList can 
	be followed, and 
	the forwarding pointer followed to locate the survivor.Should be too infrequent to lower icache density of copyAndForward: */
/* SpurGenerationScavenger>>#addToEphemeronList: */
static void NoDbgRegParms NeverInline
addToEphemeronList(sqInt _ephemeronCorpse)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _ephemeronListOffset;

	assert(!(isScavengeSurvivor(keyOfEphemeron(followForwarded(_ephemeronCorpse)))));
	_ephemeronListOffset = ((!GIV(ephemeronList))
		 ? 0
		 : GIV(ephemeronList));
	/* begin setCorpseOffsetOf:to: */
	assert(isYoung(_ephemeronCorpse));
	assert(isForwarded(_ephemeronCorpse));
	{
		long64Atput(_ephemeronCorpse, headerForSlotshashformatclassIndex(byteAt(_ephemeronCorpse + 7), ((usqInt) _ephemeronListOffset ) >> (formatFieldWidthShift()), _ephemeronListOffset & (formatMask()), isForwardedObjectClassIndexPun()));
	}
	/* end setCorpseOffsetOf:to: */
	/* begin corpseOffsetOf: */
	GIV(ephemeronList) = (((usqInt) (_ephemeronCorpse - (((getMemoryMap())->newSpaceStart))) ) >> 3) + 1;
	/* end corpseOffsetOf: */
	assert((firstCorpse(GIV(ephemeronList))) == _ephemeronCorpse);
}
/*	weakCorpse is the corpse of a weak array that was copied and forwarded. 
	Later on its surviving copy must be scanned to nil weak references. 
	Thread the corpse onto the weakList. Later, the weakList can be followed, 
	and the forwarding pointer followed to locate the survivor.Should be too infrequent to lower icache density of copyAndForward: */
/* SpurGenerationScavenger>>#addToWeakList: */
static void NoDbgRegParms NeverInline
addToWeakList(sqInt _weakCorpse)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _weakListOffset;

	_weakListOffset = ((!GIV(weakList))
		 ? 0
		 : GIV(weakList));
	/* begin setCorpseOffsetOf:to: */
	assert(isYoung(_weakCorpse));
	assert(isForwarded(_weakCorpse));
	{
		long64Atput(_weakCorpse, headerForSlotshashformatclassIndex(byteAt(_weakCorpse + 7), ((usqInt) _weakListOffset ) >> (formatFieldWidthShift()), _weakListOffset & (formatMask()), isForwardedObjectClassIndexPun()));
	}
	/* end setCorpseOffsetOf:to: */
	/* begin corpseOffsetOf: */
	GIV(weakList) = (((usqInt) (_weakCorpse - (((getMemoryMap())->newSpaceStart))) ) >> 3) + 1;
	/* end corpseOffsetOf: */
	assert((firstCorpse(GIV(weakList))) == _weakCorpse);
}
/* SpurGenerationScavenger>>#allNewSpaceObjectsHaveZeroRTRefCount */
static sqInt
allNewSpaceObjectsHaveZeroRTRefCount(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _followingWord;
	sqInt _followingWord2;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _limit;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _prevObj;
	sqInt _prevPrevObj;

	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop2 = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop2, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((((usqInt) (longAt(_objOop2)) ) >> (rememberedBitShift())) & MaxRTRefCount) > 0) {
					return 0;
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l2;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l2:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop2 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((((usqInt) (longAt(_objOop2)) ) >> (rememberedBitShift())) & MaxRTRefCount) > 0) {
					return 0;
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop2 = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	return 1;
}
/* SpurGenerationScavenger>>#allWeakSurvivorsOnWeakList */
static sqInt
allWeakSurvivorsOnWeakList(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _followingWord;
	usqInt _followingWordAddress;
	sqInt _limit;
	usqInt _numSlots;
	sqInt _objOop;

	/* begin allFutureSpaceEntitiesDo: */
	/* begin objectStartingAt: */
	_address = (GIV(futureSpace).start);
	_numSlots = byteAt(_address + 7);
	_objOop = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(futureSurvivorStart);
	while (oopisLessThan(_objOop, _limit)) {
		{
			if (isWeakFormat((((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask()))) {
				if (!(isonWeaklingList(_objOop, GIV(weakList)))) {
					return 0;
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop = _limit;
			goto l2;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l2:
		;
		/* end objectAfter:limit: */
	}
	/* end allFutureSpaceEntitiesDo: */
	return 1;
}
/*	Some time in every scavenger's life there may come a time when someone 
	writes code that stresses 
	the remembered set. One might conclude that if the remembered set is full, 
	then the right thing 
	to do is simply to tenure everything, emptying the remembered set. But in 
	some circumstances this 
	can be counter-productive, and result in the same situation arising soon 
	after tenuring everything. 
	Instead, we can try and selectively prune the remembered set, tenuring 
	only those objects that 
	are referenced by many objects in the remembered set. That's what this 
	algorithm does. It 
	reference counts young objects referenced from the remembered set, and 
	then sets a threshold 
	used to tenure objects often referenced from the remembered set, thereby 
	allowing the remembered 
	set to shrink, while not tenuring everything. 
	 
	Once in a network monitoring application in a galaxy not dissimilar from 
	the one this code inhabits, 
	a tree of nodes referring to large integers was in precisely this 
	situation. The nodes were old, and 
	the integers were in new space. Some of the nodes referred to shared 
	numbers, some their own 
	unique numbers. The numbers were updated frequently. Were new space simply 
	tenured when the 
	remembered set was full, the remembered set would soon fill up as new 
	numbers were computed. 
	Only by selectively pruning the remembered set of nodes that shared data, 
	was a balance achieved 
	whereby the remembered set population was kept small, and tenuring rates 
	were low. */
/* SpurGenerationScavenger>>#computeRefCountToShrinkRememberedSet */
static void NeverInline
computeRefCountToShrinkRememberedSet(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMRememberedSet * self_in_referenceCountRememberedReferentsmaxRefCount;
	int _count;
	sqInt _elephant;
	int _entirePopulation;
	sqInt _header;
	sqInt _i;
	sqInt _i2;
	sqInt _iLimit;
	sqInt _j;
	sqInt _j2;
	long _population[MaxRTRefCount + 1];
	sqInt _refCount;
	sqInt _referent;
	sqInt _referent2;

	memset(_population, 0, (sizeof(long)) * (MaxRTRefCount + 1));
	assert(allNewSpaceObjectsHaveZeroRTRefCount());
	/* begin referenceCountRememberedReferents: */
	/* begin referenceCountRememberedReferents:maxRefCount: */
	/* begin getFromOldSpaceRememberedSet */
	self_in_referenceCountRememberedReferentsmaxRefCount = GIV(fromOldSpaceRememberedSet);
	/* end getFromOldSpaceRememberedSet */
	for (_i2 = 0; _i2 < ((self_in_referenceCountRememberedReferentsmaxRefCount->rememberedSetSize)); _i2 += 1) {
		_elephant = (self_in_referenceCountRememberedReferentsmaxRefCount->rememberedSetArray)[_i2];
		if (((long64At(_elephant)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
			/* begin followForwarded: */
			assert(isUnambiguouslyForwarder(_elephant));
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent2 = unsignedLongAt((_elephant + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
			while (((_referent2 & (tagMask())) == 0) && (((long64At(_referent2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent2 = unsignedLongAt((_referent2 + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
			}
			_elephant = _referent2;
			/* end followForwarded: */
			if (_elephant & (tagMask())) {
				/* begin nilObject */
				_elephant = GIV(nilObj);
				/* end nilObject */
			}
		}
		for (_j2 = 0, _iLimit = (numPointerSlotsOf(_elephant)) - 1; _j2 <= _iLimit; _j2 += 1) {
			/* begin fetchPointer:ofObject: */
			_referent = unsignedLongAt((_elephant + BaseHeaderSize) + ((sqInt) (((usqInt) _j2 ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_referent & (tagMask())) == 0) && ((assert(isNonImmediate(_referent)), (oopisLessThan(_referent, (GIV(memoryMap)->newSpaceEnd))) && (oopisGreaterThanOrEqualTo(_referent, (GIV(memoryMap)->newSpaceStart)))))) {
				/* begin rtRefCountOf: */
				_refCount = (((usqInt) (longAt(_referent)) ) >> (rememberedBitShift())) & MaxRTRefCount;
				/* end rtRefCountOf: */
				if (_refCount < MaxRTRefCount) {
					if (_refCount > 0) {
						(((long *) _population ))[_refCount] = ((((long *) _population ))[_refCount]) - 1;
					}
					_refCount += 1;
					/* begin rtRefCountOf:put: */
					assert((_refCount >= 0) && (_refCount <= MaxRTRefCount));
					_header = longAt(_referent);
					_header = _header & (~((usqIntptr_t) (7U << (rememberedBitShift())) ));
					_header += ((sqInt) (((usqInt) _refCount ) << (rememberedBitShift())) );
					longAtput(_referent, _header);
					/* end rtRefCountOf:put: */
					(((long *) _population ))[_refCount] = ((((long *) _population ))[_refCount]) + 1;
				}
			}
		}
	}
	/* end referenceCountRememberedReferents:maxRefCount: */
	/* end referenceCountRememberedReferents: */
	/* begin setRefCountToShrinkRT: */
	assert((_population[0]) == 0);
	_entirePopulation = 0;
	for (_j = 1; _j <= MaxRTRefCount; _j += 1) {
		_entirePopulation += _population[_j];
	}
	_count = 0;
	_i = MaxRTRefCount + 1;
	while ((_count < (_entirePopulation / 2)) && (((_i -= 1)) >= 0)) {
		_count += _population[_i];
	}
	GIV(refCountToShrinkRT) = ((_i < 0) ? 0 : _i);
	/* end setRefCountToShrinkRT: */
}
/*	A special version of copyAndForward: for objects in the mournQueue. If 
	we're in the good times tenuring regime then copy to futureSpace, 
	otherwise tenure. 
	Also, don't repeat any of the ephemeron processing. */
/* SpurGenerationScavenger>>#copyAndForwardMourner: */
static sqInt NoDbgRegParms
copyAndForwardMourner(sqInt _mourner)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _bytesInObj;
	sqInt _classIndex;
	sqInt _format;
	sqInt _header;
	sqInt _newLocation;
	sqInt _newStart;
	usqInt _startOfSurvivor;
	sqInt _tenure;

	assert((isInEden(_mourner)) || (isInPastSpace(_mourner)));
	_bytesInObj = bytesInObject(_mourner);
	_format = (((usqInt) (longAt(_mourner)) ) >> (formatShift())) & (formatMask());
	_tenure = !((GIV(tenureCriterion) == TenureByAge) && (GIV(tenureThreshold) == 0));
	if (_tenure || ((GIV(futureSurvivorStart) + _bytesInObj) > ((GIV(futureSpace).limit)))) {
		_newLocation = copyToOldSpacebytesformat(_mourner, _bytesInObj, _format);
	} else {
		/* begin copyToFutureSpace:bytes: */
		GIV(statSurvivorCount) += 1;
		assert((GIV(futureSurvivorStart) + _bytesInObj) <= ((GIV(futureSpace).limit)));
		_startOfSurvivor = (((byteAt(_mourner + 7)) == (numSlotsMask()))
			 ? _mourner - BaseHeaderSize
			 : _mourner);
		_newStart = GIV(futureSurvivorStart);
		GIV(futureSurvivorStart) += _bytesInObj;
		memcpy(((void *) _newStart ), ((void *) _startOfSurvivor ), _bytesInObj);
		if (GIV(tenureCriterion) == TenureToShrinkRT) {
			/* begin rtRefCountOf:put: */
			assert((0 >= 0) && (0 <= MaxRTRefCount));
			_header = longAt(_newStart + (_mourner - _startOfSurvivor));
			_header = _header & (~((usqIntptr_t) (7U << (rememberedBitShift())) ));
			_header += 0U << (rememberedBitShift());
			longAtput(_newStart + (_mourner - _startOfSurvivor), _header);
			/* end rtRefCountOf:put: */
		}
		_newLocation = _newStart + (_mourner - _startOfSurvivor);
		/* end copyToFutureSpace:bytes: */
	}
	/* begin forwardSurvivor:to: */
	assert(isInNewSpace(_mourner));
	assert((isInFutureSpace(_newLocation)) || (isInOldSpace(_newLocation)));
	{
		assert(!(isOopForwarded(_mourner)));
		longAtput((_mourner + BaseHeaderSize) + (0U << (shiftForWord())), _newLocation);
	}
	/* begin set:classIndexTo:formatTo: */
	_classIndex = isForwardedObjectClassIndexPun();
	assert((_classIndex >= 0) && (_classIndex <= (classIndexMask())));
	assert((7 >= 0) && (7 <= (formatMask())));
	longAtput(_mourner, ((longAt(_mourner)) & (~((usqIntptr_t) (((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) + (classIndexMask())) ))) + (_classIndex + (7U << (formatShift()))));
	/* end set:classIndexTo:formatTo: */
	/* end forwardSurvivor:to: */
	if (_format == (weakArrayFormat())) {
		addToWeakList(_mourner);
	}
	return _newLocation;
}
/*	copyAndForward: survivor copies a survivor object either to 
	futureSurvivorSpace or, if it is to be promoted, to oldSpace. 
	It leaves a forwarding pointer behind. If the object is weak 
	then corpse is threaded onto the weakList for later treatment. */
/* SpurGenerationScavenger>>#copyAndForward: */
static sqInt NoDbgRegParms
copyAndForward(sqInt _survivor)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _bytesInObj;
	sqInt _classIndex;
	sqInt _format;
	sqInt _header;
	sqInt _newLocation;
	sqInt _newStart;
	usqInt _startOfSurvivor;
	sqInt _tenure;

	assert((isInEden(_survivor)) || (isInPastSpace(_survivor)));
	_bytesInObj = bytesInObject(_survivor);
	_format = (((usqInt) (longAt(_survivor)) ) >> (formatShift())) & (formatMask());
	switch (GIV(tenureCriterion)) {
		case TenureByAge:
		{
			_tenure = _survivor < GIV(tenureThreshold);
		}
		break;
		case TenureByClass:
		{
			_tenure = ((longAt(_survivor)) & (classIndexMask())) == GIV(tenuringClassIndex);
		}
		break;
		case TenureToShrinkRT:
		{
			_tenure = ((((usqInt) (longAt(_survivor)) ) >> (rememberedBitShift())) & MaxRTRefCount) >= GIV(refCountToShrinkRT);
		}
		break;
		default:
		{
			_tenure = 0;
		}
	}
	if (_tenure || ((GIV(futureSurvivorStart) + _bytesInObj) > ((GIV(futureSpace).limit)))) {
		_newLocation = copyToOldSpacebytesformat(_survivor, _bytesInObj, _format);
	} else {
		/* begin copyToFutureSpace:bytes: */
		GIV(statSurvivorCount) += 1;
		assert((GIV(futureSurvivorStart) + _bytesInObj) <= ((GIV(futureSpace).limit)));
		_startOfSurvivor = (((byteAt(_survivor + 7)) == (numSlotsMask()))
			 ? _survivor - BaseHeaderSize
			 : _survivor);
		_newStart = GIV(futureSurvivorStart);
		GIV(futureSurvivorStart) += _bytesInObj;
		memcpy(((void *) _newStart ), ((void *) _startOfSurvivor ), _bytesInObj);
		if (GIV(tenureCriterion) == TenureToShrinkRT) {
			/* begin rtRefCountOf:put: */
			assert((0 >= 0) && (0 <= MaxRTRefCount));
			_header = longAt(_newStart + (_survivor - _startOfSurvivor));
			_header = _header & (~((usqIntptr_t) (7U << (rememberedBitShift())) ));
			_header += 0U << (rememberedBitShift());
			longAtput(_newStart + (_survivor - _startOfSurvivor), _header);
			/* end rtRefCountOf:put: */
		}
		_newLocation = _newStart + (_survivor - _startOfSurvivor);
		/* end copyToFutureSpace:bytes: */
	}
	/* begin forwardSurvivor:to: */
	assert(isInNewSpace(_survivor));
	assert((isInFutureSpace(_newLocation)) || (isInOldSpace(_newLocation)));
	{
		assert(!(isOopForwarded(_survivor)));
		longAtput((_survivor + BaseHeaderSize) + (0U << (shiftForWord())), _newLocation);
	}
	/* begin set:classIndexTo:formatTo: */
	_classIndex = isForwardedObjectClassIndexPun();
	assert((_classIndex >= 0) && (_classIndex <= (classIndexMask())));
	assert((7 >= 0) && (7 <= (formatMask())));
	longAtput(_survivor, ((longAt(_survivor)) & (~((usqIntptr_t) (((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) + (classIndexMask())) ))) + (_classIndex + (7U << (formatShift()))));
	/* end set:classIndexTo:formatTo: */
	/* end forwardSurvivor:to: */
	if (_format == (weakArrayFormat())) {
		addToWeakList(_survivor);
	}
	if ((_format == 5) && (!(isScavengeSurvivor((assert((isNonImmediate(_newLocation)) && (isObjEphemeron(_newLocation))), /* begin fetchPointer:ofObject: */ unsignedLongAt((_newLocation + BaseHeaderSize) + (0U << (shiftForWord()))) /* end fetchPointer:ofObject: */))))) {
		addToEphemeronList(_survivor);
	}
	return _newLocation;
}
/*	Copy survivor to oldSpace. Answer the new oop of the object.Should be too infrequent to lower icache density of copyAndForward: */
/* SpurGenerationScavenger>>#copyToOldSpace:bytes:format: */
static sqInt NoDbgRegParms NeverInline
copyToOldSpacebytesformat(sqInt _survivor, sqInt _bytesInObject, sqInt _formatOfSurvivor)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _field;
	size_t _growResult;
	sqInt _header;
	sqInt _newOop;
	sqInt _newStart;
	sqInt _nTenures;
	sqInt _p;
	usqInt _startOfSurvivor;

	assert((_formatOfSurvivor == (formatOf(_survivor))) && (((!(isMarked(_survivor))) || (GIV(tenureCriterion) == MarkOnTenure)) && ((GIV(tenureCriterion) == TenureToShrinkRT) || ((!(isPinned(_survivor))) && (!(isRemembered(_survivor)))))));
	_nTenures = GIV(statTenures);
	_startOfSurvivor = (((byteAt(_survivor + 7)) == (numSlotsMask()))
		 ? _survivor - BaseHeaderSize
		 : _survivor);
	_newStart = allocateOldSpaceChunkOfBytes(_bytesInObject);
	if (!_newStart) {
		_growResult = growOldSpaceByAtLeastcallingOperation(0, "copying objects to OldSpace during GC");
		_newStart = allocateOldSpaceChunkOfBytes(_bytesInObject);
		if (!_newStart) {
			if (_growResult == null) {
				error("Could not allocate new object in the old space. It was not possible to allocate a new memory segment");
			}
 else {
				error("Could not allocate new object in the old space");
			}
		}
	}
	memcpy(((void *) _newStart ), ((void *) _startOfSurvivor ), _bytesInObject);
	_newOop = _newStart + (_survivor - _startOfSurvivor);
	if (GIV(tenureCriterion) >= (((TenureToShrinkRT < MarkOnTenure) ? TenureToShrinkRT : MarkOnTenure))) {
		if (GIV(tenureCriterion) == TenureToShrinkRT) {
			/* begin rtRefCountOf:put: */
			assert((0 >= 0) && (0 <= MaxRTRefCount));
			_header = longAt(_newOop);
			_header = _header & (~((usqIntptr_t) (7U << (rememberedBitShift())) ));
			_header += 0U << (rememberedBitShift());
			longAtput(_newOop, _header);
			/* end rtRefCountOf:put: */
		}
		if (GIV(tenureCriterion) == MarkOnTenure) {
			/* begin setIsMarkedOf:to: */
			assert(!(isFreeObject(_newOop)));
			unsignedLongAtput(_newOop, (unsignedLongAt(_newOop)) | (1ULL << (markedBitFullShift())));
			/* end setIsMarkedOf:to: */
		}
	}
	GIV(statTenures) = _nTenures + 1;
	if ((_formatOfSurvivor <= 5) || (_formatOfSurvivor >= (firstCompiledMethodFormat()))) {
		for (_p = BaseHeaderSize; _p <= ((_bytesInObject - (_survivor - _startOfSurvivor)) - BytesPerWord); _p += BytesPerWord) {
			_field = longAt(_survivor + _p);
			if (((_field & (tagMask())) == 0) && ((assert(isNonImmediate(_field)), (oopisLessThan(_field, (GIV(memoryMap)->newSpaceEnd))) && (oopisGreaterThanOrEqualTo(_field, (GIV(memoryMap)->newSpaceStart)))))) {
				remember(getFromOldSpaceRememberedSet(), _newOop);
				return _newOop;
			}
		}
	}
	return _newOop;
}
/* SpurGenerationScavenger>>#firstCorpse: */
static uint64_t NoDbgRegParms
firstCorpse(sqInt _headOfCorpseList)
{
	/* begin corpseForCorpseOffset: */
	return ((sqInt) (((usqInt) (_headOfCorpseList - 1) ) << 3) ) + (((getMemoryMap())->newSpaceStart));
	/* end corpseForCorpseOffset: */
}
/*	After the scavenge, if the future space remains full (more than 90%). 
	Useful to configure tenuring for next pass. */
/* SpurGenerationScavenger>>#futureSpaceIsFull */
static sqInt
futureSpaceIsFull(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	float _fractionSurvived;

	_fractionSurvived = ((((GIV(futureSpace).limit)) == ((GIV(futureSpace).start)))
		 ? 0.0
		 : ((double) (GIV(futureSurvivorStart) - ((GIV(futureSpace).start))) ) / (((GIV(futureSpace).limit)) - ((GIV(futureSpace).start))));
	return _fractionSurvived > 0.9;
}
/*	Answer whether the oop has survived a scavenge. This version is 
	for processing weak survivors and must cope with the scavenge in 
	freeUnmarkedObjectsAndSortAndCoalesceFreeSpaceForPigCompact. */
/* SpurGenerationScavenger>>#isMaybeOldScavengeSurvivor: */
static sqInt NoDbgRegParms
isMaybeOldScavengeSurvivor(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _referent;
	sqInt _target;

	if (_oop & (tagMask())) {
		return 1;
	}
	if (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(_oop));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		_target = _referent;
		/* end followForwarded: */
		if (_oop & (tagMask())) {
			return 1;
		}
	} else {
		_target = _oop;
	}
	if (_target >= 0x20000000000LL) {
		return 1;
	}
	return (((_target & (((getMemoryMap())->spaceMaskToUse))) == (((getMemoryMap())->oldSpaceMask)))
		 ? (GIV(tenureCriterion) != MarkOnTenure) || (((((usqInt) (longAt(_target)) ) >> (markedBitFullShift())) & 1) != 0)
		 : oopisGreaterThanOrEqualToandLessThan(_target, ((futureSpace()).start), futureSurvivorStart()));
}
/*	Answer whether the oop has survived a scavenge. This is equivalent to 
	| target | 
	(manager isImmediate: oop) ifTrue: 
	[^true]. 
	target := (manager isForwarded: oop) 
	ifTrue: [manager followForwarded: oop] 
	ifFalse: [oop]. 
	^((manager isInEden: target) 
	or: [(manager isInPastSpace: target)]) not */
/* SpurGenerationScavenger>>#isScavengeSurvivor: */
static sqInt NoDbgRegParms
isScavengeSurvivor(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _referent;
	sqInt _target;

	if (_oop & (tagMask())) {
		return 1;
	}
	if (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(_oop));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		_target = _referent;
		/* end followForwarded: */
	} else {
		_target = _oop;
	}
	return (!(((_target & (tagMask())) == 0) && ((assert(isNonImmediate(_target)), (oopisLessThan(_target, (GIV(memoryMap)->newSpaceEnd))) && (oopisGreaterThanOrEqualTo(_target, (GIV(memoryMap)->newSpaceStart))))))) || (oopisGreaterThanOrEqualToandLessThan(_target, ((futureSpace()).start), futureSurvivorStart()));
}
/* SpurGenerationScavenger>>#is:onWeaklingList: */
static sqInt NoDbgRegParms
isonWeaklingList(sqInt _oop, sqInt _listHead)
{
	sqInt _corpse;
	sqInt _listOffset;

	/* begin firstCorpse: */
	/* begin corpseForCorpseOffset: */
	_corpse = ((sqInt) (((usqInt) (_listHead - 1) ) << 3) ) + (((getMemoryMap())->newSpaceStart));
	/* end corpseForCorpseOffset: */
	/* end firstCorpse: */
	while (_corpse != null) {
		if (_oop == (followForwarded(_corpse))) {
			return 1;
		}
		/* begin nextCorpseOrNil: */
		assert(isYoung(_corpse));
		_listOffset = ((sqInt) (((usqInt) ((uint32AtPointer(_corpse + 4)) & (identityHashHalfWordMask())) ) << (formatFieldWidthShift())) ) + ((((usqInt) (longAt(_corpse)) ) >> (formatShift())) & (formatMask()));
		_corpse = ((uint64_t) (((_listOffset != 0)
			 ? (/* begin corpseForCorpseOffset: */ ((sqInt) (((usqInt) (_listOffset - 1) ) << 3) ) + (((getMemoryMap())->newSpaceStart)) /* end corpseForCorpseOffset: */)
			 : 0)) );
		/* end nextCorpseOrNil: */
	}
	return 0;
}
/* SpurGenerationScavenger>>#mapOopsFromPermSpace */
static void NeverInline
mapOopsFromPermSpace(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMRememberedSet * self_in_saveat;
	VMRememberedSet * self_in_setRememberedSetSize;
	sqInt _aValue;
	sqInt _classFormat;
	sqInt _contextSize;
	int _destIndex;
	sqInt _fmt;
	sqInt _foundNewReferentOrIsWeakling;
	sqInt _header;
	sqInt _header2;
	sqInt _i;
	sqInt _newLocation;
	sqInt _numLiterals;
	sqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots3;
	sqInt _objOop2;
	sqInt _permSpaceMinAddress;
	sqInt _referent2;
	sqInt _referent3;
	sqInt _referrer;
	int _refersOldSpace;
	sqInt _result;
	sqInt _returnValue;
	sqInt _sourceIndex;
	sqInt _sp;
	sqInt _trueObjOop;

	_sourceIndex = (_destIndex = 0);
	while (_sourceIndex < (((getFromPermToNewSpaceRememberedSet())->rememberedSetSize))) {
		_referrer = ((getFromPermToNewSpaceRememberedSet())->rememberedSetArray)[_sourceIndex];
		assert(!(isEphemeron(_referrer)));
		assert(!(isWeakNonImm(_referrer)));
		/* begin scavengeReferentsOfFromPermSpace: */
		_refersOldSpace = 0;
		/* begin getMemoryMap */
		/* end getMemoryMap */
		_trueObjOop = GIV(trueObj);
		/* begin permSpaceInitialAddress */
		_permSpaceMinAddress = 0x20000000000LL;
		/* end permSpaceInitialAddress */
		/* begin scavengeReferentsOf:additionalTestingBlock: */
		/* begin simulationOnly: */
		/* end simulationOnly: */
		_fmt = (((usqInt) (longAt(_referrer)) ) >> (formatShift())) & (formatMask());
		/* begin numStrongSlotsOf:format:ephemeronInactiveIf: */
		if (_fmt <= 5) {
			/* begin numSlotsOf: */
			assert((classIndexOf(_referrer)) > (isForwardedObjectClassIndexPun()));
			_numSlots2 = byteAt(_referrer + 7);
			_numSlots3 = ((_numSlots2 == (numSlotsMask()))
				 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_referrer - BaseHeaderSize)) ) << 8) ) ) ) >> 8
				 : _numSlots2);
			/* end numSlotsOf: */
			if (_fmt <= 2) {
				_numSlots = _numSlots3;
				goto l10;
			}
			if (_fmt == (indexablePointersFormat())) {
				if (((longAt(_referrer)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
					setTraceFlagOnContextsFramesPageIfNeeded(_referrer);
					/* begin fetchStackPointerOf: */
					/* begin fetchPointer:ofObject: */
					_sp = unsignedLongAt((_referrer + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (!(((_sp & 7) == 1))) {
						_contextSize = 0;
						goto l7;
					}
					assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_referrer)));
					_contextSize = _sp >> 3;
					l7:
					;
					/* end fetchStackPointerOf: */
					_numSlots = CtxtTempFrameStart + _contextSize;
					goto l10;
				}
				_numSlots = _numSlots3;
				goto l10;
			}
			if (_fmt == (weakArrayFormat())) {
				/* begin fixedFieldsOfClass: */
				_objOop2 = fetchClassOfNonImm(_referrer);
				/* begin fixedFieldsOfClassFormat: */
				_classFormat = (unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
				_numSlots = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
				goto l10;
				/* end fixedFieldsOfClassFormat: */
				/* end fixedFieldsOfClass: */
			}
			assert(_fmt == (ephemeronFormat()));
			_numSlots = ((isScavengeSurvivor(keyOfEphemeron(_referrer)))
				 ? _numSlots3
				 : 0);
			goto l10;
		}
		if (_fmt == 7) {
			_numSlots = 1;
			goto l10;
		}
		if (_fmt < (firstCompiledMethodFormat())) {
			_numSlots = 0;
			goto l10;
		}
		/* begin methodHeaderOf: */
		assert(isCompiledMethod(_referrer));
		/* begin fetchPointer:ofObject: */
		_header2 = unsignedLongAt((_referrer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_header2 & 7) == 1)) {
			_header = _header2;
		} else {
			assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
			assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
			_header = ((((CogMethod *) _header2 ))->methodHeader);
		}
		/* end methodHeaderOf: */
		{
			assert(((_header & 7) == 1));
			_numLiterals = (_header >> 3) & AlternateHeaderNumLiteralsMask;
		}
		_numSlots = _numLiterals + LiteralStart;
		l10:
		;
		/* end numStrongSlotsOf:format:ephemeronInactiveIf: */
		_foundNewReferentOrIsWeakling = _fmt == (weakArrayFormat());
		for (_i = 0; _i < _numSlots; _i += 1) {
			_referent3 = unsignedLongAt((_referrer + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
			if ((_referent3 & (tagMask())) == 0) {
				if (((long64At(_referent3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					/* begin followForwarded: */
					assert(isUnambiguouslyForwarder(_referent3));
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent2 = unsignedLongAt((_referent3 + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
					while (((_referent2 & (tagMask())) == 0) && (((long64At(_referent2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent2 = unsignedLongAt((_referent2 + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
					}
					_referent3 = _referent2;
					/* end followForwarded: */
				}
				if ((assert(isNonImmediate(_referent3)), (oopisLessThan(_referent3, (GIV(memoryMap)->newSpaceEnd))) && (oopisGreaterThanOrEqualTo(_referent3, (GIV(memoryMap)->newSpaceStart))))) {
					if (oopisGreaterThanOrEqualToandLessThan(_referent3, ((futureSpace()).start), futureSurvivorStart())) {
						_newLocation = _referent3;
						_foundNewReferentOrIsWeakling = 1;
					} else {
						_newLocation = copyAndForward(_referent3);
						if (((_newLocation & (tagMask())) == 0) && (((_newLocation & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_newLocation >= ((GIV(memoryMap)->newSpaceStart))))) {
							_foundNewReferentOrIsWeakling = 1;
						} else {
							{
								if ((_newLocation > _trueObjOop) && (_newLocation < _permSpaceMinAddress)) {
									_refersOldSpace = 1;
								}
							}
						}
					}
					unsignedLongAtput((_referrer + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _newLocation);
				} else {
					unsignedLongAtput((_referrer + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _referent3);
					{
						if ((_referent3 > _trueObjOop) && (_referent3 < _permSpaceMinAddress)) {
							_refersOldSpace = 1;
						}
					}
				}
			}
		}
		_returnValue = _foundNewReferentOrIsWeakling;
		/* end scavengeReferentsOf:additionalTestingBlock: */
		if (_returnValue) {
			_result = 1;
			goto l19;
		}
		if (_refersOldSpace) {
			_result = 2;
			goto l19;
		}
		_result = 3;
		l19:
		;
		/* end scavengeReferentsOfFromPermSpace: */
		if (_result == 1) {
			/* begin save:at: */
			/* begin getFromPermToNewSpaceRememberedSet */
			self_in_saveat = GIV(fromPermToNewSpaceRememberedSet);
			/* end getFromPermToNewSpaceRememberedSet */
			(self_in_saveat->rememberedSetArray)[_destIndex] = _referrer;
			/* end save:at: */
			_destIndex += 1;
		} else {
			/* begin setIsRememberedOf:to: */
			/* begin unsignedLong64At:put: */
			_aValue = (uint64AtPointer(_referrer)) & (~((usqIntptr_t) (1U << (rememberedBitShift())) ));
			uint64AtPointerput(_referrer, _aValue);
			/* end unsignedLong64At:put: */
			/* end setIsRememberedOf:to: */
			if (_result == 2) {
				rememberWithoutMarkingAsRemembered(getFromPermToOldSpaceRememberedSet(), _referrer);
			}
		}
		_sourceIndex += 1;
	}
	/* begin setRememberedSetSize: */
	/* begin getFromPermToNewSpaceRememberedSet */
	self_in_setRememberedSetSize = GIV(fromPermToNewSpaceRememberedSet);
	/* end getFromPermToNewSpaceRememberedSet */
	(self_in_setRememberedSetSize->rememberedSetSize) = _destIndex;
	if (_destIndex < ((self_in_setRememberedSetSize->rememberedSetLimit))) {
		(self_in_setRememberedSetSize->rememberedSetArray)[_destIndex] = 0;
	}
	/* end setRememberedSetSize: */
}
/* SpurGenerationScavenger>>#newSpaceCapacity */
static usqInt
newSpaceCapacity(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((GIV(eden).limit)) - (((((GIV(futureSpace).start)) < ((GIV(pastSpace).start))) ? (GIV(futureSpace).start) : (GIV(pastSpace).start)));
}
/*	For assert checking only. */
/* SpurGenerationScavenger>>#noUnfiredEphemeronsAtEndOfRememberedSet */
static sqInt
noUnfiredEphemeronsAtEndOfRememberedSet(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMRememberedSet * self_in_rememberedSetWithIndexDostartingAt;
	sqInt _i;
	sqInt _referrer;
	sqInt _startIndex;

	/* begin rememberedSetWithIndexDo:startingAt: */
	/* begin getFromOldSpaceRememberedSet */
	self_in_rememberedSetWithIndexDostartingAt = GIV(fromOldSpaceRememberedSet);
	/* end getFromOldSpaceRememberedSet */
	_startIndex = ((getFromOldSpaceRememberedSet())->numRememberedEphemerons);
	for (_i = _startIndex; _i < ((self_in_rememberedSetWithIndexDostartingAt->rememberedSetSize)); _i += 1) {
		{
			_referrer = (self_in_rememberedSetWithIndexDostartingAt->rememberedSetArray)[_i];
			if ((assert(isNonImmediate(_referrer)), isEphemeronFormat((((usqInt) (longAt(_referrer)) ) >> (formatShift())) & (formatMask())))) {
				if (!(isScavengeSurvivor((assert((isNonImmediate(_referrer)) && (isObjEphemeron(_referrer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((_referrer + BaseHeaderSize) + (0U << (shiftForWord()))) /* end fetchPointer:ofObject: */)))) {
					return 0;
				}
			}
		}
	}
	/* end rememberedSetWithIndexDo:startingAt: */
	return 1;
}
/* SpurGenerationScavenger>>#openScavengeLog */
void
openScavengeLog(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	GIV(scavengeLog) = fopen("scavenge.log", "a+");
}
/*	Print the objects in the remembered set. */
/* SpurGenerationScavenger>>#printRememberedSet */
void
printRememberedSet(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMRememberedSet * self_in_rememberedSetWithIndexDo;
	VMRememberedSet * self_in_rememberedSetWithIndexDo2;
	VMRememberedSet * self_in_rememberedSetWithIndexDo3;
	sqInt _i2;
	sqInt _i3;
	sqInt _i4;
	sqInt _oop;

	{
		print("From OldSpace:");
		/* begin cr */
		print("\n");
		/* end cr */
	}
	/* begin rememberedSetWithIndexDo: */
	/* begin getFromOldSpaceRememberedSet */
	self_in_rememberedSetWithIndexDo = GIV(fromOldSpaceRememberedSet);
	/* end getFromOldSpaceRememberedSet */
	/* begin rememberedSetWithIndexDo:startingAt: */
	for (_i2 = 0; _i2 < ((self_in_rememberedSetWithIndexDo->rememberedSetSize)); _i2 += 1) {
		{
			_oop = (self_in_rememberedSetWithIndexDo->rememberedSetArray)[_i2];
			{
				printNum(_i2);
				/* begin space */
				printChar(' ');
				/* end space */
				shortPrintOop(_oop);
			}
		}
	}
	/* end rememberedSetWithIndexDo:startingAt: */
	/* end rememberedSetWithIndexDo: */
	{
		print("From Permpace to OldSpace:");
		/* begin cr */
		print("\n");
		/* end cr */
	}
	/* begin rememberedSetWithIndexDo: */
	/* begin getFromPermToOldSpaceRememberedSet */
	self_in_rememberedSetWithIndexDo2 = GIV(fromPermToOldSpaceRememberedSet);
	/* end getFromPermToOldSpaceRememberedSet */
	/* begin rememberedSetWithIndexDo:startingAt: */
	for (_i3 = 0; _i3 < ((self_in_rememberedSetWithIndexDo2->rememberedSetSize)); _i3 += 1) {
		{
			_oop = (self_in_rememberedSetWithIndexDo2->rememberedSetArray)[_i3];
			{
				printNum(_i3);
				/* begin space */
				printChar(' ');
				/* end space */
				shortPrintOop(_oop);
			}
		}
	}
	/* end rememberedSetWithIndexDo:startingAt: */
	/* end rememberedSetWithIndexDo: */
	{
		print("From Permpace to NewSpace:");
		/* begin cr */
		print("\n");
		/* end cr */
	}
	/* begin rememberedSetWithIndexDo: */
	/* begin getFromPermToNewSpaceRememberedSet */
	self_in_rememberedSetWithIndexDo3 = GIV(fromPermToNewSpaceRememberedSet);
	/* end getFromPermToNewSpaceRememberedSet */
	/* begin rememberedSetWithIndexDo:startingAt: */
	for (_i4 = 0; _i4 < ((self_in_rememberedSetWithIndexDo3->rememberedSetSize)); _i4 += 1) {
		{
			_oop = (self_in_rememberedSetWithIndexDo3->rememberedSetArray)[_i4];
			{
				printNum(_i4);
				/* begin space */
				printChar(' ');
				/* end space */
				shortPrintOop(_oop);
			}
		}
	}
	/* end rememberedSetWithIndexDo:startingAt: */
	/* end rememberedSetWithIndexDo: */
}
/*	There are ephemerons to be scavenged. Scavenge them and fire any whose 
	keys are 
	still in pastSpace and/or eden. The unscavenged ephemerons in this cycle 
	can only be 
	fired if all the unscavenged ephemerons in this cycle are firable, because 
	references to ephemeron keys from unfired ephemerons should prevent the 
	ephemerons with 
	those keys from firing. So scavenge ephemerons with surviving keys, and 
	only if none 
	are found, fire ephemerons with unreferenced keys, and scavenge them. Read 
	the class comment for a more in-depth description of the algorithm. */
/* SpurGenerationScavenger>>#processEphemerons */
static void
processEphemerons(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMRememberedSet * self_in_removeLastEphemeronAndMoveTo;
	VMRememberedSet * self_in_removeLastEphemeronAndMoveTo2;
	VMRememberedSet * self_in_removeLastEphemeronToandSave;
	sqInt _anIndex;
	sqInt _anIndex2;
	sqInt _aValue;
	sqInt _aValue2;
	sqInt _ephemeron;
	sqInt _ephemeron2;
	sqInt _ephemeronCorpse;
	sqInt _hasNewReferents;
	int _i;
	int _i2;
	sqInt _index2;
	sqInt _key;
	sqInt _key2;
	sqInt _listOffset;
	sqLong _newRememberedSetSize;
	sqLong _newRememberedSetSize2;
	sqInt _objStack;
	sqInt _objStack2;
	sqInt _referent;
	sqInt _referent2;
	sqInt _referrer;
	sqInt _unfiredEphemeronsScavenged;
	int _unfiredEphemeronsScavenged2;
	sqInt _valuePointer;
	sqInt _valuePointer2;

	/* begin scavengeUnfiredEphemeronsInRememberedSet */
	_unfiredEphemeronsScavenged2 = 0;
	_i2 = 0;
	while (_i2 < (((getFromOldSpaceRememberedSet())->numRememberedEphemerons))) {
		_referrer = ((getFromOldSpaceRememberedSet())->rememberedSetArray)[_i2];
		assert(isEphemeron(_referrer));
		if (isScavengeSurvivor((assert((isNonImmediate(_referrer)) && (isObjEphemeron(_referrer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((_referrer + BaseHeaderSize) + (0U << (shiftForWord()))) /* end fetchPointer:ofObject: */))) {
			_unfiredEphemeronsScavenged2 = 1;
			_hasNewReferents = scavengeReferentsOfFromOldSpace(_referrer);
			if (_hasNewReferents) {
				/* begin removeLastEphemeronTo:andSave: */
				/* begin getFromOldSpaceRememberedSet */
				self_in_removeLastEphemeronToandSave = GIV(fromOldSpaceRememberedSet);
				/* end getFromOldSpaceRememberedSet */
				/* begin removeLastEphemeronAndKeepIn: */
				(self_in_removeLastEphemeronToandSave->numRememberedEphemerons) = ((self_in_removeLastEphemeronToandSave->numRememberedEphemerons)) - 1;
				(self_in_removeLastEphemeronToandSave->rememberedSetArray)[_i2] = (self_in_removeLastEphemeronToandSave->rememberedSetArray)[(self_in_removeLastEphemeronToandSave->numRememberedEphemerons)];
				/* end removeLastEphemeronAndKeepIn: */
				/* begin save:at: */
				_index2 = (self_in_removeLastEphemeronToandSave->numRememberedEphemerons);
				(self_in_removeLastEphemeronToandSave->rememberedSetArray)[_index2] = _referrer;
				/* end save:at: */
				/* end removeLastEphemeronTo:andSave: */
			} else {
				/* begin removeLastEphemeronAndMoveTo: */
				/* begin getFromOldSpaceRememberedSet */
				self_in_removeLastEphemeronAndMoveTo2 = GIV(fromOldSpaceRememberedSet);
				/* end getFromOldSpaceRememberedSet */
				/* begin removeLastEphemeronAndKeepIn: */
				(self_in_removeLastEphemeronAndMoveTo2->numRememberedEphemerons) = ((self_in_removeLastEphemeronAndMoveTo2->numRememberedEphemerons)) - 1;
				(self_in_removeLastEphemeronAndMoveTo2->rememberedSetArray)[_i2] = (self_in_removeLastEphemeronAndMoveTo2->rememberedSetArray)[(self_in_removeLastEphemeronAndMoveTo2->numRememberedEphemerons)];
				/* end removeLastEphemeronAndKeepIn: */
				/* begin removeByIndexUsingPreviousSize: */
				_anIndex2 = (self_in_removeLastEphemeronAndMoveTo2->numRememberedEphemerons);
				(self_in_removeLastEphemeronAndMoveTo2->previousRememberedSetSize) = ((self_in_removeLastEphemeronAndMoveTo2->previousRememberedSetSize)) - 1;
				_newRememberedSetSize2 = ((self_in_removeLastEphemeronAndMoveTo2->rememberedSetSize)) - 1;
				{
					(self_in_removeLastEphemeronAndMoveTo2->rememberedSetArray)[_anIndex2] = (self_in_removeLastEphemeronAndMoveTo2->rememberedSetArray)[(self_in_removeLastEphemeronAndMoveTo2->previousRememberedSetSize)];
					(self_in_removeLastEphemeronAndMoveTo2->rememberedSetArray)[(self_in_removeLastEphemeronAndMoveTo2->previousRememberedSetSize)] = (self_in_removeLastEphemeronAndMoveTo2->rememberedSetArray)[_newRememberedSetSize2];
				}
				/* begin setRememberedSetSize: */
				(self_in_removeLastEphemeronAndMoveTo2->rememberedSetSize) = _newRememberedSetSize2;
				if (_newRememberedSetSize2 < ((self_in_removeLastEphemeronAndMoveTo2->rememberedSetLimit))) {
					(self_in_removeLastEphemeronAndMoveTo2->rememberedSetArray)[_newRememberedSetSize2] = 0;
				}
				/* end setRememberedSetSize: */
				/* end removeByIndexUsingPreviousSize: */
				/* end removeLastEphemeronAndMoveTo: */
				/* begin setIsRememberedOf:to: */
				/* begin unsignedLong64At:put: */
				_aValue2 = (uint64AtPointer(_referrer)) & (~((usqIntptr_t) (1U << (rememberedBitShift())) ));
				uint64AtPointerput(_referrer, _aValue2);
				/* end unsignedLong64At:put: */
				/* end setIsRememberedOf:to: */
			}
		} else {
			_i2 += 1;
		}
	}
	_unfiredEphemeronsScavenged = _unfiredEphemeronsScavenged2;
	/* end scavengeUnfiredEphemeronsInRememberedSet */
	if (scavengeUnfiredEphemeronsOnEphemeronList()) {
		_unfiredEphemeronsScavenged = 1;
	}
	if (!_unfiredEphemeronsScavenged) {
		/* begin fireEphemeronsInRememberedSet */
		assert(noUnfiredEphemeronsAtEndOfRememberedSet());
		_i = 0;
		while (_i < (((getFromOldSpaceRememberedSet())->numRememberedEphemerons))) {
			_ephemeron = ((getFromOldSpaceRememberedSet())->rememberedSetArray)[_i];
			assert(isEphemeron(_ephemeron));
			{
				assert((isNonImmediate(_ephemeron)) && (isObjEphemeron(_ephemeron)));
				/* begin fetchPointer:ofObject: */
				_key = unsignedLongAt((_ephemeron + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofObject: */
			}
			if (((long64At(_key)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
				/* begin followForwarded: */
				assert(isUnambiguouslyForwarder(_key));
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent = unsignedLongAt((_key + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
				while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
				}
				_key = _referent;
				/* end followForwarded: */
			}
			if (!(isScavengeSurvivor(_key))) {
				/* begin fireEphemeron: */
				{
					/* begin queueMourner: */
					assert((isNonImmediate(_ephemeron)) && (((formatOf(_ephemeron)) == (ephemeronFormat())) || ((formatOf(_ephemeron)) == (weakArrayFormat()))));
					assert(!(((formatOf(_ephemeron)) == (ephemeronFormat())) && (isonObjStack(_ephemeron, GIV(mournQueue)))));
					/* begin push:onObjStack: */
					_objStack = GIV(mournQueue);
					assert(addressCouldBeOop(_ephemeron));
					if (_ephemeron & (tagMask())) {
						assert(_objStack == GIV(markStack));
						assert(addressCouldBeObj(topOfObjStack(((0 == (fetchPointerofObject(ObjStackTopx, _objStack)))
							 ? fetchPointerofObject(ObjStackNextx, _objStack)
							 : _objStack))));
					}
 else {
						assert(!((_objStack == GIV(markStack)) && (isWeakNonImm(_ephemeron))));
						assert((_objStack != GIV(weaklingStack)) || (isWeakNonImm(_ephemeron)));
					}
					noCheckPushonObjStack(_ephemeron, _objStack);
					/* end push:onObjStack: */
					/* end queueMourner: */
					/* begin setFormatOf:to: */
					assert((1 >= 0) && (1 <= (formatMask())));
					longAtput(_ephemeron, ((longAt(_ephemeron)) & (~((usqIntptr_t) ((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) ))) + (1U << (formatShift())));
					/* end setFormatOf:to: */
				}
				/* begin signalFinalization: */
				forceInterruptCheck();
				GIV(pendingFinalizationSignals) += 1;
				/* end signalFinalization: */
				/* end fireEphemeron: */
				/* begin storePointerUnchecked:ofObject:withValue: */
				_valuePointer = copyAndForward(_key);
				assert(!(isOopForwarded(_ephemeron)));
				longAtput((_ephemeron + BaseHeaderSize) + (0U << (shiftForWord())), _valuePointer);
				/* end storePointerUnchecked:ofObject:withValue: */
			}
			if (scavengeReferentsOfFromOldSpace(_ephemeron)) {
				_i += 1;
			} else {
				/* begin setIsRememberedOf:to: */
				/* begin unsignedLong64At:put: */
				_aValue = (uint64AtPointer(_ephemeron)) & (~((usqIntptr_t) (1U << (rememberedBitShift())) ));
				uint64AtPointerput(_ephemeron, _aValue);
				/* end unsignedLong64At:put: */
				/* end setIsRememberedOf:to: */
				/* begin removeLastEphemeronAndMoveTo: */
				/* begin getFromOldSpaceRememberedSet */
				self_in_removeLastEphemeronAndMoveTo = GIV(fromOldSpaceRememberedSet);
				/* end getFromOldSpaceRememberedSet */
				/* begin removeLastEphemeronAndKeepIn: */
				(self_in_removeLastEphemeronAndMoveTo->numRememberedEphemerons) = ((self_in_removeLastEphemeronAndMoveTo->numRememberedEphemerons)) - 1;
				(self_in_removeLastEphemeronAndMoveTo->rememberedSetArray)[_i] = (self_in_removeLastEphemeronAndMoveTo->rememberedSetArray)[(self_in_removeLastEphemeronAndMoveTo->numRememberedEphemerons)];
				/* end removeLastEphemeronAndKeepIn: */
				/* begin removeByIndexUsingPreviousSize: */
				_anIndex = (self_in_removeLastEphemeronAndMoveTo->numRememberedEphemerons);
				(self_in_removeLastEphemeronAndMoveTo->previousRememberedSetSize) = ((self_in_removeLastEphemeronAndMoveTo->previousRememberedSetSize)) - 1;
				_newRememberedSetSize = ((self_in_removeLastEphemeronAndMoveTo->rememberedSetSize)) - 1;
				{
					(self_in_removeLastEphemeronAndMoveTo->rememberedSetArray)[_anIndex] = (self_in_removeLastEphemeronAndMoveTo->rememberedSetArray)[(self_in_removeLastEphemeronAndMoveTo->previousRememberedSetSize)];
					(self_in_removeLastEphemeronAndMoveTo->rememberedSetArray)[(self_in_removeLastEphemeronAndMoveTo->previousRememberedSetSize)] = (self_in_removeLastEphemeronAndMoveTo->rememberedSetArray)[_newRememberedSetSize];
				}
				/* begin setRememberedSetSize: */
				(self_in_removeLastEphemeronAndMoveTo->rememberedSetSize) = _newRememberedSetSize;
				if (_newRememberedSetSize < ((self_in_removeLastEphemeronAndMoveTo->rememberedSetLimit))) {
					(self_in_removeLastEphemeronAndMoveTo->rememberedSetArray)[_newRememberedSetSize] = 0;
				}
				/* end setRememberedSetSize: */
				/* end removeByIndexUsingPreviousSize: */
				/* end removeLastEphemeronAndMoveTo: */
			}
		}
		((getFromOldSpaceRememberedSet())->numRememberedEphemerons = 0);
		/* end fireEphemeronsInRememberedSet */
		/* begin fireEphemeronsOnEphemeronList */
		if (!GIV(ephemeronList)) {
			goto l22;
		}
		/* begin firstCorpse: */
		/* begin corpseForCorpseOffset: */
		_ephemeronCorpse = ((sqInt) (((usqInt) (GIV(ephemeronList) - 1) ) << 3) ) + (((getMemoryMap())->newSpaceStart));
		/* end corpseForCorpseOffset: */
		/* end firstCorpse: */
		GIV(ephemeronList) = null;
		while (_ephemeronCorpse != null) {
			assert((isYoung(_ephemeronCorpse)) && (isForwarded(_ephemeronCorpse)));
			/* begin followForwarded: */
			assert(isUnambiguouslyForwarder(_ephemeronCorpse));
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent2 = unsignedLongAt((_ephemeronCorpse + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
			while (((_referent2 & (tagMask())) == 0) && (((long64At(_referent2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent2 = unsignedLongAt((_referent2 + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
			}
			_ephemeron2 = _referent2;
			/* end followForwarded: */
			{
				assert((isNonImmediate(_ephemeron2)) && (isMaybeFiredEphemeron(_ephemeron2)));
				/* begin fetchPointer:ofObject: */
				_key2 = unsignedLongAt((_ephemeron2 + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofObject: */
			}
			if (!(isScavengeSurvivor(_key2))) {
				/* begin fireEphemeron: */
				{
					/* begin queueMourner: */
					assert((isNonImmediate(_ephemeron2)) && (((formatOf(_ephemeron2)) == (ephemeronFormat())) || ((formatOf(_ephemeron2)) == (weakArrayFormat()))));
					assert(!(((formatOf(_ephemeron2)) == (ephemeronFormat())) && (isonObjStack(_ephemeron2, GIV(mournQueue)))));
					/* begin push:onObjStack: */
					_objStack2 = GIV(mournQueue);
					assert(addressCouldBeOop(_ephemeron2));
					if (_ephemeron2 & (tagMask())) {
						assert(_objStack2 == GIV(markStack));
						assert(addressCouldBeObj(topOfObjStack(((0 == (fetchPointerofObject(ObjStackTopx, _objStack2)))
							 ? fetchPointerofObject(ObjStackNextx, _objStack2)
							 : _objStack2))));
					}
 else {
						assert(!((_objStack2 == GIV(markStack)) && (isWeakNonImm(_ephemeron2))));
						assert((_objStack2 != GIV(weaklingStack)) || (isWeakNonImm(_ephemeron2)));
					}
					noCheckPushonObjStack(_ephemeron2, _objStack2);
					/* end push:onObjStack: */
					/* end queueMourner: */
					/* begin setFormatOf:to: */
					assert((1 >= 0) && (1 <= (formatMask())));
					longAtput(_ephemeron2, ((longAt(_ephemeron2)) & (~((usqIntptr_t) ((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) ))) + (1U << (formatShift())));
					/* end setFormatOf:to: */
				}
				/* begin signalFinalization: */
				forceInterruptCheck();
				GIV(pendingFinalizationSignals) += 1;
				/* end signalFinalization: */
				/* end fireEphemeron: */
				/* begin storePointerUnchecked:ofObject:withValue: */
				_valuePointer2 = copyAndForward(_key2);
				assert(!(isOopForwarded(_ephemeron2)));
				longAtput((_ephemeron2 + BaseHeaderSize) + (0U << (shiftForWord())), _valuePointer2);
				/* end storePointerUnchecked:ofObject:withValue: */
				assert(!((isScavengeSurvivor(_key2)) && (isEphemeron(_ephemeron2))));
			}
			((void) (scavengeReferentsOfFromOldSpace(_ephemeron2)) );
			/* begin nextCorpseOrNil: */
			assert(isYoung(_ephemeronCorpse));
			_listOffset = ((sqInt) (((usqInt) ((uint32AtPointer(_ephemeronCorpse + 4)) & (identityHashHalfWordMask())) ) << (formatFieldWidthShift())) ) + ((((usqInt) (longAt(_ephemeronCorpse)) ) >> (formatShift())) & (formatMask()));
			_ephemeronCorpse = ((uint64_t) (((_listOffset != 0)
				 ? (/* begin corpseForCorpseOffset: */ ((sqInt) (((usqInt) (_listOffset - 1) ) << 3) ) + (((getMemoryMap())->newSpaceStart)) /* end corpseForCorpseOffset: */)
				 : 0)) );
			/* end nextCorpseOrNil: */
		}
		l22:
		;
		/* end fireEphemeronsOnEphemeronList */
	}
}
/*	Go through the remembered set and the weak list, nilling references to 
	any objects that didn't survive the scavenge. Read the class comment 
	for a more in-depth description of the algorithm. */
/* SpurGenerationScavenger>>#processWeaklings */
static void
processWeaklings(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMRememberedSet * self_in_moveLastObjectTo;
	VMRememberedSet * self_in_removeLastObject;
	sqInt _aNewValue;
	sqInt _aValue;
	int _i;
	sqInt _listOffset;
	sqInt _referent;
	sqInt _rootObj;
	sqInt _weakCorpse;
	sqInt _weakObj;

	assert(allWeakSurvivorsOnWeakList());
	_i = 0;
	while (_i < (((getFromOldSpaceRememberedSet())->rememberedSetSize))) {
		_rootObj = ((getFromOldSpaceRememberedSet())->rememberedSetArray)[_i];
		if (isWeakFormat((((usqInt) (longAt(_rootObj)) ) >> (formatShift())) & (formatMask()))) {
			if (processWeakSurvivor(_rootObj)) {
				_i += 1;
			} else {
				/* begin setIsRememberedOf:to: */
				/* begin unsignedLong64At:put: */
				_aValue = (uint64AtPointer(_rootObj)) & (~((usqIntptr_t) (1U << (rememberedBitShift())) ));
				uint64AtPointerput(_rootObj, _aValue);
				/* end unsignedLong64At:put: */
				/* end setIsRememberedOf:to: */
				if ((_i + 1) < (((getFromOldSpaceRememberedSet())->rememberedSetSize))) {
					/* begin moveLastObjectTo: */
					/* begin getFromOldSpaceRememberedSet */
					self_in_moveLastObjectTo = GIV(fromOldSpaceRememberedSet);
					/* end getFromOldSpaceRememberedSet */
					(self_in_moveLastObjectTo->rememberedSetArray)[_i] = (self_in_moveLastObjectTo->rememberedSetArray)[((self_in_moveLastObjectTo->rememberedSetSize)) - 1];
					/* end moveLastObjectTo: */
				}
				/* begin removeLastObject */
				/* begin getFromOldSpaceRememberedSet */
				self_in_removeLastObject = GIV(fromOldSpaceRememberedSet);
				/* end getFromOldSpaceRememberedSet */
				/* begin setRememberedSetSize: */
				_aNewValue = ((self_in_removeLastObject->rememberedSetSize)) - 1;
				(self_in_removeLastObject->rememberedSetSize) = _aNewValue;
				if (_aNewValue < ((self_in_removeLastObject->rememberedSetLimit))) {
					(self_in_removeLastObject->rememberedSetArray)[_aNewValue] = 0;
				}
				/* end setRememberedSetSize: */
				/* end removeLastObject */
			}
		} else {
			_i += 1;
		}
	}
	if (GIV(weakList)) {
		/* begin firstCorpse: */
		/* begin corpseForCorpseOffset: */
		_weakCorpse = ((sqInt) (((usqInt) (GIV(weakList) - 1) ) << 3) ) + (((getMemoryMap())->newSpaceStart));
		/* end corpseForCorpseOffset: */
		/* end firstCorpse: */
		while (_weakCorpse != null) {
			assert(isForwarded(_weakCorpse));
			/* begin followForwarded: */
			assert(isUnambiguouslyForwarder(_weakCorpse));
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_weakCorpse + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
			while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
			}
			_weakObj = _referent;
			/* end followForwarded: */
			if ((processWeakSurvivor(_weakObj)) && (((_weakObj & (((getMemoryMap())->spaceMaskToUse))) == (((getMemoryMap())->oldSpaceMask))) && (!(((((usqInt) (long64At(_weakObj)) ) >> (rememberedBitShift())) & 1) != 0)))) {
				remember(getFromOldSpaceRememberedSet(), _weakObj);
			}
			/* begin nextCorpseOrNil: */
			assert(isYoung(_weakCorpse));
			_listOffset = ((sqInt) (((usqInt) ((uint32AtPointer(_weakCorpse + 4)) & (identityHashHalfWordMask())) ) << (formatFieldWidthShift())) ) + ((((usqInt) (longAt(_weakCorpse)) ) >> (formatShift())) & (formatMask()));
			_weakCorpse = ((uint64_t) (((_listOffset != 0)
				 ? (/* begin corpseForCorpseOffset: */ ((sqInt) (((usqInt) (_listOffset - 1) ) << 3) ) + (((getMemoryMap())->newSpaceStart)) /* end corpseForCorpseOffset: */)
				 : 0)) );
			/* end nextCorpseOrNil: */
		}
		GIV(weakList) = null;
	}
}
/*	Process a weak survivor on the weakList. Those of its fields 
	which have not survived the scavenge should be nilled, and if any 
	are, the coInterpreter should be informed via fireFinalization:. 
	Answer if the weakObj has any young referents. */
/* SpurGenerationScavenger>>#processWeakSurvivor: */
static sqInt NoDbgRegParms
processWeakSurvivor(sqInt _weakObj)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classFormat;
	sqInt _classPointer;
	int _hasYoungReferents;
	sqInt _i;
	sqInt _iLimit;
	sqInt _numStrongSlots;
	sqInt _referent;
	sqInt _referent2;
	sqInt _weakObjShouldMourn;

	_weakObjShouldMourn = (_hasYoungReferents = 0);
	/* begin fixedFieldsOfClassFormat: */
	/* begin formatOfClass: */
	_classPointer = fetchClassOfNonImm(_weakObj);
	_classFormat = (unsignedLongAt((_classPointer + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	/* end formatOfClass: */
	_numStrongSlots = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	/* end fixedFieldsOfClassFormat: */
	for (_i = 0; _i < _numStrongSlots; _i += 1) {
		_referent = unsignedLongAt((_weakObj + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		if (((_referent & (tagMask())) == 0) && (((_referent & (((getMemoryMap())->spaceMaskToUse))) == (((getMemoryMap())->newSpaceMask))) && (_referent >= (((getMemoryMap())->newSpaceStart))))) {
			_hasYoungReferents = 1;
		}
	}
	for (_i = _numStrongSlots, _iLimit = (numSlotsOf(_weakObj)) - 1; _i <= _iLimit; _i += 1) {
		_referent = unsignedLongAt((_weakObj + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		if ((_referent & (tagMask())) == 0) {
			if (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
				/* begin followForwarded: */
				assert(isUnambiguouslyForwarder(_referent));
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent2 = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
				while (((_referent2 & (tagMask())) == 0) && (((long64At(_referent2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent2 = unsignedLongAt((_referent2 + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
				}
				_referent = _referent2;
				/* end followForwarded: */
				assert((isReallyYoungObject(_weakObj)) || (isRemembered(_weakObj)));
				{
					assert(!(isOopForwarded(_weakObj)));
					longAtput((_weakObj + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _referent);
				}
			}
			if (isMaybeOldScavengeSurvivor(_referent)) {
				if (((_referent & (((getMemoryMap())->spaceMaskToUse))) == (((getMemoryMap())->newSpaceMask))) && (_referent >= (((getMemoryMap())->newSpaceStart)))) {
					_hasYoungReferents = 1;
				}
			} else {
				_weakObjShouldMourn = 1;
				/* begin storePointerUnchecked:ofObject:withValue: */
				assert(!(isOopForwarded(_weakObj)));
				longAtput((_weakObj + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), GIV(nilObj));
				/* end storePointerUnchecked:ofObject:withValue: */
			}
		}
	}
	if (_weakObjShouldMourn) {
		/* begin signalFinalization: */
		forceInterruptCheck();
		GIV(pendingFinalizationSignals) += 1;
		/* end signalFinalization: */
	}
	return _hasYoungReferents;
}
/*	scavengeFutureSurvivorSpaceStartingAt: does a depth-first traversal of the 
	new objects starting at the one at initialAddress in futureSurvivorSpace. */
/* SpurGenerationScavenger>>#scavengeFutureSurvivorSpaceStartingAt: */
static void NoDbgRegParms
scavengeFutureSurvivorSpaceStartingAt(sqInt _initialAddress)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _numSlots;
	sqInt _obj;
	usqInt _ptr;

	_ptr = _initialAddress;
	while (_ptr < GIV(futureSurvivorStart)) {
		/* begin objectStartingAt: */
		_numSlots = byteAt(_ptr + 7);
		_obj = ((_numSlots == (numSlotsMask()))
			 ? _ptr + BaseHeaderSize
			 : _ptr);
		/* end objectStartingAt: */
		_ptr = addressAfter(_obj);
		((void) (scavengeReferentsOfFromOldSpace(_obj)) );
	}
}
/*	This is the inner loop of the main routine, scavenge. It first scavenges 
	the new objects immediately 
	reachable from old ones. Then it scavenges those that are transitively 
	reachable. If this results in a 
	promotion, the promotee gets remembered, and it first scavenges objects 
	adjacent to the promotee, 
	then scavenges the ones reachable from the promoted. This loop continues 
	until no more reachable 
	objects are left. At that point, pastSurvivorSpace is exchanged with 
	futureSurvivorSpace.  
	Notice that each pointer in a live object is inspected once and only once. 
	The previousRememberedSetSize 
	and previousFutureSurvivorSpaceLimit variables ensure that no object is 
	scanned twice, as well as 
	detecting closure. If this were not true, some pointers might get 
	forwarded twice. 
	 
	An extension of the algorithm presented in David's original paper is to 
	handle weak arrays and ephemerons. 
	Weak arrays should not have their weak referents scavenged unless there 
	are strong references to them. 
	Ephemerons should fire if their key is not reachable other than from 
	ephemerons and weak arrays. 
	Handle this by maintaining a list for weak arrays and a list for 
	ephemerons, which allow scavenging these 
	objects once all other objects in new space have been scavenged, hence 
	allowing the scavenger to 
	detect which referents in new space of weak arrays are dead and of 
	ephemeron keys are only live due to 
	ephemerons. Read the class comment for a more in-depth description of the 
	algorithm.  */
/* SpurGenerationScavenger>>#scavengeLoop */
static void
scavengeLoop(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMRememberedSet * self_in_rememberPreviousSize;
	VMRememberedSet * self_in_startingLoop;
	int _firstTime;
	sqInt _i;
	sqInt _previousFutureSurvivorStart;
	StackPage *_thePage2;
	char *_theSP;

	assert(GIV(futureSurvivorStart) == ((GIV(futureSpace).start)));
	GIV(weakList) = (GIV(ephemeronList) = null);
	/* begin startingLoop */
	/* begin getFromOldSpaceRememberedSet */
	self_in_startingLoop = GIV(fromOldSpaceRememberedSet);
	/* end getFromOldSpaceRememberedSet */
	(self_in_startingLoop->numRememberedEphemerons) = 0;
	(self_in_startingLoop->previousRememberedSetSize) = 0;
	/* end startingLoop */
	_firstTime = 1;
	_previousFutureSurvivorStart = GIV(futureSurvivorStart);
	/* begin initStackPageGC */
	if (GIV(stackPage) != 0) {
		/* begin writeBackHeadFramePointers */
		assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
		assert(GIV(stackPage) == (mostRecentlyUsedPage()));
		assert(!(isFree(GIV(stackPage))));
		/* begin setHeadFP:andSP:inPage: */
		_theSP = GIV(stackPointer);
		assert(_theSP < GIV(framePointer));
		assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
		assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
		{
			(GIV(stackPage)->headFP = GIV(framePointer));
			(GIV(stackPage)->headSP = _theSP);
		}
		/* end setHeadFP:andSP:inPage: */
		assert(pageListIsWellFormed());
		/* end writeBackHeadFramePointers */
	}
	/* begin allStackPagesDo: */
	for (_i = 0; _i < GIV(numStackPages); _i += 1) {
		/* begin stackPageAt: */
		_thePage2 = stackPageAtpages(_i, GIV(pages));
		/* end stackPageAt: */
		{
			(_thePage2->trace = StackPageUnreached);
		}
	}
	/* end allStackPagesDo: */
	/* end initStackPageGC */
	while (1) {
		scavengeRememberedSetStartingAt(((getFromOldSpaceRememberedSet())->previousRememberedSetSize));
		/* begin rememberPreviousSize */
		/* begin getFromOldSpaceRememberedSet */
		self_in_rememberPreviousSize = GIV(fromOldSpaceRememberedSet);
		/* end getFromOldSpaceRememberedSet */
		(self_in_rememberPreviousSize->previousRememberedSetSize) = (self_in_rememberPreviousSize->rememberedSetSize);
		/* end rememberPreviousSize */
		if (_firstTime) {
			mapInterpreterOops();
			mapMournQueue();
			mapExtraRoots();
			mapOopsFromPermSpace();
			_firstTime = 0;
		}
		if (((((getFromOldSpaceRememberedSet())->previousRememberedSetSize)) == (((getFromOldSpaceRememberedSet())->rememberedSetSize))) && ((_previousFutureSurvivorStart == GIV(futureSurvivorStart)) && (((((getFromOldSpaceRememberedSet())->numRememberedEphemerons)) == 0) && (GIV(ephemeronList) == null)))) {
			return;
		}
		scavengeFutureSurvivorSpaceStartingAt(_previousFutureSurvivorStart);
		_previousFutureSurvivorStart = GIV(futureSurvivorStart);
		if ((((getFromOldSpaceRememberedSet())->previousRememberedSetSize)) == (((getFromOldSpaceRememberedSet())->rememberedSetSize))) {
			if (((((getFromOldSpaceRememberedSet())->numRememberedEphemerons)) == 0) && (GIV(ephemeronList) == null)) {
				return;
			}
			processEphemerons();
		}
	}
}
/* SpurGenerationScavenger>>#scavengeReferentsOfFromOldSpace: */
static sqInt NoDbgRegParms NeverInline
scavengeReferentsOfFromOldSpace(sqInt _referrer)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classFormat;
	sqInt _contextSize;
	sqInt _fmt;
	sqInt _foundNewReferentOrIsWeakling;
	sqInt _header;
	sqInt _header2;
	sqInt _i;
	sqInt _newLocation;
	sqInt _numLiterals;
	sqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots3;
	sqInt _objOop2;
	sqInt _referent;
	sqInt _referent2;
	sqInt _sp;

	/* begin scavengeReferentsOf:additionalTestingBlock: */
	/* begin simulationOnly: */
	/* end simulationOnly: */
	_fmt = (((usqInt) (longAt(_referrer)) ) >> (formatShift())) & (formatMask());
	/* begin numStrongSlotsOf:format:ephemeronInactiveIf: */
	if (_fmt <= 5) {
		/* begin numSlotsOf: */
		assert((classIndexOf(_referrer)) > (isForwardedObjectClassIndexPun()));
		_numSlots2 = byteAt(_referrer + 7);
		_numSlots3 = ((_numSlots2 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_referrer - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots2);
		/* end numSlotsOf: */
		if (_fmt <= 2) {
			_numSlots = _numSlots3;
			goto l10;
		}
		if (_fmt == (indexablePointersFormat())) {
			if (((longAt(_referrer)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
				setTraceFlagOnContextsFramesPageIfNeeded(_referrer);
				/* begin fetchStackPointerOf: */
				/* begin fetchPointer:ofObject: */
				_sp = unsignedLongAt((_referrer + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (!(((_sp & 7) == 1))) {
					_contextSize = 0;
					goto l7;
				}
				assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_referrer)));
				_contextSize = _sp >> 3;
				l7:
				;
				/* end fetchStackPointerOf: */
				_numSlots = CtxtTempFrameStart + _contextSize;
				goto l10;
			}
			_numSlots = _numSlots3;
			goto l10;
		}
		if (_fmt == (weakArrayFormat())) {
			/* begin fixedFieldsOfClass: */
			_objOop2 = fetchClassOfNonImm(_referrer);
			/* begin fixedFieldsOfClassFormat: */
			_classFormat = (unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
			_numSlots = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
			goto l10;
			/* end fixedFieldsOfClassFormat: */
			/* end fixedFieldsOfClass: */
		}
		assert(_fmt == (ephemeronFormat()));
		_numSlots = ((isScavengeSurvivor(keyOfEphemeron(_referrer)))
			 ? _numSlots3
			 : 0);
		goto l10;
	}
	if (_fmt == 7) {
		_numSlots = 1;
		goto l10;
	}
	if (_fmt < (firstCompiledMethodFormat())) {
		_numSlots = 0;
		goto l10;
	}
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_referrer));
	/* begin fetchPointer:ofObject: */
	_header2 = unsignedLongAt((_referrer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header2 & 7) == 1)) {
		_header = _header2;
	} else {
		assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_header = ((((CogMethod *) _header2 ))->methodHeader);
	}
	/* end methodHeaderOf: */
	{
		assert(((_header & 7) == 1));
		_numLiterals = (_header >> 3) & AlternateHeaderNumLiteralsMask;
	}
	_numSlots = _numLiterals + LiteralStart;
	l10:
	;
	/* end numStrongSlotsOf:format:ephemeronInactiveIf: */
	_foundNewReferentOrIsWeakling = _fmt == (weakArrayFormat());
	for (_i = 0; _i < _numSlots; _i += 1) {
		_referent = unsignedLongAt((_referrer + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		if ((_referent & (tagMask())) == 0) {
			if (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
				/* begin followForwarded: */
				assert(isUnambiguouslyForwarder(_referent));
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent2 = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
				while (((_referent2 & (tagMask())) == 0) && (((long64At(_referent2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent2 = unsignedLongAt((_referent2 + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
				}
				_referent = _referent2;
				/* end followForwarded: */
			}
			if ((assert(isNonImmediate(_referent)), (oopisLessThan(_referent, (GIV(memoryMap)->newSpaceEnd))) && (oopisGreaterThanOrEqualTo(_referent, (GIV(memoryMap)->newSpaceStart))))) {
				if (oopisGreaterThanOrEqualToandLessThan(_referent, ((futureSpace()).start), futureSurvivorStart())) {
					_newLocation = _referent;
					_foundNewReferentOrIsWeakling = 1;
				} else {
					_newLocation = copyAndForward(_referent);
					if (((_newLocation & (tagMask())) == 0) && (((_newLocation & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_newLocation >= ((GIV(memoryMap)->newSpaceStart))))) {
						_foundNewReferentOrIsWeakling = 1;
					}
				}
				unsignedLongAtput((_referrer + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _newLocation);
			} else {
				unsignedLongAtput((_referrer + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _referent);
				{
				}
			}
		}
	}
	return _foundNewReferentOrIsWeakling;
	/* end scavengeReferentsOf:additionalTestingBlock: */
}
/*	scavengeRememberedSetStartingAt: n traverses objects in the remembered 
	set starting at the nth one. If the object does not refer to any new 
	objects, it 
	is removed from the set. Otherwise, its new referents are scavenged. Defer 
	scavenging ephemerons until after a complete scavenge has been performed, 
	so that triggered ephemerons can be fired. Move them to the front of the 
	set and count them in numRememberedEphemerons for later scanning. */
/* SpurGenerationScavenger>>#scavengeRememberedSetStartingAt: */
static void NoDbgRegParms
scavengeRememberedSetStartingAt(sqInt _n)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMRememberedSet * self_in_moveNewEphemerondestinationIndex;
	VMRememberedSet * self_in_saveat;
	VMRememberedSet * self_in_setRememberedSetSize;
	sqInt _aValue;
	sqInt _destIndex;
	sqInt _format;
	sqInt _referrer;
	sqInt _sourceIndex;

	_sourceIndex = (_destIndex = _n);
	while (_sourceIndex < (((getFromOldSpaceRememberedSet())->rememberedSetSize))) {
		_referrer = ((getFromOldSpaceRememberedSet())->rememberedSetArray)[_sourceIndex];
		if (((assert(isNonImmediate(_referrer)), /* begin isEphemeronFormat: */ (_format = (((usqInt) (longAt(_referrer)) ) >> (formatShift())) & (formatMask())), _format == 5 /* end isEphemeronFormat: */)) && (!(isScavengeSurvivor((assert((isNonImmediate(_referrer)) && (isObjEphemeron(_referrer))), /* begin fetchPointer:ofObject: */ unsignedLongAt((_referrer + BaseHeaderSize) + (0U << (shiftForWord()))) /* end fetchPointer:ofObject: */))))) {
			assert(_destIndex >= (((getFromOldSpaceRememberedSet())->numRememberedEphemerons)));
			/* begin moveNewEphemeron:destinationIndex: */
			/* begin getFromOldSpaceRememberedSet */
			self_in_moveNewEphemerondestinationIndex = GIV(fromOldSpaceRememberedSet);
			/* end getFromOldSpaceRememberedSet */
			{
				(self_in_moveNewEphemerondestinationIndex->rememberedSetArray)[_destIndex] = (self_in_moveNewEphemerondestinationIndex->rememberedSetArray)[(self_in_moveNewEphemerondestinationIndex->numRememberedEphemerons)];
				(self_in_moveNewEphemerondestinationIndex->rememberedSetArray)[(self_in_moveNewEphemerondestinationIndex->numRememberedEphemerons)] = _referrer;
			}
			(self_in_moveNewEphemerondestinationIndex->numRememberedEphemerons) = ((self_in_moveNewEphemerondestinationIndex->numRememberedEphemerons)) + 1;
			/* end moveNewEphemeron:destinationIndex: */
			_destIndex += 1;
		} else {
			if (scavengeReferentsOfFromOldSpace(_referrer)) {
				/* begin save:at: */
				/* begin getFromOldSpaceRememberedSet */
				self_in_saveat = GIV(fromOldSpaceRememberedSet);
				/* end getFromOldSpaceRememberedSet */
				(self_in_saveat->rememberedSetArray)[_destIndex] = _referrer;
				/* end save:at: */
				_destIndex += 1;
			} else {
				/* begin setIsRememberedOf:to: */
				/* begin unsignedLong64At:put: */
				_aValue = (uint64AtPointer(_referrer)) & (~((usqIntptr_t) (1U << (rememberedBitShift())) ));
				uint64AtPointerput(_referrer, _aValue);
				/* end unsignedLong64At:put: */
				/* end setIsRememberedOf:to: */
			}
		}
		_sourceIndex += 1;
	}
	/* begin setRememberedSetSize: */
	/* begin getFromOldSpaceRememberedSet */
	self_in_setRememberedSetSize = GIV(fromOldSpaceRememberedSet);
	/* end getFromOldSpaceRememberedSet */
	(self_in_setRememberedSetSize->rememberedSetSize) = _destIndex;
	if (_destIndex < ((self_in_setRememberedSetSize->rememberedSetLimit))) {
		(self_in_setRememberedSetSize->rememberedSetArray)[_destIndex] = 0;
	}
	/* end setRememberedSetSize: */
	assert(noUnfiredEphemeronsAtEndOfRememberedSet());
}
/* SpurGenerationScavenger>>#scavengerTenuringProportion */
static float
scavengerTenuringProportion(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((GIV(tenureThreshold) >= ((GIV(pastSpace).start)))
		 ? ((double) (GIV(tenureThreshold) - ((GIV(pastSpace).start))) ) / (((GIV(pastSpace).limit)) - ((GIV(pastSpace).start)))
		 : 0);
}
/*	There may be ephemerons to be scavenged on the ephemeronList. 
	Scavenge any with unfired (live) keys, removing them from the 
	list, and answer if any with unfired keys were found. */
/* SpurGenerationScavenger>>#scavengeUnfiredEphemeronsOnEphemeronList */
static sqInt
scavengeUnfiredEphemeronsOnEphemeronList(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _corpseOffset;
	sqInt _ephemeron;
	sqInt _ephemeronCorpse;
	sqInt _nextCorpseOffset;
	sqInt _offset;
	sqInt _previousCorpse;
	sqInt _previousList;
	sqInt _referent;
	int _unfiredEphemeronsScavenged;

	_previousCorpse = 0;
	if (!GIV(ephemeronList)) {
		return 0;
	}
	_unfiredEphemeronsScavenged = 0;
	_corpseOffset = GIV(ephemeronList);
	_previousList = GIV(ephemeronList);
	GIV(ephemeronList) = null;
	while (_corpseOffset != 0) {
		/* begin corpseForCorpseOffset: */
		_ephemeronCorpse = ((sqInt) (((usqInt) (_corpseOffset - 1) ) << 3) ) + (((getMemoryMap())->newSpaceStart));
		/* end corpseForCorpseOffset: */
		assert(isForwarded(_ephemeronCorpse));
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(_ephemeronCorpse));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_ephemeronCorpse + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		_ephemeron = _referent;
		/* end followForwarded: */
		_nextCorpseOffset = ((sqInt) (((usqInt) ((uint32AtPointer(_ephemeronCorpse + 4)) & (identityHashHalfWordMask())) ) << (formatFieldWidthShift())) ) + ((((usqInt) (longAt(_ephemeronCorpse)) ) >> (formatShift())) & (formatMask()));
		if (isScavengeSurvivor((assert((isNonImmediate(_ephemeron)) && (isObjEphemeron(_ephemeron))), /* begin fetchPointer:ofObject: */ unsignedLongAt((_ephemeron + BaseHeaderSize) + (0U << (shiftForWord()))) /* end fetchPointer:ofObject: */))) {
			if (_corpseOffset == _previousList) {
				_previousList = _nextCorpseOffset;
			} else {
				/* begin setCorpseOffsetOf:to: */
				assert(isYoung(_previousCorpse));
				assert(isForwarded(_previousCorpse));
				{
					long64Atput(_previousCorpse, headerForSlotshashformatclassIndex(byteAt(_previousCorpse + 7), ((usqInt) _nextCorpseOffset ) >> (formatFieldWidthShift()), _nextCorpseOffset & (formatMask()), isForwardedObjectClassIndexPun()));
				}
				/* end setCorpseOffsetOf:to: */
			}
			_unfiredEphemeronsScavenged = 1;
			((void) (scavengeReferentsOfFromOldSpace(_ephemeron)) );
		} else {
			_previousCorpse = _ephemeronCorpse;
		}
		_corpseOffset = _nextCorpseOffset;
	}
	if (_previousCorpse) {
		/* begin setCorpseOffsetOf:to: */
		_offset = ((!GIV(ephemeronList))
			 ? 0
			 : GIV(ephemeronList));
		assert(isYoung(_previousCorpse));
		assert(isForwarded(_previousCorpse));
		{
			long64Atput(_previousCorpse, headerForSlotshashformatclassIndex(byteAt(_previousCorpse + 7), ((usqInt) _offset ) >> (formatFieldWidthShift()), _offset & (formatMask()), isForwardedObjectClassIndexPun()));
		}
		/* end setCorpseOffsetOf:to: */
		GIV(ephemeronList) = _previousList;
	}
	return _unfiredEphemeronsScavenged;
}
/*	Output the entire record. */
/* SpurGenerationScavenger>>#writeScavengeLog */
static void NeverInline
writeScavengeLog(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	static char *_policyNames[] = {"", "by age", "by class", "to shrink rt", "don't tenure", "mark on tenure"};

	fprintf(GIV(scavengeLog), "scavenge %ld eden bytes: 0x%lx/%ld past bytes: 0x%lx/%ld\n\trem set: %ld redzone: %ld size: %ld\n", GIV(statScavenges), (GIV(scavengeLogRecord).sEdenBytes), (GIV(scavengeLogRecord).sEdenBytes), (GIV(scavengeLogRecord).sPastBytes), (GIV(scavengeLogRecord).sPastBytes), (GIV(scavengeLogRecord).sRememberedSetSize), (GIV(scavengeLogRecord).sRememberedSetRedZone), (GIV(scavengeLogRecord).sRememberedSetLimit));
	fprintf(GIV(scavengeLog), ((((GIV(scavengeLogRecord).tTenureCriterion)) == TenureToShrinkRT)
		 ? "	tenure below 0x%lx/%ld %s refct %ld\n"
		 : "	tenure below 0x%lx/%ld %s\n"), (GIV(scavengeLogRecord).tTenureThreshold), (GIV(scavengeLogRecord).tTenureThreshold), _policyNames[(GIV(scavengeLogRecord).tTenureCriterion)], (GIV(scavengeLogRecord).tRefCountToShrinkRT));
	fprintf(GIV(scavengeLog), "	survivor bytes: 0x%lx/%ld rem set: %ld tenured: %ld usecs: %ld\n", (GIV(scavengeLogRecord).eSurvivorBytes), (GIV(scavengeLogRecord).eSurvivorBytes), (GIV(scavengeLogRecord).eRememberedSetSize), ((GIV(scavengeLogRecord).eStatTenures)) - ((GIV(scavengeLogRecord).sStatTenures)), GIV(statSGCDeltaUsecs));
	fflush(GIV(scavengeLog));
}
/*	Answer the next 32 or 64 bit word read from aFile, byte-swapped according 
	to the swapFlag. */
/* SpurImageReader>>#getLongFromFile:swap: */
static sqInt NoDbgRegParms
getLongFromFileswap(sqImageFile _aFile, sqInt _swapFlag)
{
	usqInt _w;

	_w = 0;
	sqImageFileRead(&_w, sizeof(_w), 1, _aFile);
	return ((_swapFlag)
		 ? (/* begin byteSwapped: */ SQ_SWAP_8_BYTES(_w) /* end byteSwapped: */)
		 : _w);
}
/*	Answer the next 16 bit word read from aFile, byte-swapped according to the 
	swapFlag.  */
/* SpurImageReader>>#getShortFromFile:swap: */
static sqInt NoDbgRegParms
getShortFromFileswap(sqImageFile _aFile, sqInt _swapFlag)
{
	unsigned short _w;

	_w = 0;
	sqImageFileRead(&_w, sizeof(unsigned short), 1, _aFile);
	return ((_swapFlag)
		 ? ((((usqInt) _w ) >> 8) & 0xFF) | ((sqInt) (((usqInt) (_w & 0xFF) ) << 8) )
		 : _w);
}
/*	Answer the next 32 bit word read from aFile, byte-swapped according to the 
	swapFlag.  */
/* SpurImageReader>>#getWord32FromFile:swap: */
static sqInt NoDbgRegParms
getWord32FromFileswap(sqImageFile _aFile, sqInt _swapFlag)
{
	int _w;

	_w = 0;
	sqImageFileRead(&_w, sizeof(int), 1, _aFile);
	return ((_swapFlag)
		 ? SQ_SWAP_4_BYTES(_w)
		 : _w);
}
/*	Append aLong to aFile in this platform's 'natural' byte order. aLong is 
	either 32 or 64 bits, 
	depending on ObjectMemory. (Bytes will be swapped, if necessary, when the 
	image is read 
	on a different platform.) Set successFlag to false if the write fails. */
/* SpurImageWriter>>#putLong:toFile: */
static void NoDbgRegParms
putLongtoFile(sqInt _aLong, sqImageFile _aFile)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _objectsWritten;

	_objectsWritten = sqImageFileWrite(&_aLong, sizeof(sqInt), 1, _aFile);
	/* begin success: */
	if (!(_objectsWritten == 1)) {
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
	}
	/* end success: */
}
/*	Append the 16-bit aShort to aFile in this platform's 'natural' byte order. 
	(Bytes will be swapped, if necessary, when the image is read on a 
	different platform.) Set successFlag to false if the write fails. */
/* SpurImageWriter>>#putShort:toFile: */
static void NoDbgRegParms
putShorttoFile(short _aShort, sqImageFile _aFile)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _objectsWritten;

	_objectsWritten = sqImageFileWrite(&_aShort, sizeof(short), 1, _aFile);
	/* begin success: */
	if (!(_objectsWritten == 1)) {
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
	}
	/* end success: */
}
/*	Append aWord32 to aFile in this platform's 'natural' byte order. aWord32 
	is 32 bits, 
	depending on ObjectMemory. (Bytes will be swapped, if necessary, when the 
	image is read 
	on a different platform.) Set successFlag to false if the write fails. */
/* SpurImageWriter>>#putWord32:toFile: */
static void NoDbgRegParms
putWord32toFile(int _aWord32, sqImageFile _aFile)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _objectsWritten;

	_objectsWritten = sqImageFileWrite(&_aWord32, 4, 1, _aFile);
	/* begin success: */
	if (!(_objectsWritten == 1)) {
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
	}
	/* end success: */
}
/*	Write the image header and heap contents to imageFile for snapshot. c.f. 
	writeImageFileIOSimulation. The game below is to maintain 64-bit alignment 
	for all putLong:toFile: occurrences. */
/* SpurImageWriter>>#SIW_writeImageFile:fromHeader: */
static sqInt NoDbgRegParms
SIW_writeImageFilefromHeader(char *_imageFileName, SpurImageHeaderStruct _header)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	size_t _bytesWritten;
	sqImageFile _f;
	fileOffset_t _headerStart;
	sqInt _i;
	sqInt _iLimit;
	size_t _imageBytes;
	sqInt _imageHeaderSize;
	size_t _total;

	_headerStart = 0;
	_imageHeaderSize = (_header.imageHeaderSize);
	if (!((totalBytesInPermanentSpace()) == 0)) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrUnsupported);
		/* end primitiveFailFor: */
	}
	logDebug("Writing snapshot file %s", _imageFileName);
	_f = sqImageFileOpen(_imageFileName, "wb");
	if (!_f) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	_imageBytes = (_header.dataSize);
	_headerStart = sqImageFileStartLocation(_f, _imageFileName, _imageHeaderSize + _imageBytes);
	/* Note: on Unix systems one could put an exec command here, padded to 512 bytes */;
	sqImageFileSeek(_f, _headerStart);
	/* begin writeHeader:toFile: */
	putWord32toFile((_header.imageFormat), _f);
	putWord32toFile((_header.imageHeaderSize), _f);
	putLongtoFile((_header.dataSize), _f);
	putLongtoFile((_header.oldBaseAddr), _f);
	putLongtoFile((_header.initialSpecialObjectsOop), _f);
	putLongtoFile((_header.hdrLastHash), _f);
	putLongtoFile(0, _f);
	putLongtoFile((_header.headerFlags), _f);
	putWord32toFile((_header.extraVMMemory), _f);
	putShorttoFile((_header.hdrNumStackPages), _f);
	putShorttoFile((_header.hdrCogCodeSize), _f);
	putWord32toFile((_header.hdrEdenBytes), _f);
	putShorttoFile((_header.hdrMaxExtSemTabSize), _f);
	putShorttoFile((_header.imageVersion), _f);
	/* end writeHeader:toFile: */
	putLongtoFile(firstSegmentBytes(), _f);
	putLongtoFile(GIV(totalFreeOldSpace), _f);
	/* begin padHeader:toFile: */
	{
		putLongtoFile(0, _f);
	}
	{
		putLongtoFile(0, _f);
	}
	{
		{
			putLongtoFile(0, _f);
		}
		{
			putLongtoFile(0, _f);
		}
		{
			putLongtoFile(0, _f);
		}
	}
	/* end padHeader:toFile: */
	assert((_headerStart + _imageHeaderSize) == (sqImageFilePosition(_f)));
	sqImageFileSeek(_f, _headerStart + _imageHeaderSize);
	if (GIV(primFailCode)) {
		sqImageFileClose(_f);
		return null;
	}
	/* begin writeImageSegmentsToFile: */
	/* begin beginWriteImageSegments */
	assert((firstSegmentBytes()) > 0);
	/* end beginWriteImageSegments */
	/* begin withNonEmptySegmentsDo: */
	_total = 0;
	for (_i = 0, _iLimit = (numSegments()) - 1; _i <= _iLimit; _i += 1) {
		if ((((GIV(segments)[_i]).segSize)) > (2 * BaseHeaderSize)) {
			_total += writeSegmentnextSegmenttoFile(&(GIV(segments)[_i]), nextNonEmptySegmentAfter(_i), _f);
		}
	}
	_bytesWritten = _total;
	/* end withNonEmptySegmentsDo: */
	/* end writeImageSegmentsToFile: */
	/* begin success: */
	if (!(_bytesWritten == _imageBytes)) {
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
	}
	/* end success: */
	sqImageFileClose(_f);
	logDebug("Snapshot file %s done", _imageFileName);
	return 0;
}
/*	Write the segment contents, the size of and the distance to the next 
	segment to aBinaryStream. */
/* SpurImageWriter>>#writeSegment:nextSegment:toFile: */
static size_t NoDbgRegParms
writeSegmentnextSegmenttoFile(SpurSegmentInfo *_segment, SpurSegmentInfo *_nextSegment, sqImageFile _aBinaryStream)
{
	usqLong _firstSavedBridgeWord;
	size_t _nWritten;
	sqInt _pier1;
	sqInt _pier2;
	usqLong _secondSavedBridgeWord;

	_pier1 = (((_segment->segSize)) + ((_segment->segStart))) - (2 * BaseHeaderSize);
	_pier2 = _pier1 + BaseHeaderSize;
	assert(isValidSegmentBridge(bridgeFor(_segment)));
	assert((startOfObject(bridgeFor(_segment))) == _pier1);
	_firstSavedBridgeWord = long64At(_pier1);
	_secondSavedBridgeWord = long64At(_pier2);
	bridgeFromto(_segment, _nextSegment);
	long64Atput(_pier2, ((_nextSegment == null)
		 ? 0
		 : (_nextSegment->segSize)));
	_nWritten = sqImageFileWrite(((void *) ((_segment->segStart)) ), 1, (_segment->segSize), _aBinaryStream);
	{
		long64Atput(_pier1, _firstSavedBridgeWord);
		long64Atput(_pier2, _secondSavedBridgeWord);
	}
	return _nWritten;
}
/*	Answer the accessible object following the given object or  
	free chunk in the heap. Return nil when heap is exhausted. 
	This is for primitiveNextObject subsequent to primtiiveSomeObject. 
	It also tries to handle more general use by ordering objects as 
	eden 
	past 
	old 
	but this is tricky becaus ethe order in memory is 
	past 
	eden 
	old */
/* SpurMemoryManager>>#accessibleObjectAfter: */
static sqInt NoDbgRegParms
accessibleObjectAfter(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	sqInt _limit;
	usqInt _numSlots;
	sqInt _objAfter;

	_objAfter = _objOop;
	if (oopisLessThan(_objAfter, GIV(nilObj))) {
		assert((isInEden(_objOop)) || (isInPastSpace(_objOop)));
		if (oopisGreaterThan(_objAfter, GIV(pastSpaceStart))) {
			while (1) {
				/* begin objectAfter:limit: */
				_followingWordAddress = addressAfter(_objAfter);
				if (oopisGreaterThanOrEqualTo(_followingWordAddress, GIV(freeStart))) {
					_objAfter = GIV(freeStart);
					goto l2;
				}
				flag("endianness");
				_followingWord = unsignedLongAt(_followingWordAddress);
				_objAfter = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
					 ? _followingWordAddress + BaseHeaderSize
					 : _followingWordAddress);
				l2:
				;
				/* end objectAfter:limit: */
				if (!(oopisLessThan(_objAfter, GIV(freeStart)))) 
					break;
				if (((longAt(_objAfter)) & (classIndexMask())) > (lastClassIndexPun())) {
					return _objAfter;
				}
			}
			if (GIV(pastSpaceStart) <= (((pastSpace()).start))) {
				return GIV(nilObj);
			}
			/* begin objectStartingAt: */
			_address = ((pastSpace()).start);
			_numSlots = byteAt(_address + 7);
			_objAfter = ((_numSlots == (numSlotsMask()))
				 ? _address + BaseHeaderSize
				 : _address);
			/* end objectStartingAt: */
			if (((longAt(_objAfter)) & (classIndexMask())) > (lastClassIndexPun())) {
				return _objAfter;
			}
		}
		while (1) {
			/* begin objectAfter:limit: */
			_followingWordAddress2 = addressAfter(_objAfter);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(pastSpaceStart))) {
				_objAfter = GIV(pastSpaceStart);
				goto l4;
			}
			flag("endianness");
			_followingWord2 = unsignedLongAt(_followingWordAddress2);
			_objAfter = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress2 + BaseHeaderSize
				 : _followingWordAddress2);
			l4:
			;
			/* end objectAfter:limit: */
			if (!(oopisLessThan(_objAfter, GIV(pastSpaceStart)))) 
				break;
			if (((longAt(_objAfter)) & (classIndexMask())) > (lastClassIndexPun())) {
				return _objAfter;
			}
		}
		return GIV(nilObj);
	}
	while (1) {
		/* begin objectAfter:limit: */
		_limit = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress3 = addressAfter(_objAfter);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, _limit)) {
			_objAfter = _limit;
			goto l5;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_objAfter = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l5:
		;
		/* end objectAfter:limit: */
		if (_objAfter == ((GIV(memoryMap)->oldSpaceEnd))) {
			return null;
		}
		if (((longAt(_objAfter)) & (classIndexMask())) > (lastClassIndexPun())) {
			return _objAfter;
		}
	}
	return 0;
}
/*	Answer whether an ephemeron is active (has an unmarked 
	key) and was pushed on the unscanned ephemerons stack. */
/* SpurMemoryManager>>#activeAndDeferredScan: */
static sqInt NoDbgRegParms NeverInline
activeAndDeferredScan(sqInt _anEphemeron)
{
	sqInt _key;

	assert(isEphemeron(_anEphemeron));
	if ((isImmediate((assert((isNonImmediate(_anEphemeron)) && (isObjEphemeron(_anEphemeron))), /* begin fetchPointer:ofObject: */ (_key = unsignedLongAt((_anEphemeron + BaseHeaderSize) + (0U << (shiftForWord())))) /* end fetchPointer:ofObject: */))) || ((((((usqInt) (longAt(_key)) ) >> (markedBitFullShift())) & 1) != 0) || (((_key & (tagMask())) == 0) && (_key >= 0x20000000000LL)))) {
		return 0;
	}
	return pushOnUnscannedEphemeronsStack(_anEphemeron);
}
/*	Add a freeChunk sub tree back into the large free chunk tree. 
	This is for allocateOldSpaceChunkOf[Exactly]Bytes:[suchThat:].N.B. *can't* use numSlotsOfAny: because of rounding up of odd slots 
	and/or step in size at 1032 bytes in 32-bits or 2048 bytes in 64-bits. */
/* SpurMemoryManager>>#addFreeSubTree: */
static void NoDbgRegParms
addFreeSubTree(sqInt _freeTree)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _bytesInArg;
	usqInt _bytesInNode;
	sqInt _subNode;
	sqInt _treeNode;

	assert(isFreeObject(_freeTree));
	_bytesInArg = bytesInObject(_freeTree);
	assert(_bytesInArg >= ((numFreeLists()) * (allocationUnit())));
	_treeNode = GIV(freeLists)[0];
	assert(_treeNode != 0);
	while (1) {
		_bytesInNode = bytesInObject(_treeNode);
		assert((oopisLessThanOrEqualTo((_freeTree + _bytesInArg) - BaseHeaderSize, _treeNode)) || (oopisGreaterThanOrEqualTo(_freeTree, (_treeNode + _bytesInNode) - BaseHeaderSize)));
		assert(_bytesInNode >= ((numFreeLists()) * (allocationUnit())));
		assert(_bytesInArg != _bytesInNode);
		if (_bytesInNode > _bytesInArg) {
			/* begin fetchPointer:ofFreeChunk: */
			_subNode = unsignedLongAt((_treeNode + BaseHeaderSize) + (3U << (shiftForWord())));
			/* end fetchPointer:ofFreeChunk: */
			if (_subNode == 0) {
				/* begin storePointer:ofFreeChunk:withValue: */
				assert(isFreeObject(_treeNode));
				assert((_freeTree == 0) || (isFreeObject(_freeTree)));
				unsignedLongAtput((_treeNode + BaseHeaderSize) + (3U << (shiftForWord())), _freeTree);
				/* end storePointer:ofFreeChunk:withValue: */
				/* begin storePointer:ofFreeChunk:withValue: */
				assert(isFreeObject(_freeTree));
				assert((_treeNode == 0) || (isFreeObject(_treeNode)));
				unsignedLongAtput((_freeTree + BaseHeaderSize) + (2U << (shiftForWord())), _treeNode);
				/* end storePointer:ofFreeChunk:withValue: */
				return;
			}
		}
 else {
			/* begin fetchPointer:ofFreeChunk: */
			_subNode = unsignedLongAt((_treeNode + BaseHeaderSize) + (4U << (shiftForWord())));
			/* end fetchPointer:ofFreeChunk: */
			if (_subNode == 0) {
				/* begin storePointer:ofFreeChunk:withValue: */
				assert(isFreeObject(_treeNode));
				assert((_freeTree == 0) || (isFreeObject(_freeTree)));
				unsignedLongAtput((_treeNode + BaseHeaderSize) + (4U << (shiftForWord())), _freeTree);
				/* end storePointer:ofFreeChunk:withValue: */
				/* begin storePointer:ofFreeChunk:withValue: */
				assert(isFreeObject(_freeTree));
				assert((_treeNode == 0) || (isFreeObject(_treeNode)));
				unsignedLongAtput((_freeTree + BaseHeaderSize) + (2U << (shiftForWord())), _treeNode);
				/* end storePointer:ofFreeChunk:withValue: */
				return;
			}
		}
		_treeNode = _subNode;
	}
}
/*	Add the given variable location to the extra roots table. */
/* SpurMemoryManager>>#addGCRoot: */
sqInt
addGCRoot(sqInt *_varLoc)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (GIV(extraRootCount) >= ExtraRootsSize) {
		return 0;
	}
	GIV(extraRoots)[(GIV(extraRootCount) += 1)] = _varLoc;
	return 1;
}
/* SpurMemoryManager>>#addressCouldBeObj: */
sqInt
addressCouldBeObj(sqInt _address)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((_address & (BaseHeaderSize - 1)) == 0) && ((oopisGreaterThanOrEqualToandLessThan(_address, (GIV(memoryMap)->oldSpaceStart), (GIV(memoryMap)->oldSpaceEnd))) || ((oopisGreaterThanOrEqualToandLessThan(_address, (GIV(memoryMap)->permSpaceStart), (GIV(memoryMap)->permSpaceEnd))) || ((oopisGreaterThanOrEqualToandLessThan(_address, ((eden()).start), GIV(freeStart))) || ((oopisGreaterThanOrEqualToandLessThan(_address, ((pastSpace()).start), GIV(pastSpaceStart))) || ((GIV(gcPhaseInProgress) == ScavengeInProgress) && (oopisGreaterThanOrEqualToandLessThan(_address, ((futureSpace()).start), futureSurvivorStart())))))));
}
/*	Answer if address appears to be that of either an immediate or an object. 
	For code disassembly and assertions. */
/* SpurMemoryManager>>#addressCouldBeOop: */
sqInt
addressCouldBeOop(sqInt _address)
{
	return (_address & (tagMask())) || (addressCouldBeObj(_address));
}
/*	Add freeChunk to the relevant freeList. 
	For the benefit of sortedFreeObject:, if freeChunk is large, answer the 
	treeNode it 
	is added to, if it is added to the next list of a freeTreeNode, otherwise 
	answer 0.coInterpreter transcript ensureCr. coInterpreter print: 'freeing '. self 
	printFreeChunk: freeChunk. */
/* SpurMemoryManager>>#addToFreeList:bytes: */
static sqInt NoDbgRegParms
addToFreeListbytes(sqInt _freeChunk, sqInt _chunkBytes)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _child;
	usqInt _childBytes;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;
	sqInt _index;
	sqInt _nextFreeChunk;
	sqInt _nextFreeChunk2;
	sqInt _parent;

	assert(isFreeObject(_freeChunk));
	assert(_chunkBytes == (bytesInObject(_freeChunk)));
	_index = _chunkBytes / 8;
	if (_index < 64) {
		/* begin setNextFreeChunkOf:withValue:chunkBytes: */
		_nextFreeChunk = GIV(freeLists)[_index];
		/* begin setNextFreeChunkOf:withValue:isLilliputianSize: */
		/* begin storePointer:ofFreeChunk:withValue: */
		assert(isFreeObject(_freeChunk));
		assert((_nextFreeChunk == 0) || (isFreeObject(_nextFreeChunk)));
		unsignedLongAtput((_freeChunk + BaseHeaderSize) + (0U << (shiftForWord())), _nextFreeChunk);
		/* end storePointer:ofFreeChunk:withValue: */
		if ((_nextFreeChunk != 0) && (!((assert(_chunkBytes >= (BaseHeaderSize + (allocationUnit()))), _chunkBytes == (BaseHeaderSize + 8))))) {
			/* begin storePointer:ofFreeChunk:withValue: */
			assert(isFreeObject(_nextFreeChunk));
			assert((_freeChunk == 0) || (isFreeObject(_freeChunk)));
			unsignedLongAtput((_nextFreeChunk + BaseHeaderSize) + (1U << (shiftForWord())), _freeChunk);
			/* end storePointer:ofFreeChunk:withValue: */
		}
		/* end setNextFreeChunkOf:withValue:isLilliputianSize: */
		/* end setNextFreeChunkOf:withValue:chunkBytes: */
		if (!((assert(_chunkBytes >= (BaseHeaderSize + (allocationUnit()))), _chunkBytes == (BaseHeaderSize + 8)))) {
			/* begin storePointer:ofFreeChunk:withValue: */
			assert(isFreeObject(_freeChunk));
			assert(1);
			unsignedLongAtput((_freeChunk + BaseHeaderSize) + (1U << (shiftForWord())), 0);
			/* end storePointer:ofFreeChunk:withValue: */
		}
		GIV(freeLists)[_index] = _freeChunk;
		GIV(freeListsMask) = GIV(freeListsMask) | (1ULL << _index);
		return 0;
	}
	/* begin addToFreeTree:bytes: */
	assert(isFreeObject(_freeChunk));
	assert(_chunkBytes == (bytesInObject(_freeChunk)));
	assert(_chunkBytes >= ((numFreeLists()) * (allocationUnit())));
	{
		/* begin storePointer:ofFreeChunk:withValue: */
		assert(isFreeObject(_freeChunk));
		assert(1);
		unsignedLongAtput((_freeChunk + BaseHeaderSize) + (0U << (shiftForWord())), 0);
		/* end storePointer:ofFreeChunk:withValue: */
		/* begin storePointer:ofFreeChunk:withValue: */
		assert(isFreeObject(_freeChunk));
		assert(1);
		unsignedLongAtput((_freeChunk + BaseHeaderSize) + (1U << (shiftForWord())), 0);
		/* end storePointer:ofFreeChunk:withValue: */
		/* begin storePointer:ofFreeChunk:withValue: */
		assert(isFreeObject(_freeChunk));
		assert(1);
		unsignedLongAtput((_freeChunk + BaseHeaderSize) + (2U << (shiftForWord())), 0);
		/* end storePointer:ofFreeChunk:withValue: */
		/* begin storePointer:ofFreeChunk:withValue: */
		assert(isFreeObject(_freeChunk));
		assert(1);
		unsignedLongAtput((_freeChunk + BaseHeaderSize) + (3U << (shiftForWord())), 0);
		/* end storePointer:ofFreeChunk:withValue: */
		/* begin storePointer:ofFreeChunk:withValue: */
		assert(isFreeObject(_freeChunk));
		assert(1);
		unsignedLongAtput((_freeChunk + BaseHeaderSize) + (4U << (shiftForWord())), 0);
		/* end storePointer:ofFreeChunk:withValue: */
	}
	_parent = 0;
	_child = GIV(freeLists)[0];
	while (_child != 0) {
		_childBytes = bytesInObject(_child);
		assert((oopisLessThanOrEqualTo((_freeChunk + _chunkBytes) - BaseHeaderSize, _child)) || (oopisGreaterThanOrEqualTo(_freeChunk, (_child + _childBytes) - BaseHeaderSize)));
		if (_childBytes == _chunkBytes) {
			/* begin setNextFreeChunkOf:withValue:isLilliputianSize: */
			_nextFreeChunk2 = unsignedLongAt((_child + BaseHeaderSize) + (0U << (shiftForWord())));
			/* begin storePointer:ofFreeChunk:withValue: */
			assert(isFreeObject(_freeChunk));
			assert((_nextFreeChunk2 == 0) || (isFreeObject(_nextFreeChunk2)));
			unsignedLongAtput((_freeChunk + BaseHeaderSize) + (0U << (shiftForWord())), _nextFreeChunk2);
			/* end storePointer:ofFreeChunk:withValue: */
			if ((_nextFreeChunk2 != 0) && !0) {
				/* begin storePointer:ofFreeChunk:withValue: */
				assert(isFreeObject(_nextFreeChunk2));
				assert((_freeChunk == 0) || (isFreeObject(_freeChunk)));
				unsignedLongAtput((_nextFreeChunk2 + BaseHeaderSize) + (1U << (shiftForWord())), _freeChunk);
				/* end storePointer:ofFreeChunk:withValue: */
			}
			/* end setNextFreeChunkOf:withValue:isLilliputianSize: */
			/* begin setNextFreeChunkOf:withValue:isLilliputianSize: */
			/* begin storePointer:ofFreeChunk:withValue: */
			assert(isFreeObject(_child));
			assert((_freeChunk == 0) || (isFreeObject(_freeChunk)));
			unsignedLongAtput((_child + BaseHeaderSize) + (0U << (shiftForWord())), _freeChunk);
			/* end storePointer:ofFreeChunk:withValue: */
			if ((_freeChunk != 0) && !0) {
				/* begin storePointer:ofFreeChunk:withValue: */
				assert(isFreeObject(_freeChunk));
				assert((_child == 0) || (isFreeObject(_child)));
				unsignedLongAtput((_freeChunk + BaseHeaderSize) + (1U << (shiftForWord())), _child);
				/* end storePointer:ofFreeChunk:withValue: */
			}
			/* end setNextFreeChunkOf:withValue:isLilliputianSize: */
			return _child;
		}
		_parent = _child;
		/* begin fetchPointer:ofFreeChunk: */
		_fieldIndex = ((_childBytes > _chunkBytes)
			 ? 3
			 : 4);
		_child = unsignedLongAt((_child + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofFreeChunk: */
	}
	if (_parent == 0) {
		assert((GIV(freeLists)[0]) == 0);
		GIV(freeLists)[0] = _freeChunk;
		GIV(freeListsMask) = GIV(freeListsMask) | 1;
		return 0;
	}
	assert(GIV(freeListsMask) & 1);
	/* begin storePointer:ofFreeChunk:withValue: */
	assert(isFreeObject(_freeChunk));
	assert((_parent == 0) || (isFreeObject(_parent)));
	unsignedLongAtput((_freeChunk + BaseHeaderSize) + (2U << (shiftForWord())), _parent);
	/* end storePointer:ofFreeChunk:withValue: */
	/* begin storePointer:ofFreeChunk:withValue: */
	_fieldIndex2 = ((_childBytes > _chunkBytes)
		 ? 3
		 : 4);
	assert(isFreeObject(_parent));
	assert((_freeChunk == 0) || (isFreeObject(_freeChunk)));
	unsignedLongAtput((_parent + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ), _freeChunk);
	/* end storePointer:ofFreeChunk:withValue: */
	return 0;
	/* end addToFreeTree:bytes: */
}
/*	Attempt to answer an array of all objects, excluding those that may 
	be garbage collected as a side effect of allocating the result array. 
	If no memory is available answer the number of instances as a 
	SmallInteger. Since objects are at least 16 bytes big, and the largest 
	SmallInteger covers 
	1/4 of the address space, the count can never overflow. */
/* SpurMemoryManager>>#allInstancesOf: */
static sqInt NoDbgRegParms
allInstancesOf(sqInt _aClass)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _actualIndex;
	sqInt _address;
	sqInt _address2;
	sqInt _address22;
	sqInt _address3;
	usqInt _bytes;
	sqInt _classIndex;
	sqInt _classOrNil;
	sqInt _count;
	int _count2;
	int _count3;
	sqInt _currentObject;
	sqInt _currentObject2;
	sqInt _expectedIndex;
	sqInt _expectedIndex2;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord22;
	sqInt _followingWord3;
	sqInt _followingWord32;
	sqInt _followingWord4;
	sqInt _followingWord42;
	sqInt _followingWord5;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress22;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress32;
	usqInt _followingWordAddress4;
	usqInt _followingWordAddress42;
	usqInt _followingWordAddress5;
	sqInt _freeChunk;
	int _hasToScheduleScavenge;
	int _hasToScheduleScavenge2;
	sqInt _i;
	sqInt _i2;
	sqInt _iLimit;
	sqInt _index;
	sqInt _j;
	usqInt _limit;
	sqInt _limit2;
	sqInt _limit22;
	usqInt _limit3;
	usqInt _limit32;
	sqInt _newObj;
	sqInt _newObj2;
	usqInt _numBytes;
	usqInt _numBytes2;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots22;
	usqInt _numSlots3;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _objOop3;
	sqInt _page;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevObj22;
	sqInt _prevObj3;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;
	sqInt _prevPrevObj22;
	sqInt _prevPrevObj3;
	sqInt _ptr;
	sqInt _ptr2;
	sqInt _ptr3;
	sqInt _smallObj;
	sqInt _start;
	sqInt _valuePointer;

	_classIndex = (uint32AtPointer(_aClass + 4)) & (identityHashHalfWordMask());
	if (_classIndex == 0) {
		/* begin allocateSlots:format:classIndex:isPinned:isOldSpace: */
		{
			_numBytes = BaseHeaderSize + 8;
		}
		_hasToScheduleScavenge = (GIV(freeStart) + _numBytes) > GIV(scavengeThreshold);
		if (_hasToScheduleScavenge || 0) {
			if (_hasToScheduleScavenge) {
				if (!GIV(needGCFlag)) {
					/* begin scheduleScavenge */
					GIV(needGCFlag) = 1;
					forceInterruptCheck();
					/* end scheduleScavenge */
				}
			}
			{
				_freeChunk = allocateSlotsInOldSpacebytesformatclassIndex(0, _numBytes, 2, ClassArrayCompactIndex);
				goto l4;
			}
		}
		_newObj = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(GIV(freeStart), 0, 2, ClassArrayCompactIndex, 0);
		assert((_numBytes % (allocationUnit())) == 0);
		assert((_newObj % (allocationUnit())) == 0);
		GIV(freeStart) += _numBytes;
		_freeChunk = _newObj;
		l4:
		;
		/* end allocateSlots:format:classIndex:isPinned:isOldSpace: */
		return _freeChunk;
	}
	_freeChunk = allocateLargestFreeChunk();
	_start = _freeChunk + BaseHeaderSize;
	_limit = addressAfter(_freeChunk);
	if (isClassAtUniqueIndex(_aClass)) {
		/* begin uniqueIndex:allInstancesInto:limit:resultsInto: */
		_count2 = 0;
		_ptr2 = _start;
		/* begin allHeapEntitiesDo: */
		/* begin allOldSpaceEntitiesDo: */
		/* begin allOldSpaceEntitiesFrom:do: */
		assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
		_prevPrevObj2 = (_prevObj2 = null);
		_objOop2 = GIV(nilObj);
		while (1) {
			assert((_objOop2 % (allocationUnit())) == 0);
			if (!(oopisLessThan(_objOop2, (GIV(memoryMap)->oldSpaceEnd)))) 
				break;
			assert((uint64AtPointer(_objOop2)) != 0);
			{
				{
					if (((longAt(_objOop2)) & (classIndexMask())) > (lastClassIndexPun())) {
						if (((longAt(_objOop2)) & (classIndexMask())) == _classIndex) {
							_count2 += 1;
							if (_ptr2 < _limit) {
								longAtput(_ptr2, _objOop2);
								_ptr2 += BytesPerOop;
							}
						}
					} else {
					}
				}
			}
			_prevPrevObj2 = _prevObj2;
			_prevObj2 = _objOop2;
			/* begin objectAfter:limit: */
			_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			_followingWordAddress4 = addressAfter(_objOop2);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
				_objOop2 = _limit2;
				goto l7;
			}
			flag("endianness");
			_followingWord4 = unsignedLongAt(_followingWordAddress4);
			_objOop2 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress4 + BaseHeaderSize
				 : _followingWordAddress4);
			l7:
			;
			/* end objectAfter:limit: */
		}
		/* end allOldSpaceEntitiesFrom:do: */
		/* end allOldSpaceEntitiesDo: */
		/* begin allNewSpaceEntitiesDo: */
		_prevPrevObj = (_prevObj = null);
		assert((((pastSpace()).start)) < (((eden()).start)));
		/* begin objectStartingAt: */
		_address = ((pastSpace()).start);
		_numSlots = byteAt(_address + 7);
		_objOop = ((_numSlots == (numSlotsMask()))
			 ? _address + BaseHeaderSize
			 : _address);
		/* end objectStartingAt: */
		_limit3 = GIV(pastSpaceStart);
		while (oopisLessThan(_objOop, _limit3)) {
			{
				{
					if (((longAt(_objOop)) & (classIndexMask())) > (lastClassIndexPun())) {
						if (((longAt(_objOop)) & (classIndexMask())) == _classIndex) {
							_count2 += 1;
							if (_ptr2 < _limit) {
								longAtput(_ptr2, _objOop);
								_ptr2 += BytesPerOop;
							}
						}
					} else {
					}
				}
			}
			_prevPrevObj = _prevObj;
			_prevObj = _objOop;
			/* begin objectAfter:limit: */
			_followingWordAddress = addressAfter(_objOop);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit3)) {
				_objOop = _limit3;
				goto l9;
			}
			flag("endianness");
			_followingWord = unsignedLongAt(_followingWordAddress);
			_objOop = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress + BaseHeaderSize
				 : _followingWordAddress);
			l9:
			;
			/* end objectAfter:limit: */
		}
		/* begin objectStartingAt: */
		_address2 = ((eden()).start);
		_numSlots2 = byteAt(_address2 + 7);
		_objOop = ((_numSlots2 == (numSlotsMask()))
			 ? _address2 + BaseHeaderSize
			 : _address2);
		/* end objectStartingAt: */
		while (oopisLessThan(_objOop, GIV(freeStart))) {
			{
				{
					if (((longAt(_objOop)) & (classIndexMask())) > (lastClassIndexPun())) {
						if (((longAt(_objOop)) & (classIndexMask())) == _classIndex) {
							_count2 += 1;
							if (_ptr2 < _limit) {
								longAtput(_ptr2, _objOop);
								_ptr2 += BytesPerOop;
							}
						}
					} else {
					}
				}
			}
			_prevPrevObj = _prevObj;
			_prevObj = _objOop;
			/* begin objectAfter:limit: */
			_followingWordAddress2 = addressAfter(_objOop);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
				_objOop = GIV(freeStart);
				goto l11;
			}
			flag("endianness");
			_followingWord2 = unsignedLongAt(_followingWordAddress2);
			_objOop = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress2 + BaseHeaderSize
				 : _followingWordAddress2);
			l11:
			;
			/* end objectAfter:limit: */
		}
		/* end allNewSpaceEntitiesDo: */
		/* begin allPermSpaceObjectsDo: */
		_currentObject = (GIV(memoryMap)->permSpaceStart);
		while (!(_currentObject == GIV(permSpaceFreeStart))) {
			if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
				{
					{
						if (((longAt(_currentObject)) & (classIndexMask())) > (lastClassIndexPun())) {
							if (((longAt(_currentObject)) & (classIndexMask())) == _classIndex) {
								_count2 += 1;
								if (_ptr2 < _limit) {
									longAtput(_ptr2, _currentObject);
									_ptr2 += BytesPerOop;
								}
							}
						} else {
						}
					}
				}
			}
			/* begin objectAfter:limit: */
			_followingWordAddress3 = addressAfter(_currentObject);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
				_currentObject = GIV(permSpaceFreeStart);
				goto l6;
			}
			flag("endianness");
			_followingWord3 = unsignedLongAt(_followingWordAddress3);
			_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress3 + BaseHeaderSize
				 : _followingWordAddress3);
			l6:
			;
			/* end objectAfter:limit: */
		}
		/* end allPermSpaceObjectsDo: */
		/* end allHeapEntitiesDo: */
		{
			_count = _count2;
			_ptr = _ptr2;
		}
		/* end uniqueIndex:allInstancesInto:limit:resultsInto: */
	} else {
		/* begin ambiguousClass:allInstancesInto:limit:resultsInto: */
		_count3 = 0;
		_ptr3 = _start;
		_expectedIndex = (uint32AtPointer(_aClass + 4)) & (identityHashHalfWordMask());
		/* begin allHeapEntitiesDo: */
		/* begin allOldSpaceEntitiesDo: */
		/* begin allOldSpaceEntitiesFrom:do: */
		assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
		_prevPrevObj22 = (_prevObj22 = null);
		_objOop22 = GIV(nilObj);
		while (1) {
			assert((_objOop22 % (allocationUnit())) == 0);
			if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
				break;
			assert((uint64AtPointer(_objOop22)) != 0);
			{
				{
					if (((longAt(_objOop22)) & (classIndexMask())) > (lastClassIndexPun())) {
						_actualIndex = (longAt(_objOop22)) & (classIndexMask());
						if ((classOrNilAtIndex(_actualIndex)) == _aClass) {
							if (_actualIndex != _expectedIndex) {
								/* begin setClassIndexOf:to: */
								assert((_expectedIndex >= 0) && (_expectedIndex <= (classIndexMask())));
								longAtput(_objOop22, ((longAt(_objOop22)) & (~((usqIntptr_t) (classIndexMask()) ))) + _expectedIndex);
								/* end setClassIndexOf:to: */
							}
							_count3 += 1;
							if (_ptr3 < _limit) {
								longAtput(_ptr3, _objOop22);
								_ptr3 += BytesPerOop;
							}
						}
					} else {
					}
				}
			}
			_prevPrevObj22 = _prevObj22;
			_prevObj22 = _objOop22;
			/* begin objectAfter:limit: */
			_limit22 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			_followingWordAddress42 = addressAfter(_objOop22);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress42, _limit22)) {
				_objOop22 = _limit22;
				goto l14;
			}
			flag("endianness");
			_followingWord42 = unsignedLongAt(_followingWordAddress42);
			_objOop22 = (((((usqInt) _followingWord42 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress42 + BaseHeaderSize
				 : _followingWordAddress42);
			l14:
			;
			/* end objectAfter:limit: */
		}
		/* end allOldSpaceEntitiesFrom:do: */
		/* end allOldSpaceEntitiesDo: */
		/* begin allNewSpaceEntitiesDo: */
		_prevPrevObj3 = (_prevObj3 = null);
		assert((((pastSpace()).start)) < (((eden()).start)));
		/* begin objectStartingAt: */
		_address3 = ((pastSpace()).start);
		_numSlots3 = byteAt(_address3 + 7);
		_objOop3 = ((_numSlots3 == (numSlotsMask()))
			 ? _address3 + BaseHeaderSize
			 : _address3);
		/* end objectStartingAt: */
		_limit32 = GIV(pastSpaceStart);
		while (oopisLessThan(_objOop3, _limit32)) {
			{
				{
					if (((longAt(_objOop3)) & (classIndexMask())) > (lastClassIndexPun())) {
						_actualIndex = (longAt(_objOop3)) & (classIndexMask());
						if ((classOrNilAtIndex(_actualIndex)) == _aClass) {
							if (_actualIndex != _expectedIndex) {
								/* begin setClassIndexOf:to: */
								assert((_expectedIndex >= 0) && (_expectedIndex <= (classIndexMask())));
								longAtput(_objOop3, ((longAt(_objOop3)) & (~((usqIntptr_t) (classIndexMask()) ))) + _expectedIndex);
								/* end setClassIndexOf:to: */
							}
							_count3 += 1;
							if (_ptr3 < _limit) {
								longAtput(_ptr3, _objOop3);
								_ptr3 += BytesPerOop;
							}
						}
					} else {
					}
				}
			}
			_prevPrevObj3 = _prevObj3;
			_prevObj3 = _objOop3;
			/* begin objectAfter:limit: */
			_followingWordAddress5 = addressAfter(_objOop3);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress5, _limit32)) {
				_objOop3 = _limit32;
				goto l13;
			}
			flag("endianness");
			_followingWord5 = unsignedLongAt(_followingWordAddress5);
			_objOop3 = (((((usqInt) _followingWord5 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress5 + BaseHeaderSize
				 : _followingWordAddress5);
			l13:
			;
			/* end objectAfter:limit: */
		}
		/* begin objectStartingAt: */
		_address22 = ((eden()).start);
		_numSlots22 = byteAt(_address22 + 7);
		_objOop3 = ((_numSlots22 == (numSlotsMask()))
			 ? _address22 + BaseHeaderSize
			 : _address22);
		/* end objectStartingAt: */
		while (oopisLessThan(_objOop3, GIV(freeStart))) {
			{
				{
					if (((longAt(_objOop3)) & (classIndexMask())) > (lastClassIndexPun())) {
						_actualIndex = (longAt(_objOop3)) & (classIndexMask());
						if ((classOrNilAtIndex(_actualIndex)) == _aClass) {
							if (_actualIndex != _expectedIndex) {
								/* begin setClassIndexOf:to: */
								assert((_expectedIndex >= 0) && (_expectedIndex <= (classIndexMask())));
								longAtput(_objOop3, ((longAt(_objOop3)) & (~((usqIntptr_t) (classIndexMask()) ))) + _expectedIndex);
								/* end setClassIndexOf:to: */
							}
							_count3 += 1;
							if (_ptr3 < _limit) {
								longAtput(_ptr3, _objOop3);
								_ptr3 += BytesPerOop;
							}
						}
					} else {
					}
				}
			}
			_prevPrevObj3 = _prevObj3;
			_prevObj3 = _objOop3;
			/* begin objectAfter:limit: */
			_followingWordAddress22 = addressAfter(_objOop3);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress22, GIV(freeStart))) {
				_objOop3 = GIV(freeStart);
				goto l16;
			}
			flag("endianness");
			_followingWord22 = unsignedLongAt(_followingWordAddress22);
			_objOop3 = (((((usqInt) _followingWord22 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress22 + BaseHeaderSize
				 : _followingWordAddress22);
			l16:
			;
			/* end objectAfter:limit: */
		}
		/* end allNewSpaceEntitiesDo: */
		/* begin allPermSpaceObjectsDo: */
		_currentObject2 = (GIV(memoryMap)->permSpaceStart);
		while (!(_currentObject2 == GIV(permSpaceFreeStart))) {
			if (!(((longAt(_currentObject2)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
				{
					{
						if (((longAt(_currentObject2)) & (classIndexMask())) > (lastClassIndexPun())) {
							_actualIndex = (longAt(_currentObject2)) & (classIndexMask());
							if ((classOrNilAtIndex(_actualIndex)) == _aClass) {
								if (_actualIndex != _expectedIndex) {
									/* begin setClassIndexOf:to: */
									assert((_expectedIndex >= 0) && (_expectedIndex <= (classIndexMask())));
									longAtput(_currentObject2, ((longAt(_currentObject2)) & (~((usqIntptr_t) (classIndexMask()) ))) + _expectedIndex);
									/* end setClassIndexOf:to: */
								}
								_count3 += 1;
								if (_ptr3 < _limit) {
									longAtput(_ptr3, _currentObject2);
									_ptr3 += BytesPerOop;
								}
							}
						} else {
						}
					}
				}
			}
			/* begin objectAfter:limit: */
			_followingWordAddress32 = addressAfter(_currentObject2);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress32, GIV(permSpaceFreeStart))) {
				_currentObject2 = GIV(permSpaceFreeStart);
				goto l17;
			}
			flag("endianness");
			_followingWord32 = unsignedLongAt(_followingWordAddress32);
			_currentObject2 = (((((usqInt) _followingWord32 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress32 + BaseHeaderSize
				 : _followingWordAddress32);
			l17:
			;
			/* end objectAfter:limit: */
		}
		/* end allPermSpaceObjectsDo: */
		/* end allHeapEntitiesDo: */
		/* begin purgeDuplicateClassTableEntriesFor: */
		_expectedIndex2 = (uint32AtPointer(_aClass + 4)) & (identityHashHalfWordMask());
		/* begin classTableEntriesDo: */
		for (_i2 = 0; _i2 < GIV(numClassTablePages); _i2 += 1) {
			_page = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _i2 ) << (shiftForWord())) ));
			for (_j = 0, _iLimit = (1U << (classTableMajorIndexShift())) - 1; _j <= _iLimit; _j += 1) {
				_classOrNil = unsignedLongAt((_page + BaseHeaderSize) + ((sqInt) (((usqInt) _j ) << (shiftForWord())) ));
				if (_classOrNil != GIV(nilObj)) {
					{
						_index = ((sqInt) (((usqInt) _i2 ) << (classTableMajorIndexShift())) ) + _j;
						if ((_classOrNil == _aClass) && ((_index != _expectedIndex2) && (_index > (lastClassIndexPun())))) {
							classAtIndexput(_index, GIV(nilObj));
							if (_index < GIV(classTableIndex)) {
								GIV(classTableIndex) = _index;
							}
						}
					}
				}
			}
		}
		/* end classTableEntriesDo: */
		assert(GIV(classTableIndex) >= (1U << (classTableMajorIndexShift())));
		/* end purgeDuplicateClassTableEntriesFor: */
		{
			_count = _count3;
			_ptr = _ptr3;
		}
		/* end ambiguousClass:allInstancesInto:limit:resultsInto: */
	}
	assert(isEmptyObjStack(GIV(markStack)));
	{
		assert(isEmptyObjStack(GIV(weaklingStack)));
	}
	if ((_count > ((_ptr - _start) / BytesPerOop)) || ((_limit != _ptr) && ((_limit - _ptr) <= 8))) {
		freeObject(_freeChunk);
		return ((((usqInt) _count ) << 3) | 1);
	}
	if (_count < (numSlotsMask())) {
		/* begin allocateSlots:format:classIndex:isPinned:isOldSpace: */
		if (_count >= (numSlotsMask())) {
			if ((((usqInt) _count ) >> 56) > 0) {
				_smallObj = null;
				goto l5;
			}
			_numBytes2 = (BaseHeaderSize + BaseHeaderSize) + (_count * BytesPerOop);
		} else {
			_numBytes2 = BaseHeaderSize + (((_count < 1)
				 ? 8
				 : _count * BytesPerOop));
		}
		_hasToScheduleScavenge2 = (GIV(freeStart) + _numBytes2) > GIV(scavengeThreshold);
		if (_hasToScheduleScavenge2 || 0) {
			if (_hasToScheduleScavenge2) {
				if (!GIV(needGCFlag)) {
					/* begin scheduleScavenge */
					GIV(needGCFlag) = 1;
					forceInterruptCheck();
					/* end scheduleScavenge */
				}
			}
			{
				_smallObj = allocateSlotsInOldSpacebytesformatclassIndex(_count, _numBytes2, 2, ClassArrayCompactIndex);
				goto l5;
			}
		}
		_newObj2 = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(GIV(freeStart), _count, 2, ClassArrayCompactIndex, 0);
		assert((_numBytes2 % (allocationUnit())) == 0);
		assert((_newObj2 % (allocationUnit())) == 0);
		GIV(freeStart) += _numBytes2;
		_smallObj = _newObj2;
		l5:
		;
		/* end allocateSlots:format:classIndex:isPinned:isOldSpace: */
		for (_i = 0; _i < _count; _i += 1) {
			/* begin storePointerUnchecked:ofObject:withValue: */
			_valuePointer = unsignedLongAt((_freeChunk + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
			assert(!(isOopForwarded(_smallObj)));
			longAtput((_smallObj + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _valuePointer);
			/* end storePointerUnchecked:ofObject:withValue: */
		}
		freeChunkWithBytesat(bytesInObject(_freeChunk), (((byteAt(_freeChunk + 7)) == (numSlotsMask()))
			 ? _freeChunk - BaseHeaderSize
			 : _freeChunk));
		beRootIfOld(_smallObj);
		/* begin checkFreeSpace: */
		assert(bitsSetInFreeSpaceMaskForAllFreeLists());
		assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
		if ((checkForLeaks & (GCModeFreeSpace | GCModeFull)) == (GCModeFreeSpace | GCModeFull)) {
			runLeakCheckerForFreeSpace(GCModeFreeSpace);
		}
		/* end checkFreeSpace: */
		return _smallObj;
	}
	_bytes = (BaseHeaderSize + BaseHeaderSize) + (_count * BytesPerOop);
	_start = (((byteAt(_freeChunk + 7)) == (numSlotsMask()))
		 ? _freeChunk - BaseHeaderSize
		 : _freeChunk);
	freeChunkWithBytesat((_limit - _start) - _bytes, _start + _bytes);
	GIV(totalFreeOldSpace) -= _bytes;
	/* begin rawOverflowSlotsOf:put: */
	longAtput(_freeChunk - BaseHeaderSize, ((sqInt) (((usqInt) (numSlotsMask()) ) << 56) ) + _count);
	/* end rawOverflowSlotsOf:put: */
	/* begin set:classIndexTo:formatTo: */
	assert((ClassArrayCompactIndex >= 0) && (ClassArrayCompactIndex <= (classIndexMask())));
	assert((2 >= 0) && (2 <= (formatMask())));
	longAtput(_freeChunk, ((longAt(_freeChunk)) & (~((usqIntptr_t) (((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) + (classIndexMask())) ))) + (ClassArrayCompactIndex + (2U << (formatShift()))));
	/* end set:classIndexTo:formatTo: */
	/* begin possibleOldObjectStoreInto: */
	if (!(((((usqInt) (long64At(_freeChunk)) ) >> (rememberedBitShift())) & 1) != 0)) {
		remember(GIV(fromOldSpaceRememberedSet), _freeChunk);
	}
	/* end possibleOldObjectStoreInto: */
	/* begin checkFreeSpace: */
	assert(bitsSetInFreeSpaceMaskForAllFreeLists());
	assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
	if ((checkForLeaks & (GCModeFreeSpace | GCModeFull)) == (GCModeFreeSpace | GCModeFull)) {
		runLeakCheckerForFreeSpace(GCModeFreeSpace);
	}
	/* end checkFreeSpace: */
	runLeakCheckerFor(GCModeFull);
	return _freeChunk;
}
/*	Attempt to answer an array of all objects, excluding those that may 
	be garbage collected as a side effect of allocating the result array. 
	If no memory is available answer the number of objects as a SmallInteger. 
	Since objects are at least 16 bytes big, and the largest SmallInteger 
	covers 1/4 of the address space, the count can never overflow. */
/* SpurMemoryManager>>#allObjects */
static sqInt
allObjects(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	usqInt _bytes;
	int _count;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	sqInt _freeChunk;
	usqInt _limit;
	sqInt _limit2;
	usqInt _limit3;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;
	sqInt _ptr;
	sqInt _start;

	_freeChunk = allocateLargestFreeChunk();
	_ptr = (_start = _freeChunk + BaseHeaderSize);
	_limit = addressAfter(_freeChunk);
	_count = 0;
	/* begin allHeapEntitiesDo: */
	/* begin allOldSpaceEntitiesDo: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop2 = GIV(nilObj);
	while (1) {
		assert((_objOop2 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop2, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop2)) != 0);
		{
			{
				if (((longAt(_objOop2)) & (classIndexMask())) > (lastClassIndexPun())) {
					_count += 1;
					if (_ptr < _limit) {
						longAtput(_ptr, _objOop2);
						_ptr += BytesPerOop;
					}
				} else {
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop2;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop2 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop2 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceEntitiesDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit3 = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop, _limit3)) {
		{
			{
				if (((longAt(_objOop)) & (classIndexMask())) > (lastClassIndexPun())) {
					_count += 1;
					if (_ptr < _limit) {
						longAtput(_ptr, _objOop);
						_ptr += BytesPerOop;
					}
				} else {
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit3)) {
			_objOop = _limit3;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop, GIV(freeStart))) {
		{
			{
				if (((longAt(_objOop)) & (classIndexMask())) > (lastClassIndexPun())) {
					_count += 1;
					if (_ptr < _limit) {
						longAtput(_ptr, _objOop);
						_ptr += BytesPerOop;
					}
				} else {
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				{
					if (((longAt(_currentObject)) & (classIndexMask())) > (lastClassIndexPun())) {
						_count += 1;
						if (_ptr < _limit) {
							longAtput(_ptr, _currentObject);
							_ptr += BytesPerOop;
						}
					} else {
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allHeapEntitiesDo: */
	assert(isEmptyObjStack(GIV(markStack)));
	{
		assert(isEmptyObjStack(GIV(weaklingStack)));
	}
	assert(_count >= (numSlotsMask()));
	if ((_count > ((_ptr - _start) / BytesPerOop)) || ((_limit != _ptr) && ((_limit - _ptr) <= 8))) {
		freeChunkWithBytesat(bytesInObject(_freeChunk), (((byteAt(_freeChunk + 7)) == (numSlotsMask()))
			 ? _freeChunk - BaseHeaderSize
			 : _freeChunk));
		/* begin checkFreeSpace: */
		assert(bitsSetInFreeSpaceMaskForAllFreeLists());
		assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
		if ((checkForLeaks & (GCModeFreeSpace | GCModeFull)) == (GCModeFreeSpace | GCModeFull)) {
			runLeakCheckerForFreeSpace(GCModeFreeSpace);
		}
		/* end checkFreeSpace: */
		return ((((usqInt) _count ) << 3) | 1);
	}
	_bytes = (BaseHeaderSize + BaseHeaderSize) + (_count * BytesPerOop);
	_start = (((byteAt(_freeChunk + 7)) == (numSlotsMask()))
		 ? _freeChunk - BaseHeaderSize
		 : _freeChunk);
	freeChunkWithBytesat((_limit - _start) - _bytes, _start + _bytes);
	GIV(totalFreeOldSpace) -= _bytes;
	/* begin rawOverflowSlotsOf:put: */
	longAtput(_freeChunk - BaseHeaderSize, ((sqInt) (((usqInt) (numSlotsMask()) ) << 56) ) + _count);
	/* end rawOverflowSlotsOf:put: */
	/* begin set:classIndexTo:formatTo: */
	assert((ClassArrayCompactIndex >= 0) && (ClassArrayCompactIndex <= (classIndexMask())));
	assert((2 >= 0) && (2 <= (formatMask())));
	longAtput(_freeChunk, ((longAt(_freeChunk)) & (~((usqIntptr_t) (((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) + (classIndexMask())) ))) + (ClassArrayCompactIndex + (2U << (formatShift()))));
	/* end set:classIndexTo:formatTo: */
	/* begin possibleOldObjectStoreInto: */
	if (!(((((usqInt) (long64At(_freeChunk)) ) >> (rememberedBitShift())) & 1) != 0)) {
		remember(GIV(fromOldSpaceRememberedSet), _freeChunk);
	}
	/* end possibleOldObjectStoreInto: */
	/* begin checkFreeSpace: */
	assert(bitsSetInFreeSpaceMaskForAllFreeLists());
	assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
	if ((checkForLeaks & (GCModeFreeSpace | GCModeFull)) == (GCModeFreeSpace | GCModeFull)) {
		runLeakCheckerForFreeSpace(GCModeFreeSpace);
	}
	/* end checkFreeSpace: */
	runLeakCheckerFor(GCModeFull);
	return _freeChunk;
}
/* SpurMemoryManager>>#allObjectsUnmarked */
static sqInt
allObjectsUnmarked(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	/* begin allObjectsDo: */
	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop2 = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop2, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((((usqInt) (longAt(_objOop2)) ) >> (markedBitFullShift())) & 1) != 0) {
					GIV(bogon) = _objOop2;
					return 0;
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l2;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l2:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop2 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((((usqInt) (longAt(_objOop2)) ) >> (markedBitFullShift())) & 1) != 0) {
					GIV(bogon) = _objOop2;
					return 0;
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop2 = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	/* begin allOldSpaceObjectsDo: */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop22 = GIV(nilObj);
	while (1) {
		assert((_objOop22 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop22)) != 0);
		{
			if (isEnumerableObject(_objOop22)) {
				{
					if (((((usqInt) (longAt(_objOop22)) ) >> (markedBitFullShift())) & 1) != 0) {
						GIV(bogon) = _objOop22;
						return 0;
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop22 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	/* end allOldSpaceObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (((((usqInt) (longAt(_currentObject)) ) >> (markedBitFullShift())) & 1) != 0) {
					GIV(bogon) = _currentObject;
					return 0;
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
	return 1;
}
/* SpurMemoryManager>>#allOldMarkedWeakObjectsOnWeaklingStack */
static sqInt
allOldMarkedWeakObjectsOnWeaklingStack(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _followingWord;
	usqInt _followingWordAddress;
	sqInt _limit;
	sqInt _objOop;
	sqInt _prevObj;
	sqInt _prevPrevObj;

	/* begin allOldSpaceEntitiesDo: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj = (_prevObj = null);
	_objOop = GIV(nilObj);
	while (1) {
		assert((_objOop % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop)) != 0);
		{
			if ((isWeakFormat((((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask()))) && (((((usqInt) (longAt(_objOop)) ) >> (markedBitFullShift())) & 1) != 0)) {
				if (!(isonObjStack(_objOop, GIV(weaklingStack)))) {
					return 0;
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_limit = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop = _limit;
			goto l2;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l2:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceEntitiesDo: */
	return 1;
}
/*	Answer the largest free chunk in the free lists.would like to use ifNotNil: but the ^next inside the ^blah ifNotNil: 
	confused Slang */
/* SpurMemoryManager>>#allocateLargestFreeChunk */
static sqInt
allocateLargestFreeChunk(void)
{
	sqInt _freeChunk;
	sqInt _next;
	sqInt _nextFreeChunk;

	_freeChunk = findLargestFreeChunk();
	if (!_freeChunk) {
		return null;
	}
	/* begin fetchPointer:ofFreeChunk: */
	_next = unsignedLongAt((_freeChunk + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofFreeChunk: */
	if (_next != 0) {
		assert((bytesInObject(_freeChunk)) >= (numFreeLists()));
		/* begin setNextFreeChunkOf:withValue:isLilliputianSize: */
		_nextFreeChunk = unsignedLongAt((_next + BaseHeaderSize) + (0U << (shiftForWord())));
		/* begin storePointer:ofFreeChunk:withValue: */
		assert(isFreeObject(_freeChunk));
		assert((_nextFreeChunk == 0) || (isFreeObject(_nextFreeChunk)));
		unsignedLongAtput((_freeChunk + BaseHeaderSize) + (0U << (shiftForWord())), _nextFreeChunk);
		/* end storePointer:ofFreeChunk:withValue: */
		if ((_nextFreeChunk != 0) && !0) {
			/* begin storePointer:ofFreeChunk:withValue: */
			assert(isFreeObject(_nextFreeChunk));
			assert((_freeChunk == 0) || (isFreeObject(_freeChunk)));
			unsignedLongAtput((_nextFreeChunk + BaseHeaderSize) + (1U << (shiftForWord())), _freeChunk);
			/* end storePointer:ofFreeChunk:withValue: */
		}
		/* end setNextFreeChunkOf:withValue:isLilliputianSize: */
		return _next;
	}
	unlinkSolitaryFreeTreeNode(_freeChunk);
	return _freeChunk;
}
/*	Allocate an object with numSlots in newSpace. This is for the `ee' 
	execution engine allocations, 
	and must be satisfied. If no memory is available, abort. If the allocation 
	pushes freeStart past 
	scavengeThreshold and a scavenge is not already scheduled, schedule a 
	scavenge. Object headers are 8 bytes in length if the slot size fits in the num 
	slots field (max implies overflow), 
	16 bytes otherwise (num slots in preceding word). 
	Objects always have at least one slot, for the forwarding pointer, 
	and are multiples of 8 bytes in length. */
/* SpurMemoryManager>>#allocateNewSpaceSlots:format:classIndex: */
static sqInt NoDbgRegParms
allocateNewSpaceSlotsformatclassIndex(sqInt _numSlots, sqInt _formatField, sqInt _classIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _newObj;
	usqInt _numBytes;

	if (_numSlots >= (numSlotsMask())) {
		if (_numSlots > 0xFFFFFFFFU) {
			return null;
		}
		_newObj = GIV(freeStart) + BaseHeaderSize;
		_numBytes = (BaseHeaderSize + BaseHeaderSize) + (_numSlots * BytesPerOop);
	} else {
		_newObj = GIV(freeStart);
		_numBytes = BaseHeaderSize + (((_numSlots < 1)
			 ? 8
			 : _numSlots * BytesPerOop));
	}
	if ((GIV(freeStart) + _numBytes) > GIV(scavengeThreshold)) {
		if (!GIV(needGCFlag)) {
			/* begin scheduleScavenge */
			GIV(needGCFlag) = 1;
			forceInterruptCheck();
			/* end scheduleScavenge */
		}
		if ((GIV(freeStart) + _numBytes) > (((eden()).limit))) {
			error("no room in eden for allocateNewSpaceSlots:format:classIndex:");
			return 0;
		}
	}
	if (_numSlots >= (numSlotsMask())) {
		flag("endianness");
		long32Atput(GIV(freeStart), _numSlots);
		long32Atput(GIV(freeStart) + 4, ((int) ((sqInt) (((usqInt) (numSlotsMask()) ) << (numSlotsHalfShift())) ) ));
		long64Atput(_newObj, headerForSlotsformatclassIndex(numSlotsMask(), _formatField, _classIndex));
	} else {
		long64Atput(_newObj, ((((usqLong) _numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) _formatField ) << (formatShift())) )) + _classIndex);
	}
	assert((_numBytes % (allocationUnit())) == 0);
	assert((_newObj % (allocationUnit())) == 0);
	GIV(freeStart) += _numBytes;
	return _newObj;
}
/*	Answer a chunk of oldSpace from the free lists, if available, 
	otherwise answer nil. Break up a larger chunk if one of the 
	exact size does not exist. N.B. the chunk is simply a pointer, it 
	has no valid header. The caller *must* fill in the header correctly.for debugging:totalFreeOldSpace := self totalFreeListBytes */
/* SpurMemoryManager>>#allocateOldSpaceChunkOfBytes: */
static sqInt NoDbgRegParms
allocateOldSpaceChunkOfBytes(usqInt _chunkBytes)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _child;
	usqInt _childBytes;
	sqInt _chunk;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;
	sqInt _fieldIndex3;
	sqInt _index;
	usqInt _initialIndex;
	sqInt _next;
	sqInt _next2;
	sqInt _next3;
	sqInt _nextFreeChunk;
	sqInt _nextFreeChunk2;
	sqInt _nodeBytes;
	sqInt _parent;

	_nodeBytes = 0;
	GIV(totalFreeOldSpace) -= _chunkBytes;
	_initialIndex = _chunkBytes / 8;
	if ((_initialIndex < 64) && ((1ULL << _initialIndex) <= GIV(freeListsMask))) {
		if (GIV(freeListsMask) & (1ULL << _initialIndex)) {
			if (((_chunk = GIV(freeLists)[_initialIndex])) != 0) {
				assert(_chunk == (startOfObject(_chunk)));
				/* begin assertValidFreeObject: */
				assert(assertInnerValidFreeObject(_chunk));
				/* end assertValidFreeObject: */
				/* begin unlinkFreeChunk:atIndex:isLilliputianSize: */
				assert(((bytesInObject(_chunk)) == (_initialIndex * (allocationUnit()))) && ((_initialIndex > 1) && ((startOfObject(_chunk)) == _chunk)));
				GIV(freeLists)[_initialIndex] = (_next = unsignedLongAt((_chunk + BaseHeaderSize) + (0U << (shiftForWord()))));
				if ((!((assert(_chunkBytes >= (BaseHeaderSize + (allocationUnit()))), _chunkBytes == (BaseHeaderSize + 8)))) && (_next != 0)) {
					/* begin storePointer:ofFreeChunk:withValue: */
					_fieldIndex = 1;
					assert(isFreeObject(_next));
					assert(1);
					unsignedLongAtput((_next + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ), 0);
					/* end storePointer:ofFreeChunk:withValue: */
				}
				/* end unlinkFreeChunk:atIndex:isLilliputianSize: */
				return _chunk;
			}
			GIV(freeListsMask) -= 1ULL << _initialIndex;
		}
		_index = _initialIndex;
		while ((((_index += _index)) < 64) && ((1ULL << _index) <= GIV(freeListsMask))) {
			if (GIV(freeListsMask) & (1ULL << _index)) {
				if (((_chunk = GIV(freeLists)[_index])) != 0) {
					assert(_chunk == (startOfObject(_chunk)));
					/* begin assertValidFreeObject: */
					assert(assertInnerValidFreeObject(_chunk));
					/* end assertValidFreeObject: */
					/* begin unlinkFreeChunk:atIndex:isLilliputianSize: */
					assert(((bytesInObject(_chunk)) == (_index * (allocationUnit()))) && ((_index > 1) && ((startOfObject(_chunk)) == _chunk)));
					GIV(freeLists)[_index] = (_next2 = unsignedLongAt((_chunk + BaseHeaderSize) + (0U << (shiftForWord()))));
					if (_next2 != 0) {
						/* begin storePointer:ofFreeChunk:withValue: */
						_fieldIndex2 = 1;
						assert(isFreeObject(_next2));
						assert(1);
						unsignedLongAtput((_next2 + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ), 0);
						/* end storePointer:ofFreeChunk:withValue: */
					}
					/* end unlinkFreeChunk:atIndex:isLilliputianSize: */
					assert((bytesInObject(_chunk)) == (_index * (allocationUnit())));
					freeChunkWithBytesat((_index * 8) - _chunkBytes, ((((byteAt(_chunk + 7)) == (numSlotsMask()))
						 ? _chunk - BaseHeaderSize
						 : _chunk)) + _chunkBytes);
					return _chunk;
				}
				GIV(freeListsMask) -= 1ULL << _index;
			}
		}
		_index = _initialIndex + 1;
		while ((((_index += 1)) < 64) && ((1ULL << _index) <= GIV(freeListsMask))) {
			if (GIV(freeListsMask) & (1ULL << _index)) {
				if (((_chunk = GIV(freeLists)[_index])) != 0) {
					assert(_chunk == (startOfObject(_chunk)));
					/* begin assertValidFreeObject: */
					assert(assertInnerValidFreeObject(_chunk));
					/* end assertValidFreeObject: */
					/* begin unlinkFreeChunk:atIndex:isLilliputianSize: */
					assert(((bytesInObject(_chunk)) == (_index * (allocationUnit()))) && ((_index > 1) && ((startOfObject(_chunk)) == _chunk)));
					GIV(freeLists)[_index] = (_next3 = unsignedLongAt((_chunk + BaseHeaderSize) + (0U << (shiftForWord()))));
					if (_next3 != 0) {
						/* begin storePointer:ofFreeChunk:withValue: */
						_fieldIndex3 = 1;
						assert(isFreeObject(_next3));
						assert(1);
						unsignedLongAtput((_next3 + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex3 ) << (shiftForWord())) ), 0);
						/* end storePointer:ofFreeChunk:withValue: */
					}
					/* end unlinkFreeChunk:atIndex:isLilliputianSize: */
					assert((bytesInObject(_chunk)) == (_index * (allocationUnit())));
					freeChunkWithBytesat((_index * 8) - _chunkBytes, ((((byteAt(_chunk + 7)) == (numSlotsMask()))
						 ? _chunk - BaseHeaderSize
						 : _chunk)) + _chunkBytes);
					return _chunk;
				}
				GIV(freeListsMask) -= 1ULL << _index;
			}
		}
	}
	_parent = 0;
	_child = GIV(freeLists)[0];
	while (_child != 0) {
		/* begin assertValidFreeObject: */
		assert(assertInnerValidFreeObject(_child));
		/* end assertValidFreeObject: */
		_childBytes = bytesInObject(_child);
		if (_childBytes == _chunkBytes) {
			/* begin fetchPointer:ofFreeChunk: */
			_chunk = unsignedLongAt((_child + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofFreeChunk: */
			if (_chunk != 0) {
				/* begin assertValidFreeObject: */
				assert(assertInnerValidFreeObject(_chunk));
				/* end assertValidFreeObject: */
				/* begin setNextFreeChunkOf:withValue:isLilliputianSize: */
				_nextFreeChunk = unsignedLongAt((_chunk + BaseHeaderSize) + (0U << (shiftForWord())));
				/* begin storePointer:ofFreeChunk:withValue: */
				assert(isFreeObject(_child));
				assert((_nextFreeChunk == 0) || (isFreeObject(_nextFreeChunk)));
				unsignedLongAtput((_child + BaseHeaderSize) + (0U << (shiftForWord())), _nextFreeChunk);
				/* end storePointer:ofFreeChunk:withValue: */
				if ((_nextFreeChunk != 0) && !0) {
					/* begin storePointer:ofFreeChunk:withValue: */
					assert(isFreeObject(_nextFreeChunk));
					assert((_child == 0) || (isFreeObject(_child)));
					unsignedLongAtput((_nextFreeChunk + BaseHeaderSize) + (1U << (shiftForWord())), _child);
					/* end storePointer:ofFreeChunk:withValue: */
				}
				/* end setNextFreeChunkOf:withValue:isLilliputianSize: */
				return (((byteAt(_chunk + 7)) == (numSlotsMask()))
					 ? _chunk - BaseHeaderSize
					 : _chunk);
			}
			_nodeBytes = _childBytes;
			_parent = _child;
			_child = 0;
		} else {
			if (_childBytes <= (_chunkBytes + 8)) {
				/* begin fetchPointer:ofFreeChunk: */
				_child = unsignedLongAt((_child + BaseHeaderSize) + (4U << (shiftForWord())));
				/* end fetchPointer:ofFreeChunk: */
			} else {
				_parent = _child;
				_nodeBytes = _childBytes;
				/* begin fetchPointer:ofFreeChunk: */
				_child = unsignedLongAt((_child + BaseHeaderSize) + (3U << (shiftForWord())));
				/* end fetchPointer:ofFreeChunk: */
			}
		}
	}
	if (_parent == 0) {
		GIV(totalFreeOldSpace) += _chunkBytes;
		return null;
	}
	assert((_nodeBytes == _chunkBytes) || (_nodeBytes >= (_chunkBytes + (2 * (allocationUnit())))));
	assert((bytesInObject(_parent)) == _nodeBytes);
	/* begin fetchPointer:ofFreeChunk: */
	_chunk = unsignedLongAt((_parent + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofFreeChunk: */
	if (_chunk != 0) {
		assert((_chunkBytes == _nodeBytes) || ((_chunkBytes + (allocationUnit())) < _nodeBytes));
		/* begin setNextFreeChunkOf:withValue:isLilliputianSize: */
		_nextFreeChunk2 = unsignedLongAt((_chunk + BaseHeaderSize) + (0U << (shiftForWord())));
		/* begin storePointer:ofFreeChunk:withValue: */
		assert(isFreeObject(_parent));
		assert((_nextFreeChunk2 == 0) || (isFreeObject(_nextFreeChunk2)));
		unsignedLongAtput((_parent + BaseHeaderSize) + (0U << (shiftForWord())), _nextFreeChunk2);
		/* end storePointer:ofFreeChunk:withValue: */
		if ((_nextFreeChunk2 != 0) && !0) {
			/* begin storePointer:ofFreeChunk:withValue: */
			assert(isFreeObject(_nextFreeChunk2));
			assert((_parent == 0) || (isFreeObject(_parent)));
			unsignedLongAtput((_nextFreeChunk2 + BaseHeaderSize) + (1U << (shiftForWord())), _parent);
			/* end storePointer:ofFreeChunk:withValue: */
		}
		/* end setNextFreeChunkOf:withValue:isLilliputianSize: */
		if (_chunkBytes != _nodeBytes) {
			freeChunkWithBytesat(_nodeBytes - _chunkBytes, ((((byteAt(_chunk + 7)) == (numSlotsMask()))
				 ? _chunk - BaseHeaderSize
				 : _chunk)) + _chunkBytes);
		}
		return (((byteAt(_chunk + 7)) == (numSlotsMask()))
			 ? _chunk - BaseHeaderSize
			 : _chunk);
	}
	_chunk = _parent;
	unlinkSolitaryFreeTreeNode(_chunk);
	if (_chunkBytes != _nodeBytes) {
		freeChunkWithBytesat(_nodeBytes - _chunkBytes, ((((byteAt(_chunk + 7)) == (numSlotsMask()))
			 ? _chunk - BaseHeaderSize
			 : _chunk)) + _chunkBytes);
	}
	return (((byteAt(_chunk + 7)) == (numSlotsMask()))
		 ? _chunk - BaseHeaderSize
		 : _chunk);
}
/* SpurMemoryManager>>#allocatePinnedSlots: */
sqInt
allocatePinnedSlots(sqInt _nSlots)
{
	sqInt _obj;
	usqInt _p;

	_obj = allocateSlotsForPinningInOldSpacebytesformatclassIndex(_nSlots, ((_nSlots == 0)
		 ? 8 + BaseHeaderSize
		 : ((sqInt) (((usqInt) _nSlots ) << (shiftForWord())) ) + (((_nSlots >= (numSlotsMask()))
			 ? BaseHeaderSize + BaseHeaderSize
			 : BaseHeaderSize))), sixtyFourBitIndexableFormat(), sixtyFourBitLongsClassIndexPun());
	if (_obj) {
		/* begin fillObj:numSlots:with: */
		assert(oopisLessThan(((_obj + BaseHeaderSize) + (_nSlots * BytesPerOop)) - 1, addressAfter(_obj)));
		for (_p = ((usqInt) (_obj + BaseHeaderSize) ); _p <= ((usqInt) (((_obj + BaseHeaderSize) + (_nSlots * BytesPerOop)) - 1) ); _p += 8) {
			longAtput(_p, 0);
		}
		/* end fillObj:numSlots:with: */
	}
	return _obj;
}
/*	Answer the oop of a chunk of space in oldSpace with numSlots slots.  
	Try and allocate in a segment that already includes pinned objects. 
	If the option #avoidSearchingSegmentsWithPinnedObjects is true, we don't 
	do the search. 
	For some users this can have a good impact when having many pinned objects 
	used in FFI calls. 
	The header of the result will have been filled-in but not the contents. */
/* SpurMemoryManager>>#allocateSlotsForPinningInOldSpace:bytes:format:classIndex: */
static sqInt NoDbgRegParms
allocateSlotsForPinningInOldSpacebytesformatclassIndex(sqInt _numSlots, usqInt _totalBytes, sqInt _formatField, sqInt _classIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _acceptedChunk;
	sqInt _acceptedNode;
	sqInt _child;
	usqInt _childBytes;
	sqInt _chunk;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;
	sqInt _fieldIndex3;
	sqInt _index;
	usqInt _initialIndex;
	sqInt _newOop;
	sqInt _next;
	sqInt _next2;
	sqInt _next3;
	sqInt _next4;
	sqInt _nextFreeChunk;
	sqInt _nextFreeChunk2;
	sqInt _node;
	sqInt _prev;

	if (GIV(avoidSearchingSegmentsWithPinnedObjects)) {
		_chunk = null;
	} else {
		/* begin allocateOldSpaceChunkOfBytes:suchThat: */
		GIV(totalFreeOldSpace) -= _totalBytes;
		_initialIndex = _totalBytes / 8;
		if ((_initialIndex < 64) && ((1ULL << _initialIndex) <= GIV(freeListsMask))) {
			if (GIV(freeListsMask) & (1ULL << _initialIndex)) {
				if (((_node = GIV(freeLists)[_initialIndex])) == 0) {
					GIV(freeListsMask) -= 1ULL << _initialIndex;
				} else {
					_prev = 0;
					while (_node != 0) {
						assert(_node == (startOfObject(_node)));
						/* begin assertValidFreeObject: */
						assert(assertInnerValidFreeObject(_node));
						/* end assertValidFreeObject: */
						/* begin fetchPointer:ofFreeChunk: */
						_next = unsignedLongAt((_node + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofFreeChunk: */
						if (((segmentContainingObj(_node))->containsPinned)) {
							if (_prev == 0) {
								/* begin unlinkFreeChunk:atIndex:isLilliputianSize: */
								assert(((bytesInObject(_node)) == (_initialIndex * (allocationUnit()))) && ((_initialIndex > 1) && ((startOfObject(_node)) == _node)));
								GIV(freeLists)[_initialIndex] = (_next2 = unsignedLongAt((_node + BaseHeaderSize) + (0U << (shiftForWord()))));
								if ((!((assert(_totalBytes >= (BaseHeaderSize + (allocationUnit()))), _totalBytes == (BaseHeaderSize + 8)))) && (_next2 != 0)) {
									/* begin storePointer:ofFreeChunk:withValue: */
									_fieldIndex = 1;
									assert(isFreeObject(_next2));
									assert(1);
									unsignedLongAtput((_next2 + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ), 0);
									/* end storePointer:ofFreeChunk:withValue: */
								}
								/* end unlinkFreeChunk:atIndex:isLilliputianSize: */
							} else {
								/* begin setNextFreeChunkOf:withValue:chunkBytes: */
								/* begin setNextFreeChunkOf:withValue:isLilliputianSize: */
								/* begin storePointer:ofFreeChunk:withValue: */
								assert(isFreeObject(_prev));
								assert((_next == 0) || (isFreeObject(_next)));
								unsignedLongAtput((_prev + BaseHeaderSize) + (0U << (shiftForWord())), _next);
								/* end storePointer:ofFreeChunk:withValue: */
								if ((_next != 0) && (!((assert(_totalBytes >= (BaseHeaderSize + (allocationUnit()))), _totalBytes == (BaseHeaderSize + 8))))) {
									/* begin storePointer:ofFreeChunk:withValue: */
									assert(isFreeObject(_next));
									assert((_prev == 0) || (isFreeObject(_prev)));
									unsignedLongAtput((_next + BaseHeaderSize) + (1U << (shiftForWord())), _prev);
									/* end storePointer:ofFreeChunk:withValue: */
								}
								/* end setNextFreeChunkOf:withValue:isLilliputianSize: */
								/* end setNextFreeChunkOf:withValue:chunkBytes: */
							}
							_chunk = _node;
							goto l28;
						}
						_prev = _node;
						_node = _next;
					}
				}
			}
			_index = _initialIndex;
			while ((((_index += _initialIndex)) < 64) && ((1ULL << _index) <= GIV(freeListsMask))) {
				if (GIV(freeListsMask) & (1ULL << _index)) {
					if (((_node = GIV(freeLists)[_index])) == 0) {
						GIV(freeListsMask) -= 1ULL << _index;
					} else {
						_prev = 0;
						while (_node != 0) {
							assert(_node == (startOfObject(_node)));
							/* begin assertValidFreeObject: */
							assert(assertInnerValidFreeObject(_node));
							/* end assertValidFreeObject: */
							/* begin fetchPointer:ofFreeChunk: */
							_next = unsignedLongAt((_node + BaseHeaderSize) + (0U << (shiftForWord())));
							/* end fetchPointer:ofFreeChunk: */
							if (((segmentContainingObj(_node))->containsPinned)) {
								if (_prev == 0) {
									/* begin unlinkFreeChunk:atIndex:isLilliputianSize: */
									assert(((bytesInObject(_node)) == (_index * (allocationUnit()))) && ((_index > 1) && ((startOfObject(_node)) == _node)));
									GIV(freeLists)[_index] = (_next3 = unsignedLongAt((_node + BaseHeaderSize) + (0U << (shiftForWord()))));
									if (_next3 != 0) {
										/* begin storePointer:ofFreeChunk:withValue: */
										_fieldIndex2 = 1;
										assert(isFreeObject(_next3));
										assert(1);
										unsignedLongAtput((_next3 + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ), 0);
										/* end storePointer:ofFreeChunk:withValue: */
									}
									/* end unlinkFreeChunk:atIndex:isLilliputianSize: */
								} else {
									/* begin setNextFreeChunkOf:withValue:isLilliputianSize: */
									/* begin storePointer:ofFreeChunk:withValue: */
									assert(isFreeObject(_prev));
									assert((_next == 0) || (isFreeObject(_next)));
									unsignedLongAtput((_prev + BaseHeaderSize) + (0U << (shiftForWord())), _next);
									/* end storePointer:ofFreeChunk:withValue: */
									if ((_next != 0) && !0) {
										/* begin storePointer:ofFreeChunk:withValue: */
										assert(isFreeObject(_next));
										assert((_prev == 0) || (isFreeObject(_prev)));
										unsignedLongAtput((_next + BaseHeaderSize) + (1U << (shiftForWord())), _prev);
										/* end storePointer:ofFreeChunk:withValue: */
									}
									/* end setNextFreeChunkOf:withValue:isLilliputianSize: */
								}
								freeChunkWithBytesat((_index * 8) - _totalBytes, ((((byteAt(_node + 7)) == (numSlotsMask()))
									 ? _node - BaseHeaderSize
									 : _node)) + _totalBytes);
								_chunk = _node;
								goto l28;
							}
							_prev = _node;
							_node = _next;
						}
					}
				}
			}
			_index = _initialIndex + 1;
			while ((((_index += 1)) < 64) && ((1ULL << _index) <= GIV(freeListsMask))) {
				if (GIV(freeListsMask) & (1ULL << _index)) {
					if (((_node = GIV(freeLists)[_index])) == 0) {
						GIV(freeListsMask) -= 1ULL << _index;
					} else {
						_prev = 0;
						while (_node != 0) {
							assert(_node == (startOfObject(_node)));
							/* begin assertValidFreeObject: */
							assert(assertInnerValidFreeObject(_node));
							/* end assertValidFreeObject: */
							/* begin fetchPointer:ofFreeChunk: */
							_next = unsignedLongAt((_node + BaseHeaderSize) + (0U << (shiftForWord())));
							/* end fetchPointer:ofFreeChunk: */
							if (((segmentContainingObj(_node))->containsPinned)) {
								if (_prev == 0) {
									/* begin unlinkFreeChunk:atIndex:isLilliputianSize: */
									assert(((bytesInObject(_node)) == (_index * (allocationUnit()))) && ((_index > 1) && ((startOfObject(_node)) == _node)));
									GIV(freeLists)[_index] = (_next4 = unsignedLongAt((_node + BaseHeaderSize) + (0U << (shiftForWord()))));
									if (_next4 != 0) {
										/* begin storePointer:ofFreeChunk:withValue: */
										_fieldIndex3 = 1;
										assert(isFreeObject(_next4));
										assert(1);
										unsignedLongAtput((_next4 + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex3 ) << (shiftForWord())) ), 0);
										/* end storePointer:ofFreeChunk:withValue: */
									}
									/* end unlinkFreeChunk:atIndex:isLilliputianSize: */
								} else {
									/* begin setNextFreeChunkOf:withValue:isLilliputianSize: */
									/* begin storePointer:ofFreeChunk:withValue: */
									assert(isFreeObject(_prev));
									assert((_next == 0) || (isFreeObject(_next)));
									unsignedLongAtput((_prev + BaseHeaderSize) + (0U << (shiftForWord())), _next);
									/* end storePointer:ofFreeChunk:withValue: */
									if ((_next != 0) && !0) {
										/* begin storePointer:ofFreeChunk:withValue: */
										assert(isFreeObject(_next));
										assert((_prev == 0) || (isFreeObject(_prev)));
										unsignedLongAtput((_next + BaseHeaderSize) + (1U << (shiftForWord())), _prev);
										/* end storePointer:ofFreeChunk:withValue: */
									}
									/* end setNextFreeChunkOf:withValue:isLilliputianSize: */
								}
								freeChunkWithBytesat((_index * 8) - _totalBytes, ((((byteAt(_node + 7)) == (numSlotsMask()))
									 ? _node - BaseHeaderSize
									 : _node)) + _totalBytes);
								_chunk = _node;
								goto l28;
							}
							_prev = _node;
							_node = _next;
						}
					}
				}
			}
		}
		_child = GIV(freeLists)[0];
		_node = (_acceptedChunk = (_acceptedNode = 0));
		while (_child != 0) {
			/* begin assertValidFreeObject: */
			assert(assertInnerValidFreeObject(_child));
			/* end assertValidFreeObject: */
			_childBytes = bytesInObject(_child);
			if (_childBytes == _totalBytes) {
				_node = _child;
				while (1) {
					_prev = _node;
					/* begin fetchPointer:ofFreeChunk: */
					_node = unsignedLongAt((_node + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofFreeChunk: */
					if (!(_node != 0)) 
						break;
					if (((segmentContainingObj(_node))->containsPinned)) {
						/* begin assertValidFreeObject: */
						assert(assertInnerValidFreeObject(_node));
						/* end assertValidFreeObject: */
						/* begin setNextFreeChunkOf:withValue:isLilliputianSize: */
						_nextFreeChunk = unsignedLongAt((_node + BaseHeaderSize) + (0U << (shiftForWord())));
						/* begin storePointer:ofFreeChunk:withValue: */
						assert(isFreeObject(_prev));
						assert((_nextFreeChunk == 0) || (isFreeObject(_nextFreeChunk)));
						unsignedLongAtput((_prev + BaseHeaderSize) + (0U << (shiftForWord())), _nextFreeChunk);
						/* end storePointer:ofFreeChunk:withValue: */
						if ((_nextFreeChunk != 0) && !0) {
							/* begin storePointer:ofFreeChunk:withValue: */
							assert(isFreeObject(_nextFreeChunk));
							assert((_prev == 0) || (isFreeObject(_prev)));
							unsignedLongAtput((_nextFreeChunk + BaseHeaderSize) + (1U << (shiftForWord())), _prev);
							/* end storePointer:ofFreeChunk:withValue: */
						}
						/* end setNextFreeChunkOf:withValue:isLilliputianSize: */
						_chunk = (((byteAt(_node + 7)) == (numSlotsMask()))
							 ? _node - BaseHeaderSize
							 : _node);
						goto l28;
					}
				}
				if (((segmentContainingObj(_child))->containsPinned)) {
					/* begin fetchPointer:ofFreeChunk: */
					_next = unsignedLongAt((_child + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofFreeChunk: */
					if (_next == 0) {
						unlinkSolitaryFreeTreeNode(_child);
					}
 else {
						inFreeTreeReplacewith(_child, _next);
					}
					_chunk = (((byteAt(_child + 7)) == (numSlotsMask()))
						 ? _child - BaseHeaderSize
						 : _child);
					goto l28;
				}
			}
			if (_child != 0) {
				if (_childBytes <= (_totalBytes + 8)) {
					/* begin fetchPointer:ofFreeChunk: */
					_child = unsignedLongAt((_child + BaseHeaderSize) + (4U << (shiftForWord())));
					/* end fetchPointer:ofFreeChunk: */
				} else {
					flag("we can do better here; preferentially choosing the lowest node. That would be a form of best-fit since we are trying to compact down");
					_node = _child;
					/* begin fetchPointer:ofFreeChunk: */
					_child = unsignedLongAt((_node + BaseHeaderSize) + (3U << (shiftForWord())));
					/* end fetchPointer:ofFreeChunk: */
					if (_acceptedNode == 0) {
						_acceptedChunk = _node;
						do {
							/* begin fetchPointer:ofFreeChunk: */
							_acceptedChunk = unsignedLongAt((_acceptedChunk + BaseHeaderSize) + (0U << (shiftForWord())));
							/* end fetchPointer:ofFreeChunk: */
							if ((_acceptedChunk != 0) && (((segmentContainingObj(_acceptedChunk))->containsPinned))) {
								_acceptedNode = _node;
							}
						} while ((_acceptedChunk != 0) && (_acceptedNode == 0));
						if ((_acceptedNode == 0) && (((segmentContainingObj(_node))->containsPinned))) {
							_acceptedNode = _node;
							_child = 0;
						}
					}
				}
			}
		}
		if (_acceptedNode != 0) {
			if (_acceptedChunk != 0) {
				assert((bytesInObject(_acceptedChunk)) >= (_totalBytes + (allocationUnit())));
				while (1) {
					/* begin fetchPointer:ofFreeChunk: */
					_next = unsignedLongAt((_acceptedNode + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofFreeChunk: */
					if (!(_next != _acceptedChunk)) 
						break;
					_acceptedNode = _next;
				}
				/* begin setNextFreeChunkOf:withValue:isLilliputianSize: */
				_nextFreeChunk2 = unsignedLongAt((_acceptedChunk + BaseHeaderSize) + (0U << (shiftForWord())));
				/* begin storePointer:ofFreeChunk:withValue: */
				assert(isFreeObject(_acceptedNode));
				assert((_nextFreeChunk2 == 0) || (isFreeObject(_nextFreeChunk2)));
				unsignedLongAtput((_acceptedNode + BaseHeaderSize) + (0U << (shiftForWord())), _nextFreeChunk2);
				/* end storePointer:ofFreeChunk:withValue: */
				if ((_nextFreeChunk2 != 0) && !0) {
					/* begin storePointer:ofFreeChunk:withValue: */
					assert(isFreeObject(_nextFreeChunk2));
					assert((_acceptedNode == 0) || (isFreeObject(_acceptedNode)));
					unsignedLongAtput((_nextFreeChunk2 + BaseHeaderSize) + (1U << (shiftForWord())), _acceptedNode);
					/* end storePointer:ofFreeChunk:withValue: */
				}
				/* end setNextFreeChunkOf:withValue:isLilliputianSize: */
				freeChunkWithBytesat((bytesInObject(_acceptedChunk)) - _totalBytes, ((((byteAt(_acceptedChunk + 7)) == (numSlotsMask()))
					 ? _acceptedChunk - BaseHeaderSize
					 : _acceptedChunk)) + _totalBytes);
				_chunk = (((byteAt(_acceptedChunk + 7)) == (numSlotsMask()))
					 ? _acceptedChunk - BaseHeaderSize
					 : _acceptedChunk);
				goto l28;
			}
			/* begin fetchPointer:ofFreeChunk: */
			_next = unsignedLongAt((_acceptedNode + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofFreeChunk: */
			if (_next == 0) {
				unlinkSolitaryFreeTreeNode(_acceptedNode);
			}
 else {
				inFreeTreeReplacewith(_acceptedNode, _next);
			}
			assert((bytesInObject(_acceptedNode)) >= (_totalBytes + (allocationUnit())));
			freeChunkWithBytesat((bytesInObject(_acceptedNode)) - _totalBytes, ((((byteAt(_acceptedNode + 7)) == (numSlotsMask()))
				 ? _acceptedNode - BaseHeaderSize
				 : _acceptedNode)) + _totalBytes);
			_chunk = (((byteAt(_acceptedNode + 7)) == (numSlotsMask()))
				 ? _acceptedNode - BaseHeaderSize
				 : _acceptedNode);
			goto l28;
		}
		GIV(totalFreeOldSpace) += _totalBytes;
		_chunk = null;
		l28:
		;
		/* end allocateOldSpaceChunkOfBytes:suchThat: */
	}
	if (!_chunk) {
		_chunk = allocateOldSpaceChunkOfBytes(_totalBytes);
		if (!_chunk) {
			return null;
		}
		((segmentContainingObj(_chunk))->containsPinned = 1);
	}
	_newOop = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(_chunk, _numSlots, _formatField, _classIndex, 1);
	/* begin checkFreeSpace: */
	assert(bitsSetInFreeSpaceMaskForAllFreeLists());
	assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
	if ((checkForLeaks & (GCModeFreeSpace | GCModeNewSpace)) == (GCModeFreeSpace | GCModeNewSpace)) {
		runLeakCheckerForFreeSpace(GCModeFreeSpace);
	}
	/* end checkFreeSpace: */
	return _newOop;
}
/*	Answer the oop of a chunk of space in oldSpace with numSlots slots. The 
	header will have been filled-in but not the contents. If no memory is 
	available answer nil. */
/* SpurMemoryManager>>#allocateSlotsInOldSpace:bytes:format:classIndex: */
static sqInt NoDbgRegParms
allocateSlotsInOldSpacebytesformatclassIndex(sqInt _numSlots, usqInt _totalBytes, sqInt _formatField, sqInt _classIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _chunk;
	sqInt _newOop;

	_chunk = allocateOldSpaceChunkOfBytes(_totalBytes);
	if (!_chunk) {
		return null;
	}
	_newOop = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(_chunk, _numSlots, _formatField, _classIndex, 0);
	/* begin checkFreeSpace: */
	assert(bitsSetInFreeSpaceMaskForAllFreeLists());
	assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
	if ((checkForLeaks & (GCModeFreeSpace | GCModeNewSpace)) == (GCModeFreeSpace | GCModeNewSpace)) {
		runLeakCheckerForFreeSpace(GCModeFreeSpace);
	}
	/* end checkFreeSpace: */
	return _newOop;
}
/*	Answer the oop of a chunk of space in permanent Space with numSlots slots. 
	The header 
	will have been filled-in but not the contents. If no memory is available 
	answer nil. */
/* SpurMemoryManager>>#allocateSlotsInPermSpace:bytes:format:classIndex: */
static sqInt NoDbgRegParms
allocateSlotsInPermSpacebytesformatclassIndex(sqInt _numSlots, usqInt _totalBytes, sqInt _formatField, sqInt _classIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _chunk;
	sqInt _newOop;

	if ((GIV(permSpaceFreeStart) + _totalBytes) > ((GIV(memoryMap)->permSpaceEnd))) {
		if (!(extendPermObjectsSpaceMinimum(GIV(memoryMap), (GIV(permSpaceFreeStart) + _totalBytes) - ((GIV(memoryMap)->permSpaceEnd))))) {
			return null;
		}
	}
	_chunk = GIV(permSpaceFreeStart);
	GIV(permSpaceFreeStart) += _totalBytes;
	_newOop = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(_chunk, _numSlots, _formatField, _classIndex, 0);
	return _newOop;
}
/*	Allocate an object with numSlots space. If there is room beneath 
	scavengeThreshold allocate in newSpace, otherwise alocate in oldSpace. If 
	there is not room in newSpace 
	and a scavenge is not already scheduled, schedule a scavenge. */
/* SpurMemoryManager>>#allocateSlots:format:classIndex: */
sqInt
allocateSlotsformatclassIndex(sqInt _numSlots, sqInt _formatField, sqInt _classIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	int _hasToScheduleScavenge;
	sqInt _newObj;
	usqInt _numBytes;

	/* begin allocateSlots:format:classIndex:isPinned:isOldSpace: */
	if (_numSlots >= (numSlotsMask())) {
		if ((((usqInt) _numSlots ) >> 56) > 0) {
			return null;
		}
		_numBytes = (BaseHeaderSize + BaseHeaderSize) + (_numSlots * BytesPerOop);
	} else {
		_numBytes = BaseHeaderSize + (((_numSlots < 1)
			 ? 8
			 : _numSlots * BytesPerOop));
	}
	_hasToScheduleScavenge = (GIV(freeStart) + _numBytes) > GIV(scavengeThreshold);
	if (_hasToScheduleScavenge || 0) {
		if (_hasToScheduleScavenge) {
			if (!GIV(needGCFlag)) {
				/* begin scheduleScavenge */
				GIV(needGCFlag) = 1;
				forceInterruptCheck();
				/* end scheduleScavenge */
			}
		}
		{
			return allocateSlotsInOldSpacebytesformatclassIndex(_numSlots, _numBytes, _formatField, _classIndex);
		}
	}
	_newObj = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(GIV(freeStart), _numSlots, _formatField, _classIndex, 0);
	assert((_numBytes % (allocationUnit())) == 0);
	assert((_newObj % (allocationUnit())) == 0);
	GIV(freeStart) += _numBytes;
	return _newObj;
	/* end allocateSlots:format:classIndex:isPinned:isOldSpace: */
}
/*	All objects are a multiple of 8 bytes in length */
/* SpurMemoryManager>>#allocationUnit */
static sqInt
allocationUnit(void)
{
	return 8;
}
/* SpurMemoryManager>>#allPermSpaceObjectsUnmarked */
static sqInt
allPermSpaceObjectsUnmarked(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _currentObject;
	sqInt _followingWord;
	usqInt _followingWordAddress;

	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (((((usqInt) (longAt(_currentObject)) ) >> (markedBitFullShift())) & 1) != 0) {
					GIV(bogon) = _currentObject;
					return 0;
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l2;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_currentObject = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l2:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	return 1;
}
/*	N.B. generateToByDoLimitExpression:negative:on: guards against (unsigned)0 
	- 1 going +ve */
/* SpurMemoryManager>>#allStrongSlotsOfWeaklingAreMarked: */
static sqInt NoDbgRegParms
allStrongSlotsOfWeaklingAreMarked(sqInt _aWeakling)
{
	sqInt _classFormat;
	sqInt _i;
	sqInt _iLimit;
	sqInt _objOop;
	sqInt _referent;

	for (_i = 0, _iLimit = ((assert((formatOf(_aWeakling)) == (weakArrayFormat())), /* begin fixedFieldsOfClass: */ (_objOop = fetchClassOfNonImm(_aWeakling)), /* begin fixedFieldsOfClassFormat: */ (_classFormat = (unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3), _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1) /* end fixedFieldsOfClassFormat: */ /* end fixedFieldsOfClass: */)) - 1; _i <= _iLimit; _i += 1) {
		_referent = unsignedLongAt((_aWeakling + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		if ((_referent & (tagMask())) == 0) {
			if (!((((((usqInt) (longAt(_referent)) ) >> (markedBitFullShift())) & 1) != 0) || (((_referent & (tagMask())) == 0) && (_referent >= 0x20000000000LL)))) {
				return 0;
			}
		}
	}
	return 1;
}
/* SpurMemoryManager>>#allUnscannedEphemeronsAreActive */
static sqInt
allUnscannedEphemeronsAreActive(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _key;
	sqInt _p;

	for (_p = (GIV(unscannedEphemerons)->start); _p <= (((GIV(unscannedEphemerons)->top)) - BytesPerOop); _p += BytesPerOop) {
		{
			assert((isNonImmediate(longAt(_p))) && (isMaybeFiredEphemeron(longAt(_p))));
			/* begin fetchPointer:ofObject: */
			_key = unsignedLongAt(((longAt(_p)) + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofObject: */
		}
		if ((_key & (tagMask())) || ((((((usqInt) (longAt(_key)) ) >> (markedBitFullShift())) & 1) != 0) || (((_key & (tagMask())) == 0) && (_key >= 0x20000000000LL)))) {
			return 0;
		}
	}
	return 1;
}
/* SpurMemoryManager>>#arrayFormat */
sqInt
arrayFormat(void)
{
	return 2;
}
/*	we don't want to inline so we can nest that in an assertion with the 
	return true so the production VM does not generate any code here, while in 
	simulation, the code breaks on the assertion we want to. */
/* SpurMemoryManager>>#assertInnerValidFreeObject: */
static sqInt NoDbgRegParms NeverInline
assertInnerValidFreeObject(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _cameFrom;
	sqInt _chunk;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;
	sqInt _fieldIndex3;
	usqInt _index;
	sqInt _largeChild;
	sqInt _smallChild;
	sqInt _treeNode;

	assert(isFreeOop(_objOop));
	assert(oopisLessThanOrEqualTo(addressAfter(_objOop), (GIV(memoryMap)->oldSpaceEnd)));
	/* begin fetchPointer:ofFreeChunk: */
	_chunk = unsignedLongAt((_objOop + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofFreeChunk: */
	assert((_chunk == 0) || (isFreeOop(_chunk)));
	if (!(isLilliputianSize(bytesInObject(_objOop)))) {
		/* begin fetchPointer:ofFreeChunk: */
		_chunk = unsignedLongAt((_objOop + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofFreeChunk: */
		if (!(_chunk == 0)) {
			assert(isFreeOop(_chunk));
			assert(_objOop == (fetchPointerofFreeChunk(freeChunkPrevIndex(), _chunk)));
		}
		/* begin fetchPointer:ofFreeChunk: */
		_chunk = unsignedLongAt((_objOop + BaseHeaderSize) + (1U << (shiftForWord())));
		/* end fetchPointer:ofFreeChunk: */
		_index = (bytesInObject(_objOop)) / 8;
		if ((_index < 64) && ((1ULL << _index) <= GIV(freeListsMask))) {
			if ((GIV(freeLists)[_index]) == _objOop) {
				assert(_chunk == 0);
			}
		} else {
			/* begin freeTreeNodesDo: */
			_treeNode = GIV(freeLists)[0];
			if (_treeNode == 0) {
				goto l5;
			}
			_cameFrom = -1;
			do {
				assert((bytesInObject(_treeNode)) >= ((numFreeLists()) * (allocationUnit())));
				/* begin fetchPointer:ofFreeChunk: */
				_fieldIndex2 = 3;
				_smallChild = unsignedLongAt((_treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
				/* end fetchPointer:ofFreeChunk: */
				/* begin fetchPointer:ofFreeChunk: */
				_fieldIndex3 = 4;
				_largeChild = unsignedLongAt((_treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex3 ) << (shiftForWord())) ));
				/* end fetchPointer:ofFreeChunk: */
				assert((_smallChild == 0) || (_treeNode == (fetchPointerofFreeChunk(freeChunkParentIndex(), _smallChild))));
				assert((_largeChild == 0) || (_treeNode == (fetchPointerofFreeChunk(freeChunkParentIndex(), _largeChild))));
				if (((_smallChild == 0) && (_largeChild == 0)) || (((_largeChild == 0)
					 ? _cameFrom == _smallChild
					 : _cameFrom == _largeChild))) {
					{
						if (_treeNode == _objOop) {
							assert(_chunk == 0);
						}
					}
					_cameFrom = _treeNode;
					/* begin fetchPointer:ofFreeChunk: */
					_fieldIndex = 2;
					_treeNode = unsignedLongAt((_treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofFreeChunk: */
				} else {
					if ((_smallChild != 0) && (_cameFrom != _smallChild)) {
						_treeNode = _smallChild;
					} else {
						assert(_largeChild != 0);
						_treeNode = _largeChild;
					}
					_cameFrom = -1;
				}
			} while (_treeNode != 0);
			l5:
			;
			/* end freeTreeNodesDo: */
		}
		if (!(_chunk == 0)) {
			assert(isFreeOop(_chunk));
			assert(_objOop == (fetchPointerofFreeChunk(freeChunkNextIndex(), _chunk)));
		}
	}
	if ((bytesInObject(_objOop)) >= (64 * 8)) {
		/* begin fetchPointer:ofFreeChunk: */
		_chunk = unsignedLongAt((_objOop + BaseHeaderSize) + (2U << (shiftForWord())));
		/* end fetchPointer:ofFreeChunk: */
		assert((_chunk == 0) || ((isFreeOop(_chunk)) && (isLargeFreeObject(_chunk))));
		/* begin fetchPointer:ofFreeChunk: */
		_chunk = unsignedLongAt((_objOop + BaseHeaderSize) + (3U << (shiftForWord())));
		/* end fetchPointer:ofFreeChunk: */
		assert((_chunk == 0) || ((isFreeOop(_chunk)) && (isLargeFreeObject(_chunk))));
		/* begin fetchPointer:ofFreeChunk: */
		_chunk = unsignedLongAt((_objOop + BaseHeaderSize) + (4U << (shiftForWord())));
		/* end fetchPointer:ofFreeChunk: */
		assert((_chunk == 0) || ((isFreeOop(_chunk)) && (isLargeFreeObject(_chunk))));
	}
	return 1;
}
/*	Answer the appropriate become effect flags for objOop, or 0 if none. 
	The effect flags determine how much work is done after the become 
	in following forwarding pointers, voiding method caches, etc. */
/* SpurMemoryManager>>#becomeEffectFlagsFor: */
static sqInt NoDbgRegParms
becomeEffectFlagsFor(sqInt _objOop)
{
	sqInt _hash;

	return ((((((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask())) <= 5)
		 ? (((((_hash = (uint32AtPointer(_objOop + 4)) & (identityHashHalfWordMask()))) != 0) && ((classAtIndex(_hash)) == _objOop))
			 ? BecamePointerObjectFlag + BecameActiveClassFlag
			 : BecamePointerObjectFlag)
		 : ((((((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()))
			 ? BecameCompiledMethodFlag
			 : 0));
}
/* SpurMemoryManager>>#become:with: */
sqInt
becomewith(sqInt _array1, sqInt _array2)
{
	return becomewithtwoWaycopyHash(_array1, _array2, 1, 1);
}
/*	All references to each object in array1 are swapped with all references to 
	the corresponding object in array2. That is, all pointers to one object 
	are replaced 
	with with pointers to the other. The arguments must be arrays of the same 
	length.  
	Answers PrimNoErr if the primitive succeeds, otherwise a relevant error 
	code. Implementation: Uses lazy forwarding to defer updating references until 
	message send. */
/* SpurMemoryManager>>#become:with:twoWay:copyHash: */
static sqInt NoDbgRegParms
becomewithtwoWaycopyHash(sqInt _array1, sqInt _array2, sqInt _twoWayFlag, sqInt _copyHashFlag)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classIndex;
	sqInt _contextSize;
	sqInt _ec;
	sqInt _effectsFlags;
	sqInt _fieldOffset;
	sqInt _fmt;
	sqInt _hash;
	sqInt _header;
	sqInt _header2;
	sqInt _i;
	sqInt _i2;
	sqInt _iLimit;
	sqInt _iLimit2;
	sqInt _newObj1;
	sqInt _newObj2;
	sqInt _o1ClassIndex;
	sqInt _o2ClassIndex;
	sqInt _obj1;
	sqInt _obj12;
	sqInt _obj2;
	sqInt _obj22;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _objOop3;
	sqInt _objOop32;
	sqInt _objOop4;
	sqInt _objOop5;
	sqInt _oop1;
	sqInt _oop2;
	sqInt _referent;
	sqInt _referent2;
	sqInt _referent22;
	sqInt _referent3;
	sqInt _referent4;
	int _size;
	sqInt _sp;
	char *_theSP;

	assert(GIV(becomeEffectsFlags) == 0);
	runLeakCheckerFor(GCModeBecome);
	if (!(((_array1 & (tagMask())) == 0) && (((((usqInt) (longAt(_array1)) ) >> (formatShift())) & (formatMask())) == 2))) {
		return PrimErrBadReceiver;
	}
	if (!((((_array2 & (tagMask())) == 0) && (((((usqInt) (longAt(_array2)) ) >> (formatShift())) & (formatMask())) == 2)) && ((numSlotsOf(_array1)) == (numSlotsOf(_array2))))) {
		return PrimErrBadArgument;
	}
	/* begin containsOnlyValidBecomeObjects:and:twoWay:copyHash: */
	/* begin lastPointerOf: */
	_fmt = (((usqInt) (longAt(_array1)) ) >> (formatShift())) & (formatMask());
	assert(_fmt != (forwardedFormat()));
	if (_fmt <= 5) {
		if ((_fmt == (indexablePointersFormat())) && (((longAt(_array1)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
			/* begin fetchStackPointerOf: */
			/* begin fetchPointer:ofObject: */
			_sp = unsignedLongAt((_array1 + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (!(((_sp & 7) == 1))) {
				_contextSize = 0;
				goto l36;
			}
			assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_array1)));
			_contextSize = _sp >> 3;
			l36:
			;
			/* end fetchStackPointerOf: */
			_fieldOffset = (((CtxtTempFrameStart - 1) + _contextSize) * BytesPerOop) + BaseHeaderSize;
			goto l32;
		}
		_fieldOffset = (((numSlotsOf(_array1)) - 1) * BytesPerOop) + BaseHeaderSize;
		goto l32;
	}
	if (_fmt < (firstCompiledMethodFormat())) {
		_fieldOffset = 0;
		goto l32;
	}
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_array1));
	/* begin fetchPointer:ofObject: */
	_header2 = unsignedLongAt((_array1 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header2 & 7) == 1)) {
		_header = _header2;
	} else {
		assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_header = ((((CogMethod *) _header2 ))->methodHeader);
	}
	/* end methodHeaderOf: */
	_fieldOffset = (((((assert(((_header & 7) == 1)), (_header >> 3) & AlternateHeaderNumLiteralsMask)) + LiteralStart) - 1) * BytesPerOop) + BaseHeaderSize;
	l32:
	;
	/* end lastPointerOf: */
	_effectsFlags = (_size = 0);
	while (_fieldOffset >= BaseHeaderSize) {
		_oop1 = longAt(_array1 + _fieldOffset);
		if (((_oop1 & (tagMask())) == 0) && (((long64At(_oop1)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin followForwarded: */
			assert(isUnambiguouslyForwarder(_oop1));
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent4 = unsignedLongAt((_oop1 + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
			while (((_referent4 & (tagMask())) == 0) && (((long64At(_referent4)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent4 = unsignedLongAt((_referent4 + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
			}
			_oop1 = _referent4;
			/* end followForwarded: */
		}
		/* begin ifOopInvalidForBecome:errorCodeInto: */
		if (_oop1 & (tagMask())) {
			{
				_ec = PrimErrInappropriate;
				goto l43;
			}
			goto l39;
		}
		if (((((usqInt) (longAt(_oop1)) ) >> (pinnedBitShift())) & 1) != 0) {
			{
				_ec = PrimErrObjectIsPinned;
				goto l43;
			}
			goto l39;
		}
		if (
#      if IMMUTABILITY
				(/* begin isImmutable: */ ((((usqInt) (longAt(_oop1)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#      else /* IMMUTABILITY */
				0
#      endif /* IMMUTABILITY */
				) {
			{
				_ec = PrimErrNoModification;
				goto l43;
			}
			goto l39;
		}
		l39:
		;
		/* end ifOopInvalidForBecome:errorCodeInto: */
		_effectsFlags = _effectsFlags | (becomeEffectFlagsFor(_oop1));
		_oop2 = longAt(_array2 + _fieldOffset);
		if (((_oop2 & (tagMask())) == 0) && (((long64At(_oop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin followForwarded: */
			assert(isUnambiguouslyForwarder(_oop2));
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent22 = unsignedLongAt((_oop2 + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
			while (((_referent22 & (tagMask())) == 0) && (((long64At(_referent22)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent22 = unsignedLongAt((_referent22 + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
			}
			_oop2 = _referent22;
			/* end followForwarded: */
		}
		if (_twoWayFlag) {
			/* begin ifOopInvalidForBecome:errorCodeInto: */
			if (_oop2 & (tagMask())) {
				{
					_ec = PrimErrInappropriate;
					goto l43;
				}
				goto l42;
			}
			if (((((usqInt) (longAt(_oop2)) ) >> (pinnedBitShift())) & 1) != 0) {
				{
					_ec = PrimErrObjectIsPinned;
					goto l43;
				}
				goto l42;
			}
			if (
#        if IMMUTABILITY
					(/* begin isImmutable: */ ((((usqInt) (longAt(_oop2)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#        else /* IMMUTABILITY */
					0
#        endif /* IMMUTABILITY */
					) {
				{
					_ec = PrimErrNoModification;
					goto l43;
				}
				goto l42;
			}
			l42:
			;
			/* end ifOopInvalidForBecome:errorCodeInto: */
			_size = (_size + (bytesInObject(_oop1))) + (bytesInObject(_oop2));
			_effectsFlags = _effectsFlags | (becomeEffectFlagsFor(_oop2));
		} else {
			if (_copyHashFlag && ((_oop2 & (tagMask())) || (((((usqInt) (longAt(_oop2)) ) >> (immutableBitShift())) & 1) != 0))) {
				_ec = PrimErrInappropriate;
				goto l43;
			}
		}
		_fieldOffset -= BytesPerOop;
	}
	if (_size >= (sizeOfLargestFreeChunk())) {
		_ec = PrimErrNoMemory;
		goto l43;
	}
	GIV(becomeEffectsFlags) = _effectsFlags;
	_ec = 0;
	l43:
	;
	/* end containsOnlyValidBecomeObjects:and:twoWay:copyHash: */
	if (_ec != 0) {
		GIV(becomeEffectsFlags) = 0;
		return _ec;
	}
	/* begin preBecomeAction */
	{
		if (GIV(stackPage) != 0) {
			/* begin writeBackHeadFramePointers */
			assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
			assert(GIV(stackPage) == (mostRecentlyUsedPage()));
			assert(!(isFree(GIV(stackPage))));
			/* begin setHeadFP:andSP:inPage: */
			_theSP = GIV(stackPointer);
			assert(_theSP < GIV(framePointer));
			assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
			assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
			{
				(GIV(stackPage)->headFP = GIV(framePointer));
				(GIV(stackPage)->headSP = _theSP);
			}
			/* end setHeadFP:andSP:inPage: */
			assert(pageListIsWellFormed());
			/* end writeBackHeadFramePointers */
		}
	}
	GIV(gcMode) = GCModeBecome;
	/* end preBecomeAction */
	if (_twoWayFlag) {
		/* begin innerBecomeObjectsIn:and:copyHash: */
		for (_i = 0, _iLimit = (numSlotsOf(_array1)) - 1; _i <= _iLimit; _i += 1) {
			/* begin followField:ofObject: */
			/* begin fetchPointer:ofObject: */
			_objOop3 = unsignedLongAt((_array1 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_objOop3 & (tagMask())) == 0) && (((long64At(_objOop3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				_objOop3 = fixFollowedFieldofObjectwithInitialValue(_i, _array1, _objOop3);
			}
			_obj1 = _objOop3;
			/* end followField:ofObject: */
			/* begin followField:ofObject: */
			/* begin fetchPointer:ofObject: */
			_objOop4 = unsignedLongAt((_array2 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_objOop4 & (tagMask())) == 0) && (((long64At(_objOop4)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				_objOop4 = fixFollowedFieldofObjectwithInitialValue(_i, _array2, _objOop4);
			}
			_obj2 = _objOop4;
			/* end followField:ofObject: */
			if (_obj1 != _obj2) {
				/* begin doBecome:and:copyHash: */
				_o1ClassIndex = (uint32AtPointer(_obj1 + 4)) & (identityHashHalfWordMask());
				if ((_o1ClassIndex != 0) && ((classAtIndex(_o1ClassIndex)) != _obj1)) {
					_o1ClassIndex = 0;
				}
				_o2ClassIndex = (uint32AtPointer(_obj2 + 4)) & (identityHashHalfWordMask());
				if ((_o2ClassIndex != 0) && ((classAtIndex(_o2ClassIndex)) != _obj2)) {
					_o2ClassIndex = 0;
				}
				if ((((_obj1 & (tagMask())) == 0) && (_obj1 >= 0x20000000000LL)) || (((_obj2 & (tagMask())) == 0) && (_obj2 >= 0x20000000000LL))) {
					GIV(becomeEffectsFlags) = GIV(becomeEffectsFlags) | BecamePermanentObject;
				}
				if (((numSlotsOf(_obj1)) == (numSlotsOf(_obj2))) && ((_o1ClassIndex == 0) && (_o2ClassIndex == 0))) {
					inPlaceBecomeandcopyHashFlag(_obj1, _obj2, _copyHashFlag);
					goto l16;
				}
				outOfPlaceBecomeandcopyHashFlag(_obj1, _obj2, _copyHashFlag);
				if (_copyHashFlag) {
					goto l16;
				}
				if (_o1ClassIndex != 0) {
					if (_o2ClassIndex != 0) {
						classAtIndexput(_o1ClassIndex, _obj2);
						classAtIndexput(_o2ClassIndex, _obj1);
					} else {
						/* begin followForwarded: */
						assert(isUnambiguouslyForwarder(_obj1));
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent3 = unsignedLongAt((_obj1 + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
						while (((_referent3 & (tagMask())) == 0) && (((long64At(_referent3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
							/* begin fetchPointer:ofMaybeForwardedObject: */
							_referent3 = unsignedLongAt((_referent3 + BaseHeaderSize) + (0U << (shiftForWord())));
							/* end fetchPointer:ofMaybeForwardedObject: */
						}
						_newObj2 = _referent3;
						/* end followForwarded: */
						assert((rawHashBitsOf(_newObj2)) == 0);
						/* begin setHashBitsOf:to: */
						assert((_o1ClassIndex >= 0) && (_o1ClassIndex <= (identityHashHalfWordMask())));
						uint32AtPointerput(_newObj2 + 4, (((uint32AtPointer(_newObj2 + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + _o1ClassIndex);
						/* end setHashBitsOf:to: */
					}
				}
 else {
					if (_o2ClassIndex != 0) {
						/* begin followForwarded: */
						assert(isUnambiguouslyForwarder(_obj2));
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent2 = unsignedLongAt((_obj2 + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
						while (((_referent2 & (tagMask())) == 0) && (((long64At(_referent2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
							/* begin fetchPointer:ofMaybeForwardedObject: */
							_referent2 = unsignedLongAt((_referent2 + BaseHeaderSize) + (0U << (shiftForWord())));
							/* end fetchPointer:ofMaybeForwardedObject: */
						}
						_newObj1 = _referent2;
						/* end followForwarded: */
						assert((rawHashBitsOf(_newObj1)) == 0);
						/* begin setHashBitsOf:to: */
						assert((_o2ClassIndex >= 0) && (_o2ClassIndex <= (identityHashHalfWordMask())));
						uint32AtPointerput(_newObj1 + 4, (((uint32AtPointer(_newObj1 + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + _o2ClassIndex);
						/* end setHashBitsOf:to: */
					}
				}
				l16:
				;
				/* end doBecome:and:copyHash: */
				/* begin followField:ofObject: */
				/* begin fetchPointer:ofObject: */
				_objOop = unsignedLongAt((_array1 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					_objOop = fixFollowedFieldofObjectwithInitialValue(_i, _array1, _objOop);
				}
				/* end followField:ofObject: */
				/* begin followField:ofObject: */
				/* begin fetchPointer:ofObject: */
				_objOop2 = unsignedLongAt((_array2 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_objOop2 & (tagMask())) == 0) && (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					_objOop2 = fixFollowedFieldofObjectwithInitialValue(_i, _array2, _objOop2);
				}
				/* end followField:ofObject: */
			}
		}
		/* end innerBecomeObjectsIn:and:copyHash: */
	}
 else {
		/* begin innerBecomeObjectsIn:to:copyHash: */
		for (_i2 = 0, _iLimit2 = (numSlotsOf(_array1)) - 1; _i2 <= _iLimit2; _i2 += 1) {
			/* begin followField:ofObject: */
			/* begin fetchPointer:ofObject: */
			_objOop22 = unsignedLongAt((_array1 + BaseHeaderSize) + ((sqInt) (((usqInt) _i2 ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_objOop22 & (tagMask())) == 0) && (((long64At(_objOop22)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				_objOop22 = fixFollowedFieldofObjectwithInitialValue(_i2, _array1, _objOop22);
			}
			_obj12 = _objOop22;
			/* end followField:ofObject: */
			/* begin followField:ofObject: */
			/* begin fetchPointer:ofObject: */
			_objOop32 = unsignedLongAt((_array2 + BaseHeaderSize) + ((sqInt) (((usqInt) _i2 ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_objOop32 & (tagMask())) == 0) && (((long64At(_objOop32)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				_objOop32 = fixFollowedFieldofObjectwithInitialValue(_i2, _array2, _objOop32);
			}
			_obj22 = _objOop32;
			/* end followField:ofObject: */
			if (_obj12 != _obj22) {
				/* begin doBecome:to:copyHash: */
				/* begin forward:to: */
				/* begin set:classIndexTo:formatTo: */
				_classIndex = isForwardedObjectClassIndexPun();
				assert((_classIndex >= 0) && (_classIndex <= (classIndexMask())));
				assert((7 >= 0) && (7 <= (formatMask())));
				longAtput(_obj12, ((longAt(_obj12)) & (~((usqIntptr_t) (((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) + (classIndexMask())) ))) + (_classIndex + (7U << (formatShift()))));
				/* end set:classIndexTo:formatTo: */
				
#        if IMMUTABILITY
				{
					/* begin setIsImmutableOf:to: */
					longAtput(_obj12, (longAt(_obj12)) & (~((usqIntptr_t) (1U << (immutableBitShift())) )));
					/* end setIsImmutableOf:to: */
				}
#        endif /* IMMUTABILITY */
				/* begin storePointer:ofForwarder:withValue: */
				assert(isForwarded(_obj12));
				assert(!(isOopForwarded(_obj22)));
				if ((_obj12 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask))) {
					if (((_obj22 & (tagMask())) == 0) && (((_obj22 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_obj22 >= ((GIV(memoryMap)->newSpaceStart))))) {
						/* begin possibleOldObjectStoreInto: */
						if (!(((((usqInt) (long64At(_obj12)) ) >> (rememberedBitShift())) & 1) != 0)) {
							remember(GIV(fromOldSpaceRememberedSet), _obj12);
						}
						/* end possibleOldObjectStoreInto: */
					}
				}
				/* begin possiblePermObjectStoreInto:value: */
				if (((((usqInt) (long64At(_obj12)) ) >> (rememberedBitShift())) & 1) != 0) {
					goto l26;
				}
				if (_obj22 & (tagMask())) {
					goto l26;
				}
				if (!(_obj12 >= 0x20000000000LL)) {
					goto l26;
				}
				if (_obj22 >= 0x20000000000LL) {
					goto l26;
				}
				if ((_obj22 >= GIV(nilObj)) && (_obj22 <= GIV(trueObj))) {
					goto l26;
				}
				if (!(_obj22 >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l26;
				}
				remember(getFromPermToNewSpaceRememberedSet(), _obj12);
				l26:
				;
				/* end possiblePermObjectStoreInto:value: */
				unsignedLongAtput((_obj12 + BaseHeaderSize) + (0U << (shiftForWord())), _obj22);
				/* end storePointer:ofForwarder:withValue: */
				if ((byteAt(_obj12 + 7)) == 0) {
					byteAtput(_obj12 + 7, 1);
				}
				/* end forward:to: */
				if (_copyHashFlag) {
					/* begin setHashBitsOf:to: */
					_hash = (uint32AtPointer(_obj12 + 4)) & (identityHashHalfWordMask());
					assert((_hash >= 0) && (_hash <= (identityHashHalfWordMask())));
					uint32AtPointerput(_obj22 + 4, (((uint32AtPointer(_obj22 + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + _hash);
					/* end setHashBitsOf:to: */
				}
				assert(!(isOopForwarded(_obj22)));
				if (_obj12 >= 0x20000000000LL) {
					GIV(becomeEffectsFlags) = GIV(becomeEffectsFlags) | BecamePermanentObject;
				}
				if (((_obj12 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask))) && (((_obj22 & (tagMask())) == 0) && (((_obj22 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_obj22 >= ((GIV(memoryMap)->newSpaceStart)))))) {
					GIV(becomeEffectsFlags) = GIV(becomeEffectsFlags) | OldBecameNewFlag;
				}
				/* end doBecome:to:copyHash: */
				/* begin followField:ofObject: */
				/* begin fetchPointer:ofObject: */
				_objOop5 = unsignedLongAt((_array1 + BaseHeaderSize) + ((sqInt) (((usqInt) _i2 ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_objOop5 & (tagMask())) == 0) && (((long64At(_objOop5)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					_objOop5 = fixFollowedFieldofObjectwithInitialValue(_i2, _array1, _objOop5);
				}
				/* end followField:ofObject: */
				assert(!(isOopForwarded(_obj22)));
			}
		}
		/* end innerBecomeObjectsIn:to:copyHash: */
	}
	/* begin followSpecialObjectsOop */
	if (((long64At(GIV(specialObjectsOop))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(GIV(specialObjectsOop)));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		GIV(specialObjectsOop) = _referent;
		/* end followForwarded: */
	}
	followForwardedObjectFieldstoDepth(GIV(specialObjectsOop), 0);
	/* end followSpecialObjectsOop */
	postBecomeAction(GIV(becomeEffectsFlags));
	postBecomeScanClassTable(GIV(becomeEffectsFlags));
	GIV(becomeEffectsFlags) = 0;
	assert(validClassTableHashes());
	runLeakCheckerFor(GCModeBecome);
	return PrimNoErr;
}
/*	If this object is old, mark it as a root (because a new object 
	may be stored into it). */
/* SpurMemoryManager>>#beRootIfOld: */
void
beRootIfOld(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if ((_oop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask))) {
		/* begin possibleOldObjectStoreInto: */
		if (!(((((usqInt) (long64At(_oop)) ) >> (rememberedBitShift())) & 1) != 0)) {
			remember(GIV(fromOldSpaceRememberedSet), _oop);
		}
		/* end possibleOldObjectStoreInto: */
	}
}
/* SpurMemoryManager>>#bitsSetInFreeSpaceMaskForAllFreeLists */
static sqInt
bitsSetInFreeSpaceMaskForAllFreeLists(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _iLimit;

	for (_i = 0, _iLimit = 64 - 1; _i <= _iLimit; _i += 1) {
		if (((GIV(freeLists)[_i]) != 0) && (((1ULL << _i) & GIV(freeListsMask)) == 0)) {
			return 0;
		}
	}
	return 1;
}
/* SpurMemoryManager>>#boxedFloatObjectOf: */
usqInt
boxedFloatObjectOf(double _aFloat)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _newFloatObj;
	usqInt _newObj;
	usqInt _numBytes;
	sqInt _numSlots;
	sqInt _objFormat;

	/* begin eeInstantiateSmallClassIndex:format:numSlots: */
	_objFormat = firstLongFormat();
	_numSlots = (sizeof(double)) / BytesPerOop;
	assert((_numSlots >= 0) && ((classAtIndex(ClassFloatCompactIndex)) != GIV(nilObj)));
	assert((((_objFormat < (firstByteFormat()))
		 ? _objFormat
		 : _objFormat & (byteFormatMask()))) == (instSpecOfClass(classAtIndex(ClassFloatCompactIndex))));
	/* begin allocateSmallNewSpaceSlots:format:classIndex: */
	assert(_numSlots < (numSlotsMask()));
	_newObj = GIV(freeStart);
	_numBytes = BaseHeaderSize + (((_numSlots < 1)
		 ? 8
		 : _numSlots * BytesPerOop));
	assert((_numBytes % (allocationUnit())) == 0);
	assert((_newObj % (allocationUnit())) == 0);
	if ((GIV(freeStart) + _numBytes) > GIV(scavengeThreshold)) {
		if (!GIV(needGCFlag)) {
			/* begin scheduleScavenge */
			GIV(needGCFlag) = 1;
			forceInterruptCheck();
			/* end scheduleScavenge */
		}
		if ((GIV(freeStart) + _numBytes) > (((eden()).limit))) {
			error("no room in eden for allocateSmallNewSpaceSlots:format:classIndex:");
			_newFloatObj = 0;
			goto l2;
		}
	}
	long64Atput(_newObj, ((((usqLong) _numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) _objFormat ) << (formatShift())) )) + ClassFloatCompactIndex);
	GIV(freeStart) += _numBytes;
	_newFloatObj = _newObj;
	/* end allocateSmallNewSpaceSlots:format:classIndex: */
	l2:
	;
	/* end eeInstantiateSmallClassIndex:format:numSlots: */
	storeFloatAtfrom(_newFloatObj + BaseHeaderSize, _aFloat);
	return _newFloatObj;
}
/* SpurMemoryManager>>#bridgeSize */
static sqInt
bridgeSize(void)
{
	return 2 * BaseHeaderSize;
}
/* SpurMemoryManager>>#byteFormatMask */
static sqInt
byteFormatMask(void)
{
	return 24;
}
/* SpurMemoryManager>>#byteSizeOf: */
sqInt
byteSizeOf(sqInt _oop)
{
	sqInt _fmt;
	usqInt _numBytes;
	usqInt _numSlots;

	if (_oop & (tagMask())) {
		return 0;
	}
	/* begin numBytesOf: */
	_fmt = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_oop)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_oop + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_oop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt >= (firstByteFormat())) {
		return _numBytes - (_fmt & 7);
	}
	if (_fmt <= (sixtyFourBitIndexableFormat())) {
		return _numBytes;
	}
	if (_fmt >= (firstShortFormat())) {
		return _numBytes - ((sqInt) (((usqInt) (_fmt & 3) ) << 1) );
	}
	return _numBytes - ((sqInt) (((usqInt) (_fmt & 1) ) << 2) );
	/* end numBytesOf: */
}
/*	Attempt to change the class of the receiver to the argument given that the 
	format of the receiver matches the format of the argument. If successful, 
	answer 0, otherwise answer an error code indicating the reason for 
	failure.  
	Fail if the format of the receiver is incompatible with the format of the 
	argument, or if the argument is a fixed class and the receiver's size 
	differs from the size 
	that an instance of the argument should have. */
/* SpurMemoryManager>>#changeClassOf:to: */
static sqInt NoDbgRegParms
changeClassOfto(sqInt _rcvr, sqInt _argClass)
{
	sqInt _classFormat;
	sqInt _classIndex;
	sqInt _err;
	sqInt _fixedFields;
	sqInt _fmt;
	sqInt _hash;
	sqInt _instBytes;
	sqInt _instFormat;
	usqInt _instSlots;
	sqInt _newFormat;
	usqInt _numBytes;
	usqInt _numSlots;

	_instBytes = 0;
	_instSlots = 0;
	if (
#    if IMMUTABILITY
			(/* begin isImmutable: */ ((((usqInt) (longAt(_rcvr)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#    else /* IMMUTABILITY */
			0
#    endif /* IMMUTABILITY */
			) {
		return PrimErrNoModification;
	}
	_classFormat = (unsignedLongAt((_argClass + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	_fixedFields = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	_classFormat = (((usqInt) _classFormat ) >> (fixedFieldsFieldWidth())) & (formatMask());
	_instFormat = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (((assert(addressCouldBeClassObj(_argClass)), (_classIndex = ((((_hash = (uint32AtPointer(_argClass + 4)) & (identityHashHalfWordMask()))) != 0)
		 ? _hash
		 : ((objCouldBeClassObj(_argClass))
			 ? ((((_err = enterIntoClassTable(_argClass))) != 0)
				 ? -_err
				 : (/* begin rawHashBitsOf: */ (uint32AtPointer(_argClass + 4)) & (identityHashHalfWordMask()) /* end rawHashBitsOf: */))
			 : -PrimErrBadReceiver))))) < 0) {
		return -_classIndex;
	}
	if (_classFormat <= 5) {
		if (_instFormat > 5) {
			return PrimErrInappropriate;
		}
		if ((((_instSlots = numSlotsOf(_rcvr))) < _fixedFields) || ((_instSlots > _fixedFields) && ((_classFormat <= 1) || (_classFormat == 5)))) {
			return PrimErrBadReceiver;
		}
		if ((_instFormat == (indexablePointersFormat())) && (((longAt(_rcvr)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
			makeContextSnapshotSafe(_rcvr);
		}
		_newFormat = _classFormat;
	} else {
		if (_classFormat != (classFormatForInstanceFormat(_classFormat))) {
			return PrimErrBadArgument;
		}
		/* begin numBytesOf: */
		_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
		/* begin numSlotsOf: */
		assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
		_numSlots = byteAt(_rcvr + 7);
		_numBytes = ((_numSlots == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots);
		/* end numSlotsOf: */
		_numBytes = _numBytes << (shiftForWord());
		if (_fmt >= (firstByteFormat())) {
			_instBytes = _numBytes - (_fmt & 7);
			goto l5;
		}
		if (_fmt <= (sixtyFourBitIndexableFormat())) {
			_instBytes = _numBytes;
			goto l5;
		}
		if (_fmt >= (firstShortFormat())) {
			_instBytes = _numBytes - ((sqInt) (((usqInt) (_fmt & 3) ) << 1) );
			goto l5;
		}
		_instBytes = _numBytes - ((sqInt) (((usqInt) (_fmt & 1) ) << 2) );
		l5:
		;
		/* end numBytesOf: */
		switch (_classFormat) {
			case sixtyFourBitIndexableFormat():
			{
				if (_instBytes & 7) {
					return PrimErrBadReceiver;
				}
				_newFormat = _classFormat;
			}
			break;
			case firstLongFormat():
			{
				if (_instBytes & 3) {
					return PrimErrBadReceiver;
				}
				_newFormat = _classFormat + (paddingForFormatInstBytesshiftForElement(_instBytes, 2));
			}
			break;
			case firstShortFormat():
			{
				if (_instBytes & 1) {
					return PrimErrBadReceiver;
				}
				_newFormat = _classFormat + (paddingForFormatInstBytesshiftForElement(_instBytes, 1));
			}
			break;
			case firstByteFormat():
			{
				_newFormat = _classFormat + (paddingForFormatInstBytesshiftForElement(_instBytes, 0));
			}
			break;
			case firstCompiledMethodFormat():
			{
				if (_classFormat != (firstCompiledMethodFormat())) {
					return PrimErrInappropriate;
				}
				_newFormat = _instFormat;
			}
			break;
			default:
			{
				return PrimErrInappropriate;
			}
		}
	}
	/* begin set:classIndexTo:formatTo: */
	assert((_classIndex >= 0) && (_classIndex <= (classIndexMask())));
	assert((_newFormat >= 0) && (_newFormat <= (formatMask())));
	longAtput(_rcvr, ((longAt(_rcvr)) & (~((usqIntptr_t) (((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) + (classIndexMask())) ))) + (_classIndex + ((sqInt) (((usqInt) _newFormat ) << (formatShift())) )));
	/* end set:classIndexTo:formatTo: */
	assert((numBytesOf(_rcvr)) == (((_classFormat <= (lastPointerFormat()))
		 ? _instSlots * BytesPerOop
		 : _instBytes)));
	return 0;
}
/* SpurMemoryManager>>#characterObjectOf: */
sqInt
characterObjectOf(sqInt _characterCode)
{
	return ((sqInt) (((usqInt) _characterCode ) << (numTagBits())) ) + (characterTag());
}
/*	Immediate characters are unsigned */
/* SpurMemoryManager>>#characterValueOf: */
usqInt
characterValueOf(sqInt _oop)
{
	return ((usqInt) ((usqInt) _oop ) ) >> (numTagBits());
}
/* SpurMemoryManager>>#cheapAddressCouldBeInHeap: */
static sqInt NoDbgRegParms
cheapAddressCouldBeInHeap(sqInt _address)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((_address & (BytesPerWord - 1)) == 0) && (((oopisLessThan(_address, (GIV(memoryMap)->newSpaceEnd))) && (oopisGreaterThanOrEqualTo(_address, (GIV(memoryMap)->newSpaceStart)))) || ((oopisGreaterThanOrEqualToandLessThan(_address, (GIV(memoryMap)->oldSpaceStart), (GIV(memoryMap)->oldSpaceEnd))) || (oopisGreaterThanOrEqualToandLessThan(_address, (GIV(memoryMap)->permSpaceStart), (GIV(memoryMap)->permSpaceEnd)))));
}
/*	Assumes zero-based array indexing. */
/* SpurMemoryManager>>#checkedLongAt: */
sqInt
checkedLongAt(sqInt _byteAddress)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (!(isInMemory(_byteAddress))) {
		warning("checkedLongAt bad address");
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	}
	return longAt(_byteAddress);
}
/*	Perform an integrity/leak check using the heapMap. Assume 
	clearLeakMapAndMapAccessibleFreeSpace has set a bit at each free chunk's 
	header. Scan all objects in the heap checking that no pointer points 
	to a free chunk and that all free chunks that refer to others refer to 
	marked chunks. Answer if all checks pass. */
/* SpurMemoryManager>>#checkHeapFreeSpaceIntegrity */
static sqInt
checkHeapFreeSpaceIntegrity(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _fi;
	sqInt _fieldOop;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	sqInt _i;
	sqInt _iLimit;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop;
	sqInt _objOop2;
	int _ok;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;
	usqInt _total;

	_ok = 1;
	_total = 0;
	for (_i = 0, _iLimit = 64 - 1; _i <= _iLimit; _i += 1) {
		if ((GIV(freeLists)[_i]) != 0) {
			if ((heapMapAtWord(pointerForOop(GIV(freeLists)[_i]))) == 0) {
				{
					print("leak in free list ");
					printNum(_i);
					print(" to non-free ");
					printHex(GIV(freeLists)[_i]);
					/* begin cr */
					print("\n");
					/* end cr */
				}
				_ok = 0;
			}
		}
	}
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop, _limit)) {
		{
			if (((longAt(_objOop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
				{
					print("young object ");
					printHex(_objOop);
					print(" is free");
					/* begin cr */
					print("\n");
					/* end cr */
				}
				_ok = 0;
			} else {
				for (_fi = 0, _iLimit = (numPointerSlotsOf(_objOop)) - 1; _fi <= _iLimit; _fi += 1) {
					_fieldOop = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _fi ) << (shiftForWord())) ));
					if ((_fieldOop & (tagMask())) == 0) {
						if ((heapMapAtWord(pointerForOop(_fieldOop))) != 0) {
							{
								print("object leak in ");
								printHex(_objOop);
								print(" @ ");
								printNum(_fi);
								print(" = ");
								printHex(_fieldOop);
								print(" is free");
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_ok = 0;
						}
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop = _limit;
			goto l7;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop, GIV(freeStart))) {
		{
			if (((longAt(_objOop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
				{
					print("young object ");
					printHex(_objOop);
					print(" is free");
					/* begin cr */
					print("\n");
					/* end cr */
				}
				_ok = 0;
			} else {
				for (_fi = 0, _iLimit = (numPointerSlotsOf(_objOop)) - 1; _fi <= _iLimit; _fi += 1) {
					_fieldOop = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _fi ) << (shiftForWord())) ));
					if ((_fieldOop & (tagMask())) == 0) {
						if ((heapMapAtWord(pointerForOop(_fieldOop))) != 0) {
							{
								print("object leak in ");
								printHex(_objOop);
								print(" @ ");
								printNum(_fi);
								print(" = ");
								printHex(_fieldOop);
								print(" is free");
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_ok = 0;
						}
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop = GIV(freeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* begin allOldSpaceEntitiesDo: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop2 = GIV(nilObj);
	while (1) {
		assert((_objOop2 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop2, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop2)) != 0);
		{
			if (((longAt(_objOop2)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
				if ((heapMapAtWord(pointerForOop(_objOop2))) == 0) {
					{
						print("leak in free chunk ");
						printHex(_objOop2);
						print(" is unmapped?! ");
						/* begin cr */
						print("\n");
						/* end cr */
					}
					_ok = 0;
				}
				/* begin fetchPointer:ofFreeChunk: */
				_fieldOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofFreeChunk: */
				if ((_fieldOop != 0) && ((heapMapAtWord(pointerForOop(_fieldOop))) == 0)) {
					{
						print("leak in free chunk ");
						printHex(_objOop2);
						print(" @ 0 = ");
						printHex(_fieldOop);
						print(" is unmapped");
						/* begin cr */
						print("\n");
						/* end cr */
					}
					_ok = 0;
				}
				if (!(isLilliputianSize(bytesInObject(_objOop2)))) {
					/* begin fetchPointer:ofFreeChunk: */
					_fieldOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + (1U << (shiftForWord())));
					/* end fetchPointer:ofFreeChunk: */
					if ((_fieldOop != 0) && ((heapMapAtWord(pointerForOop(_fieldOop))) == 0)) {
						{
							print("leak in free chunk ");
							printHex(_objOop2);
							print(" @ 0 = ");
							printHex(_fieldOop);
							print(" is unmapped");
							/* begin cr */
							print("\n");
							/* end cr */
						}
						_ok = 0;
					}
				}
				if ((bytesInObject(_objOop2)) >= (64 * 8)) {
					for (_fi = 2, _iLimit = 4; _fi <= _iLimit; _fi += 1) {
						_fieldOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _fi ) << (shiftForWord())) ));
						if ((_fieldOop != 0) && ((heapMapAtWord(pointerForOop(_fieldOop))) == 0)) {
							{
								print("leak in free chunk ");
								printHex(_objOop2);
								print(" @ ");
								printNum(_fi);
								print(" = ");
								printHex(_fieldOop);
								print(" is unmapped");
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_ok = 0;
						}
					}
				}
				_total += bytesInObject(_objOop2);
			} else {
				for (_fi = 0, _iLimit = (numPointerSlotsOf(_objOop2)) - 1; _fi <= _iLimit; _fi += 1) {
					if (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
						assert(_fi == 0);
						_fieldOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _fi ) << (shiftForWord())) ));
					} else {
						_fieldOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _fi ) << (shiftForWord())) ));
					}
					if ((_fieldOop & (tagMask())) == 0) {
						if ((heapMapAtWord(pointerForOop(_fieldOop))) != 0) {
							{
								print("object leak in ");
								printHex(_objOop2);
								print(" @ ");
								printNum(_fi);
								print(" = ");
								printHex(_fieldOop);
								print(" is free");
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_ok = 0;
						}
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop2;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress3 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, _limit2)) {
			_objOop2 = _limit2;
			goto l19;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_objOop2 = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l19:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceEntitiesDo: */
	if (_total != GIV(totalFreeOldSpace)) {
		{
			print("incorrect totalFreeOldSpace; expected ");
			printNum(GIV(totalFreeOldSpace));
			print(" found ");
			printNum(_total);
			/* begin cr */
			print("\n");
			/* end cr */
		}
		_ok = 0;
	}
	return _ok;
}
/*	Perform an integrity/leak check using the heapMap. Assume 
	clearLeakMapAndMapAccessibleObjects has set a bit at each (non-free) 
	object's header. Scan all objects in the heap checking that every 
	pointer points to a header. Scan the rememberedSet, remapBuffer and 
	extraRootTable checking 
	that every entry is a pointer to a header. Check that the number of roots 
	is correct and that all 
	rememberedSet entries have their isRemembered: flag set. Answer if all 
	checks pass. */
/* SpurMemoryManager>>#checkHeapIntegrity:classIndicesShouldBeValid: */
static sqInt NoDbgRegParms
checkHeapIntegrityclassIndicesShouldBeValid(sqInt _excludeUnmarkedObjs, sqInt _classIndicesShouldBeValid)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _classIndex;
	sqInt _classIndex2;
	sqInt _classIndex3;
	sqInt _classIndex4;
	sqInt _classOop;
	sqInt _classTablePage;
	sqInt _classTablePage2;
	sqInt _classTablePage3;
	int _containsYoung;
	sqInt _fi;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;
	sqInt _fieldIndex22;
	sqInt _fieldIndex23;
	sqInt _fieldIndex3;
	sqInt _fieldIndex4;
	sqInt _fieldOop;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	sqInt _i;
	sqInt _i2;
	sqInt _i3;
	sqInt _iLimit;
	usqInt _limit;
	sqInt _limit2;
	sqInt _numOnThisPage;
	int _numRememberedObjectsInHeap;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _obj;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _objStackPage;
	int _ok;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;
	sqInt _ri;

	_ok = 1;
	_numRememberedObjectsInHeap = 0;
	for (_i = 0, _iLimit = 64 - 1; _i <= _iLimit; _i += 1) {
		if ((GIV(freeLists)[_i]) != 0) {
			if ((heapMapAtWord(pointerForOop(GIV(freeLists)[_i]))) != 0) {
				{
					print("leak in free list ");
					printNum(_i);
					print(" to non-free ");
					printHex(GIV(freeLists)[_i]);
					/* begin cr */
					print("\n");
					/* end cr */
				}
				_ok = 0;
			}
		}
	}
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop, _limit)) {
		{
			if (((longAt(_objOop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
				{
					print("young object ");
					printHex(_objOop);
					print(" is free");
					/* begin cr */
					print("\n");
					/* end cr */
				}
				_ok = 0;
			} else {
				if (!((!(((((usqInt) (longAt(_objOop)) ) >> (markedBitFullShift())) & 1) != 0)) && _excludeUnmarkedObjs)) {
					if (((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0) {
						{
							print("young object ");
							printHex(_objOop);
							print(" is remembered");
							/* begin cr */
							print("\n");
							/* end cr */
						}
						_ok = 0;
					}
				}
				if (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					_fieldOop = unsignedLongAt((_objOop + BaseHeaderSize) + (0U << (shiftForWord())));
					if ((heapMapAtWord(pointerForOop(_fieldOop))) == 0) {
						{
							print("object leak in forwarder ");
							printHex(_objOop);
							print(" to unmapped ");
							printHex(_fieldOop);
							/* begin cr */
							print("\n");
							/* end cr */
						}
						_ok = 0;
					}
				} else {
					/* begin classOrNilAtIndex: */
					_classIndex2 = (_classIndex = (longAt(_objOop)) & (classIndexMask()));
					assert((_classIndex2 <= (tagMask())) || (_classIndex2 >= (arrayClassIndexPun())));
					/* begin fetchPointer:ofObject: */
					_fieldIndex = ((usqInt) _classIndex2 ) >> (classTableMajorIndexShift());
					_classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (_classTablePage == GIV(nilObj)) {
						_classOop = GIV(nilObj);
						goto l50;
					}
					/* begin fetchPointer:ofObject: */
					_fieldIndex2 = _classIndex2 & ((1U << (classTableMajorIndexShift())) - 1);
					_classOop = unsignedLongAt((_classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					l50:
					;
					/* end classOrNilAtIndex: */
					if (_classIndicesShouldBeValid && ((_classOop == GIV(nilObj)) && (!(((longAt(_objOop)) & (classIndexMask())) <= (lastClassIndexPun()))))) {
						{
							print("object leak in ");
							printHex(_objOop);
							print(" invalid class index ");
							printHex(_classIndex);
							print(" -> ");
							print(((_classOop == null)
								 ? "nil"
								 : "nilObj"));
							/* begin cr */
							print("\n");
							/* end cr */
						}
						_ok = 0;
					}
					for (_fi = 0, _iLimit = (numPointerSlotsOf(_objOop)) - 1; _fi <= _iLimit; _fi += 1) {
						_fieldOop = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _fi ) << (shiftForWord())) ));
						if ((_fieldOop & (tagMask())) == 0) {
							if ((heapMapAtWord(pointerForOop(_fieldOop))) == 0) {
								{
									print("object leak in ");
									printHex(_objOop);
									print(" @ ");
									printNum(_fi);
									print(" = ");
									printHex(_fieldOop);
									/* begin cr */
									print("\n");
									/* end cr */
								}
								_ok = 0;
							}
						}
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop = _limit;
			goto l7;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop, GIV(freeStart))) {
		{
			if (((longAt(_objOop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
				{
					print("young object ");
					printHex(_objOop);
					print(" is free");
					/* begin cr */
					print("\n");
					/* end cr */
				}
				_ok = 0;
			} else {
				if (!((!(((((usqInt) (longAt(_objOop)) ) >> (markedBitFullShift())) & 1) != 0)) && _excludeUnmarkedObjs)) {
					if (((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0) {
						{
							print("young object ");
							printHex(_objOop);
							print(" is remembered");
							/* begin cr */
							print("\n");
							/* end cr */
						}
						_ok = 0;
					}
				}
				if (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					_fieldOop = unsignedLongAt((_objOop + BaseHeaderSize) + (0U << (shiftForWord())));
					if ((heapMapAtWord(pointerForOop(_fieldOop))) == 0) {
						{
							print("object leak in forwarder ");
							printHex(_objOop);
							print(" to unmapped ");
							printHex(_fieldOop);
							/* begin cr */
							print("\n");
							/* end cr */
						}
						_ok = 0;
					}
				} else {
					/* begin classOrNilAtIndex: */
					_classIndex3 = (_classIndex = (longAt(_objOop)) & (classIndexMask()));
					assert((_classIndex3 <= (tagMask())) || (_classIndex3 >= (arrayClassIndexPun())));
					/* begin fetchPointer:ofObject: */
					_fieldIndex3 = ((usqInt) _classIndex3 ) >> (classTableMajorIndexShift());
					_classTablePage2 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex3 ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (_classTablePage2 == GIV(nilObj)) {
						_classOop = GIV(nilObj);
						goto l51;
					}
					/* begin fetchPointer:ofObject: */
					_fieldIndex22 = _classIndex3 & ((1U << (classTableMajorIndexShift())) - 1);
					_classOop = unsignedLongAt((_classTablePage2 + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex22 ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					l51:
					;
					/* end classOrNilAtIndex: */
					if (_classIndicesShouldBeValid && ((_classOop == GIV(nilObj)) && (!(((longAt(_objOop)) & (classIndexMask())) <= (lastClassIndexPun()))))) {
						{
							print("object leak in ");
							printHex(_objOop);
							print(" invalid class index ");
							printHex(_classIndex);
							print(" -> ");
							print(((_classOop == null)
								 ? "nil"
								 : "nilObj"));
							/* begin cr */
							print("\n");
							/* end cr */
						}
						_ok = 0;
					}
					for (_fi = 0, _iLimit = (numPointerSlotsOf(_objOop)) - 1; _fi <= _iLimit; _fi += 1) {
						_fieldOop = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _fi ) << (shiftForWord())) ));
						if ((_fieldOop & (tagMask())) == 0) {
							if ((heapMapAtWord(pointerForOop(_fieldOop))) == 0) {
								{
									print("object leak in ");
									printHex(_objOop);
									print(" @ ");
									printNum(_fi);
									print(" = ");
									printHex(_fieldOop);
									/* begin cr */
									print("\n");
									/* end cr */
								}
								_ok = 0;
							}
						}
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop = GIV(freeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* begin allOldSpaceEntitiesDo: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop2 = GIV(nilObj);
	while (1) {
		assert((_objOop2 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop2, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop2)) != 0);
		{
			if (((longAt(_objOop2)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
				if ((heapMapAtWord(pointerForOop(_objOop2))) != 0) {
					{
						print("leak in free chunk ");
						printHex(_objOop2);
						print(" is mapped?! ");
						/* begin cr */
						print("\n");
						/* end cr */
					}
					_ok = 0;
				}
				/* begin fetchPointer:ofFreeChunk: */
				_fieldOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofFreeChunk: */
				if ((_fieldOop != 0) && ((heapMapAtWord(pointerForOop(_fieldOop))) != 0)) {
					{
						print("leak in free chunk ");
						printHex(_objOop2);
						print(" @ 0 = ");
						printHex(_fieldOop);
						print(" is mapped");
						/* begin cr */
						print("\n");
						/* end cr */
					}
					_ok = 0;
				}
				if (!(isLilliputianSize(bytesInObject(_objOop2)))) {
					/* begin fetchPointer:ofFreeChunk: */
					_fieldOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + (1U << (shiftForWord())));
					/* end fetchPointer:ofFreeChunk: */
					if ((_fieldOop != 0) && ((heapMapAtWord(pointerForOop(_fieldOop))) != 0)) {
						{
							print("leak in free chunk ");
							printHex(_objOop2);
							print(" @ 1 = ");
							printHex(_fieldOop);
							print(" is mapped");
							/* begin cr */
							print("\n");
							/* end cr */
						}
						_ok = 0;
					}
				}
				if ((bytesInObject(_objOop2)) >= (64 * 8)) {
					for (_fi = 2, _iLimit = 4; _fi <= _iLimit; _fi += 1) {
						_fieldOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _fi ) << (shiftForWord())) ));
						if ((_fieldOop != 0) && ((heapMapAtWord(pointerForOop(_fieldOop))) != 0)) {
							{
								print("leak in free chunk ");
								printHex(_objOop2);
								print(" @ ");
								printNum(_fi);
								print(" = ");
								printHex(_fieldOop);
								print(" is mapped");
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_ok = 0;
						}
					}
				}
			} else {
				if (!(_excludeUnmarkedObjs && (!(((((usqInt) (longAt(_objOop2)) ) >> (markedBitFullShift())) & 1) != 0)))) {
					_containsYoung = 0;
					if (((((usqInt) (long64At(_objOop2)) ) >> (rememberedBitShift())) & 1) != 0) {
						_numRememberedObjectsInHeap += 1;
						if (!(isInRememberedSet(GIV(fromOldSpaceRememberedSet), _objOop2))) {
							{
								print("remembered object ");
								printHex(_objOop2);
								print(" is not in remembered table");
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_ok = 0;
						}
					}
					if (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
						_fieldOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + (0U << (shiftForWord())));
						if ((heapMapAtWord(pointerForOop(_fieldOop))) == 0) {
							{
								print("object leak in forwarder ");
								printHex(_objOop2);
								print(" to unmapped ");
								printHex(_fieldOop);
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_ok = 0;
						}
						if (((_fieldOop & (tagMask())) == 0) && ((assert(isNonImmediate(_fieldOop)), (oopisLessThan(_fieldOop, (GIV(memoryMap)->newSpaceEnd))) && (oopisGreaterThanOrEqualTo(_fieldOop, (GIV(memoryMap)->newSpaceStart)))))) {
							_containsYoung = 1;
						}
					} else {
						/* begin classOrNilAtIndex: */
						_classIndex4 = (_classIndex = (longAt(_objOop2)) & (classIndexMask()));
						assert((_classIndex4 <= (tagMask())) || (_classIndex4 >= (arrayClassIndexPun())));
						/* begin fetchPointer:ofObject: */
						_fieldIndex4 = ((usqInt) _classIndex4 ) >> (classTableMajorIndexShift());
						_classTablePage3 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex4 ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						if (_classTablePage3 == GIV(nilObj)) {
							_classOop = GIV(nilObj);
							goto l52;
						}
						/* begin fetchPointer:ofObject: */
						_fieldIndex23 = _classIndex4 & ((1U << (classTableMajorIndexShift())) - 1);
						_classOop = unsignedLongAt((_classTablePage3 + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex23 ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						l52:
						;
						/* end classOrNilAtIndex: */
						if (_classIndicesShouldBeValid && ((_classOop == GIV(nilObj)) && (_classIndex > (lastClassIndexPun())))) {
							{
								print("object leak in ");
								printHex(_objOop2);
								print(" invalid class index ");
								printHex(_classIndex);
								print(" -> ");
								print(((_classOop == null)
									 ? "nil"
									 : "nilObj"));
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_ok = 0;
						}
						for (_fi = 0, _iLimit = (numPointerSlotsOf(_objOop2)) - 1; _fi <= _iLimit; _fi += 1) {
							_fieldOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _fi ) << (shiftForWord())) ));
							if ((_fieldOop & (tagMask())) == 0) {
								if ((heapMapAtWord(pointerForOop(_fieldOop))) == 0) {
									{
										print("object leak in ");
										printHex(_objOop2);
										print(" @ ");
										printNum(_fi);
										print(" = ");
										printHex(_fieldOop);
										/* begin cr */
										print("\n");
										/* end cr */
									}
									_ok = 0;
								}
								if (((_fieldOop & (tagMask())) == 0) && ((assert(isNonImmediate(_fieldOop)), (oopisLessThan(_fieldOop, (GIV(memoryMap)->newSpaceEnd))) && (oopisGreaterThanOrEqualTo(_fieldOop, (GIV(memoryMap)->newSpaceStart)))))) {
									_containsYoung = 1;
								}
							}
						}
					}
					if (_containsYoung) {
						if (!(((((usqInt) (long64At(_objOop2)) ) >> (rememberedBitShift())) & 1) != 0)) {
							{
								print("unremembered object ");
								printHex(_objOop2);
								print(" contains young oop(s)");
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_ok = 0;
						}
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop2;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress3 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, _limit2)) {
			_objOop2 = _limit2;
			goto l47;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_objOop2 = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l47:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceEntitiesDo: */
	if (_numRememberedObjectsInHeap != ((GIV(fromOldSpaceRememberedSet)->rememberedSetSize))) {
		{
			print("root count mismatch. #heap roots ");
			printNum(_numRememberedObjectsInHeap);
			print("; #roots ");
			printNum((GIV(fromOldSpaceRememberedSet)->rememberedSetSize));
			/* begin cr */
			print("\n");
			/* end cr */
		}
		flag("no support for remembered set overflow yet");
	}
	/* begin rememberedSetWithIndexDo: */
	/* begin rememberedSetWithIndexDo:startingAt: */
	for (_i3 = 0; _i3 < ((GIV(fromOldSpaceRememberedSet)->rememberedSetSize)); _i3 += 1) {
		{
			_obj = (GIV(fromOldSpaceRememberedSet)->rememberedSetArray)[_i3];
			if ((_obj & (BytesPerWord - 1)) != 0) {
				{
					print("misaligned oop in remembered set @ ");
					printNum(_i3);
					print(" = ");
					printHex(_obj);
					/* begin cr */
					print("\n");
					/* end cr */
				}
				_ok = 0;
			} else {
				if ((heapMapAtWord(pointerForOop(_obj))) == 0) {
					{
						print("object leak in remembered set @ ");
						printNum(_i3);
						print(" = ");
						printHex(_obj);
						/* begin cr */
						print("\n");
						/* end cr */
					}
					_ok = 0;
				} else {
					if (((_obj & (tagMask())) == 0) && (((_obj & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_obj >= ((GIV(memoryMap)->newSpaceStart))))) {
						{
							print("non-root in remembered set @ ");
							printNum(_i3);
							print(" = ");
							printHex(_obj);
							/* begin cr */
							print("\n");
							/* end cr */
						}
						_ok = 0;
					}
				}
			}
		}
	}
	/* end rememberedSetWithIndexDo:startingAt: */
	/* end rememberedSetWithIndexDo: */
	/* begin objStack:do: */
	if (GIV(mournQueue) == GIV(nilObj)) {
		goto l10;
	}
	eassert(isValidObjStack(GIV(mournQueue)));
	_objStackPage = GIV(mournQueue);
	while (_objStackPage != 0) {
		/* begin fetchPointer:ofObject: */
		_numOnThisPage = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		for (_i2 = (_numOnThisPage + ObjStackFixedSlots) - 1; _i2 >= ObjStackFixedSlots; _i2 += -1) {
			{
				_obj = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) _i2 ) << (shiftForWord())) ));
				if ((_obj & (BytesPerWord - 1)) != 0) {
					{
						print("misaligned oop in mournQueue @ ");
						printNum(_i2);
						print(" in ");
						printHex(_objStackPage);
						print(" = ");
						printHex(_obj);
						/* begin cr */
						print("\n");
						/* end cr */
					}
					_ok = 0;
				} else {
					if (!(_excludeUnmarkedObjs && (!(((((usqInt) (longAt(_obj)) ) >> (markedBitFullShift())) & 1) != 0)))) {
						if ((heapMapAtWord(pointerForOop(_obj))) == 0) {
							{
								print("object leak in mournQueue @ ");
								printNum(_i2);
								print(" in ");
								printHex(_objStackPage);
								print(" = ");
								printHex(_obj);
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_ok = 0;
						}
					}
				}
			}
		}
		/* begin fetchPointer:ofObject: */
		_objStackPage = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
	}
	l10:
	;
	/* end objStack:do: */
	for (_ri = 1; _ri <= GIV(remapBufferCount); _ri += 1) {
		_obj = GIV(remapBuffer)[_ri];
		if ((_obj & (BytesPerWord - 1)) != 0) {
			{
				print("misaligned remapRoot @ ");
				printNum(_ri);
				print(" = ");
				printHex(_obj);
				/* begin cr */
				print("\n");
				/* end cr */
			}
			_ok = 0;
		} else {
			if ((heapMapAtWord(pointerForOop(_obj))) == 0) {
				{
					print("object leak in remapRoots @ ");
					printNum(_ri);
					print(" = ");
					printHex(_obj);
					/* begin cr */
					print("\n");
					/* end cr */
				}
				_ok = 0;
			}
		}
	}
	for (_ri = 1; _ri <= GIV(extraRootCount); _ri += 1) {
		_obj = GIV(extraRoots)[_ri][0];
		if ((_obj & (BytesPerWord - 1)) != 0) {
			{
				print("misaligned extraRoot @ ");
				printNum(_ri);
				print(" => ");
				printHex(_obj);
				/* begin cr */
				print("\n");
				/* end cr */
			}
			_ok = 0;
		} else {
			if ((heapMapAtWord(pointerForOop(_obj))) == 0) {
				{
					print("object leak in extraRoots @ ");
					printNum(_ri);
					print(" => ");
					printHex(_obj);
					/* begin cr */
					print("\n");
					/* end cr */
				}
				_ok = 0;
			}
		}
	}
	return _ok;
}
/*	Verify that the given oop is legitimate. Check address, header, and size 
	but not class. 
	Answer true if OK. Otherwise print reason and answer false. */
/* SpurMemoryManager>>#checkOkayOop: */
sqInt
checkOkayOop(usqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classIndex;
	sqInt _fmt;
	usqLong _unusedBits;
	sqInt _unusedBitsInYoungObjects;

	if (_oop & (tagMask())) {
		return 1;
	}
	if (!(addressCouldBeObj(_oop))) {
		{
			print("oop ");
			printHex(_oop);
			print(" is not a valid address");
		}
		return 0;
	}
	if (!(oopisLessThanOrEqualTo(addressAfter(_oop), (GIV(memoryMap)->oldSpaceEnd)))) {
		{
			print("oop ");
			printHex(_oop);
			print(" size would make it extend beyond the end of memory");
		}
		return 0;
	}
	if (!(((_classIndex = (longAt(_oop)) & (classIndexMask()))) >= (firstClassIndexPun()))) {
		{
			print("oop ");
			printHex(_oop);
			print(" is a free chunk, or bridge, not an object");
		}
		return 0;
	}
	if (((byteAt(_oop + 7)) == (numSlotsMask())) && ((byteAt((_oop - BaseHeaderSize) + 7)) != (numSlotsMask()))) {
		{
			print("oop ");
			printHex(_oop);
			print(" header has overflow header word, but overflow word does not have a saturated numSlots field");
		}
		return 0;
	}
	_fmt = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
	if ((_fmt == 6) || (_fmt == 8)) {
		{
			print("oop ");
			printHex(_oop);
			print(" has an unknown format type");
		}
		return 0;
	}
	if ((_fmt == 7) != (_classIndex == (isForwardedObjectClassIndexPun()))) {
		{
			print("oop ");
			printHex(_oop);
			print(" has mis-matched format/classIndex fields; only one of them is the isForwarded value");
		}
		return 0;
	}
	_unusedBits = (1U << 22) | (1ULL << (22 + 32));
	if (((long64At(_oop)) & _unusedBits) != 0) {
		{
			print("oop ");
			printHex(_oop);
			print(" has some unused header bits set; should be zero");
		}
		return 0;
	}
	_unusedBitsInYoungObjects = (1U << (greyBitShift())) | ((1U << (pinnedBitShift())) | (1U << (rememberedBitShift())));
	if (((longAt(_oop)) & _unusedBitsInYoungObjects) != 0) {
		{
			print("oop ");
			printHex(_oop);
			print(" has some header bits unused in young objects set; should be zero");
		}
		return 0;
	}
	return 1;
}
/* SpurMemoryManager>>#checkOopIntegrity:named: */
static sqInt NoDbgRegParms
checkOopIntegritynamed(sqInt _obj, char *_name)
{
	if ((heapMapAtWord(pointerForOop(_obj))) != 0) {
		return 1;
	}
	{
		print(_name);
		print(" leak ");
		printHex(_obj);
		/* begin cr */
		print("\n");
		/* end cr */
	}
	return 0;
}
/* SpurMemoryManager>>#checkOopIntegrity:named:index: */
static sqInt NoDbgRegParms
checkOopIntegritynamedindex(sqInt _obj, char *_name, sqInt _i)
{
	if ((heapMapAtWord(pointerForOop(_obj))) != 0) {
		return 1;
	}
	{
		print(_name);
		print(" leak @ ");
		printNum(_i);
		print(" = ");
		printHex(_obj);
		/* begin cr */
		print("\n");
		/* end cr */
	}
	return 0;
}
/* SpurMemoryManager>>#classArray */
sqInt
classArray(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/* SpurMemoryManager>>#classAtIndex: */
sqInt
classAtIndex(sqInt _classIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classTablePage;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;

	assert((_classIndex >= 0) && ((_classIndex <= (tagMask())) || ((_classIndex >= (arrayClassIndexPun())) && (_classIndex <= (classIndexMask())))));
	/* begin fetchPointer:ofObject: */
	_fieldIndex2 = ((usqInt) _classIndex ) >> (classTableMajorIndexShift());
	_classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	return ((_classTablePage == GIV(nilObj))
		 ? null
		 : (/* begin fetchPointer:ofObject: */ (_fieldIndex = _classIndex & ((1U << (classTableMajorIndexShift())) - 1)), unsignedLongAt((_classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */));
}
/*	for become & GC of classes */
/* SpurMemoryManager>>#classAtIndex:put: */
static sqInt NoDbgRegParms
classAtIndexput(sqInt _classIndex, sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classTablePage;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;

	assert((_classIndex <= (tagMask())) || (_classIndex >= (arrayClassIndexPun())));
	assert((_objOop == GIV(nilObj)) || ((((rawHashBitsOf(_objOop)) == _classIndex) || ((classAtIndex(rawHashBitsOf(_objOop))) == _objOop)) && (objCouldBeClassObj(_objOop))));
	/* begin fetchPointer:ofObject: */
	_fieldIndex = ((usqInt) _classIndex ) >> (classTableMajorIndexShift());
	_classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_classTablePage == GIV(nilObj)) {
		error("attempt to add class to empty page");
	}
	/* begin storePointer:ofObject:withValue: */
	_fieldIndex2 = _classIndex & ((1U << (classTableMajorIndexShift())) - 1);
	assert(!(isForwarded(_classTablePage)));
	if (((_classTablePage & (tagMask())) == 0) && ((_classTablePage & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((_objOop & (tagMask())) == 0) && (((_objOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_objOop >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_classTablePage)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _classTablePage);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(_classTablePage)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l3;
	}
	if (_objOop & (tagMask())) {
		goto l3;
	}
	if (!(_classTablePage >= 0x20000000000LL)) {
		goto l3;
	}
	if (_objOop >= 0x20000000000LL) {
		goto l3;
	}
	if ((_objOop >= GIV(nilObj)) && (_objOop <= GIV(trueObj))) {
		goto l3;
	}
	if (!(_objOop >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l3;
	}
	remember(getFromPermToNewSpaceRememberedSet(), _classTablePage);
	l3:
	;
	/* end possiblePermObjectStoreInto:value: */
	return unsignedLongAtput((_classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ), _objOop);
	/* end storePointer:ofObject:withValue: */
}
/* SpurMemoryManager>>#classBitmap */
sqInt
classBitmap(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassBitmap ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/*	a.k.a. self fetchPointer: ClassByteArrayCompactIndex ofObject: 
	classTableFirstPage  */
/* SpurMemoryManager>>#classByteArray */
sqInt
classByteArray(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteArray ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/* SpurMemoryManager>>#classCharacter */
sqInt
classCharacter(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassCharacter ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/* SpurMemoryManager>>#classExternalAddress */
sqInt
classExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/* SpurMemoryManager>>#classExternalAddressIndex */
sqInt
classExternalAddressIndex(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aBehavior;
	sqInt _err;
	sqInt _hash;

	/* begin ensureBehaviorHash: */
	_aBehavior = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ));
	assert(addressCouldBeClassObj(_aBehavior));
	return ((((_hash = (uint32AtPointer(_aBehavior + 4)) & (identityHashHalfWordMask()))) != 0)
		 ? _hash
		 : ((objCouldBeClassObj(_aBehavior))
			 ? ((((_err = enterIntoClassTable(_aBehavior))) != 0)
				 ? -_err
				 : (uint32AtPointer(_aBehavior + 4)) & (identityHashHalfWordMask()))
			 : -PrimErrBadReceiver));
	/* end ensureBehaviorHash: */
}
/* SpurMemoryManager>>#classFloat */
sqInt
classFloat(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassFloat ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/*	Clear any odd bits from the format so that it matches its class's format */
/* SpurMemoryManager>>#classFormatForInstanceFormat: */
static sqInt NoDbgRegParms
classFormatForInstanceFormat(sqInt _aFormat)
{
	if (_aFormat < (firstLongFormat())) {
		return _aFormat;
	}
	if (_aFormat >= (firstByteFormat())) {
		return _aFormat & -8;
	}
	return ((_aFormat >= (firstShortFormat()))
		 ? _aFormat & -4
		 : _aFormat & -2);
}
/*	22-bit class mask => ~ 4M classes */
/* SpurMemoryManager>>#classIndexFieldWidth */
sqInt
classIndexFieldWidth(void)
{
	return 22;
}
/*	Answer objOop's classIndex from the object header. 
	A note on performance: 
	This routine uses longAt:, which does a 32-bit load on the 32-bit system, 
	and a 64-bit load 
	on the 64-bit system. Since the only 64-bit implementation(s) is/are 
	little-endian, and 
	since all of isGrey,isPinned,isRemembered,format,isUmmutable and 
	classIndex fit within 
	the least significant 32-bits we could use long32At: to access these, in 
	the hope that the 
	32-bit access will be quicker on 64-bits by virtue of fetching half the 
	bits. But experiments 
	show that doing this does not produce any increase; at least any signal is 
	lost in the noise. */
/* SpurMemoryManager>>#classIndexOf: */
sqInt
classIndexOf(sqInt _objOop)
{
	return (longAt(_objOop)) & (classIndexMask());
}
/* SpurMemoryManager>>#classLargeNegativeInteger */
sqInt
classLargeNegativeInteger(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return (assert((ClassLargeNegativeIntegerCompactIndex >= 1) && (ClassLargeNegativeIntegerCompactIndex <= (classTablePageSize()))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargeNegativeIntegerCompactIndex ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */);
}
/* SpurMemoryManager>>#classLargePositiveInteger */
sqInt
classLargePositiveInteger(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return (assert((ClassLargePositiveIntegerCompactIndex >= 1) && (ClassLargePositiveIntegerCompactIndex <= (classTablePageSize()))), /* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveIntegerCompactIndex ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */);
}
/* SpurMemoryManager>>#classOrNilAtIndex: */
sqInt
classOrNilAtIndex(sqInt _classIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classTablePage;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;

	assert((_classIndex <= (tagMask())) || (_classIndex >= (arrayClassIndexPun())));
	/* begin fetchPointer:ofObject: */
	_fieldIndex = ((usqInt) _classIndex ) >> (classTableMajorIndexShift());
	_classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_classTablePage == GIV(nilObj)) {
		return GIV(nilObj);
	}
	/* begin fetchPointer:ofObject: */
	_fieldIndex2 = _classIndex & ((1U << (classTableMajorIndexShift())) - 1);
	return unsignedLongAt((_classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/* SpurMemoryManager>>#classPoint */
sqInt
classPoint(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassPoint ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/* SpurMemoryManager>>#classSemaphore */
sqInt
classSemaphore(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassSemaphore ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/* SpurMemoryManager>>#classSmallInteger */
sqInt
classSmallInteger(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassSmallInteger ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/* SpurMemoryManager>>#classString */
sqInt
classString(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteString ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/*	1024 entries per page (2^10); 22 bit classIndex implies 2^12 pagesself basicNew classTableMinorIndexMask */
/* SpurMemoryManager>>#classTableMinorIndexMask */
sqInt
classTableMinorIndexMask(void)
{
	return (1U << (classTableMajorIndexShift())) - 1;
}
/*	1024 entries per page (2^10); 22 bit classIndex implies 2^12 pagesself basicNew classTablePageSize */
/* SpurMemoryManager>>#classTablePageSize */
sqInt
classTablePageSize(void)
{
	return 1U << (classTableMajorIndexShift());
}
/*	For Cogit & bootstrap */
/* SpurMemoryManager>>#classTableRootObj */
sqInt
classTableRootObj(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(hiddenRootsObj);
}
/*	Answer the number of slots for class table pages in the hidden root 
	object.  */
/* SpurMemoryManager>>#classTableRootSlots */
static sqInt
classTableRootSlots(void)
{
	return 1U << (22 - (classTableMajorIndexShift()));
}
/*	Answer the classObj's identityHash to use as a tag in the first-level 
	method lookup cache. */
/* SpurMemoryManager>>#classTagForClass: */
sqInt
classTagForClass(sqInt _classObj)
{
	sqInt _err;
	sqInt _hash;

	return (assert(addressCouldBeClassObj(_classObj)), ((((_hash = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask()))) != 0)
		 ? _hash
		 : ((objCouldBeClassObj(_classObj))
			 ? ((((_err = enterIntoClassTable(_classObj))) != 0)
				 ? -_err
				 : (/* begin rawHashBitsOf: */ (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask()) /* end rawHashBitsOf: */))
			 : -PrimErrBadReceiver)));
}
/* SpurMemoryManager>>#cleanUpPermToNewSpaceRememeberedSet */
static void
cleanUpPermToNewSpaceRememeberedSet(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMRememberedSet * self_in_saveat;
	VMRememberedSet * self_in_setRememberedSetSize;
	int _destIndex;
	sqInt _newLimit;
	sqInt _newSize;
	sqInt _newStart;
	sqInt _newTop;
	sqInt _referrer;
	sqInt _sourceIndex;

	_sourceIndex = (_destIndex = 0);
	while (_sourceIndex < (((getFromPermToNewSpaceRememberedSet())->rememberedSetSize))) {
		_referrer = ((getFromPermToNewSpaceRememberedSet())->rememberedSetArray)[_sourceIndex];
		if (((long64At(_referrer)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
			/* begin handleUnreacheablePermanentForwarded: */
			/* begin addToStack: */
			if (((GIV(permSpaceForwardersToCleanUp)->top)) == ((GIV(permSpaceForwardersToCleanUp)->limit))) {
				/* begin extendObjStack */
				_newSize = ((((GIV(permSpaceForwardersToCleanUp)->limit)) - ((GIV(permSpaceForwardersToCleanUp)->start))) / BytesPerWord) * 2;
				_newStart = realloc((GIV(permSpaceForwardersToCleanUp)->start), BytesPerWord * _newSize);
				if (!_newStart) {
					error("Imposible to extend SpurContiguousObjStack");
				}
				_newLimit = ((sqInt) _newStart ) + (_newSize * BytesPerWord);
				_newTop = (((GIV(permSpaceForwardersToCleanUp)->top)) - ((GIV(permSpaceForwardersToCleanUp)->start))) + ((sqInt) _newStart );
				{
					(GIV(permSpaceForwardersToCleanUp)->start = ((sqInt) _newStart ));
					(GIV(permSpaceForwardersToCleanUp)->limit = _newLimit);
				}
				(GIV(permSpaceForwardersToCleanUp)->top = _newTop);
				/* end extendObjStack */
			}
			longAtput((GIV(permSpaceForwardersToCleanUp)->top), _referrer);
			(GIV(permSpaceForwardersToCleanUp)->top = ((GIV(permSpaceForwardersToCleanUp)->top)) + BytesPerOop);
			/* end addToStack: */
			/* end handleUnreacheablePermanentForwarded: */
		} else {
			/* begin save:at: */
			/* begin getFromPermToNewSpaceRememberedSet */
			self_in_saveat = GIV(fromPermToNewSpaceRememberedSet);
			/* end getFromPermToNewSpaceRememberedSet */
			(self_in_saveat->rememberedSetArray)[_destIndex] = _referrer;
			/* end save:at: */
			_destIndex += 1;
		}
		_sourceIndex += 1;
	}
	/* begin setRememberedSetSize: */
	/* begin getFromPermToNewSpaceRememberedSet */
	self_in_setRememberedSetSize = GIV(fromPermToNewSpaceRememberedSet);
	/* end getFromPermToNewSpaceRememberedSet */
	(self_in_setRememberedSetSize->rememberedSetSize) = _destIndex;
	if (_destIndex < ((self_in_setRememberedSetSize->rememberedSetLimit))) {
		(self_in_setRememberedSetSize->rememberedSetArray)[_destIndex] = 0;
	}
	/* end setRememberedSetSize: */
	shrinkRememberedSet(getFromPermToNewSpaceRememberedSet());
}
/* SpurMemoryManager>>#cleanUpPermToOldSpaceRememeberedSet */
static void
cleanUpPermToOldSpaceRememeberedSet(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMRememberedSet * self_in_rememberedSetWithIndexDo;
	VMRememberedSet * self_in_saveat;
	VMRememberedSet * self_in_setRememberedSetSize;
	int _destIndex;
	sqInt _i;
	sqInt _newLimit;
	sqInt _newSize;
	sqInt _newStart;
	sqInt _newTop;
	sqInt _oop;
	sqInt _referrer;
	sqInt _sourceIndex;

	_sourceIndex = (_destIndex = 0);
	assert(allPermSpaceObjectsUnmarked());
	while (_sourceIndex < (((getFromPermToOldSpaceRememberedSet())->rememberedSetSize))) {
		_referrer = ((getFromPermToOldSpaceRememberedSet())->rememberedSetArray)[_sourceIndex];
		assert((isForwarded(_referrer)) || ((!(hasYoungReferents(_referrer))) || (isRemembered(_referrer))));
		if (((long64At(_referrer)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
			/* begin handleUnreacheablePermanentForwarded: */
			/* begin addToStack: */
			if (((GIV(permSpaceForwardersToCleanUp)->top)) == ((GIV(permSpaceForwardersToCleanUp)->limit))) {
				/* begin extendObjStack */
				_newSize = ((((GIV(permSpaceForwardersToCleanUp)->limit)) - ((GIV(permSpaceForwardersToCleanUp)->start))) / BytesPerWord) * 2;
				_newStart = realloc((GIV(permSpaceForwardersToCleanUp)->start), BytesPerWord * _newSize);
				if (!_newStart) {
					error("Imposible to extend SpurContiguousObjStack");
				}
				_newLimit = ((sqInt) _newStart ) + (_newSize * BytesPerWord);
				_newTop = (((GIV(permSpaceForwardersToCleanUp)->top)) - ((GIV(permSpaceForwardersToCleanUp)->start))) + ((sqInt) _newStart );
				{
					(GIV(permSpaceForwardersToCleanUp)->start = ((sqInt) _newStart ));
					(GIV(permSpaceForwardersToCleanUp)->limit = _newLimit);
				}
				(GIV(permSpaceForwardersToCleanUp)->top = _newTop);
				/* end extendObjStack */
			}
			longAtput((GIV(permSpaceForwardersToCleanUp)->top), _referrer);
			(GIV(permSpaceForwardersToCleanUp)->top = ((GIV(permSpaceForwardersToCleanUp)->top)) + BytesPerOop);
			/* end addToStack: */
			/* end handleUnreacheablePermanentForwarded: */
		} else {
			if ((!(((((usqInt) (longAt(_referrer)) ) >> (markedBitFullShift())) & 1) != 0)) && (hasOldReferents(_referrer))) {
				/* begin save:at: */
				/* begin getFromPermToOldSpaceRememberedSet */
				self_in_saveat = GIV(fromPermToOldSpaceRememberedSet);
				/* end getFromPermToOldSpaceRememberedSet */
				(self_in_saveat->rememberedSetArray)[_destIndex] = _referrer;
				/* end save:at: */
				/* begin setIsMarkedOf:to: */
				assert(!(isFreeObject(_referrer)));
				unsignedLongAtput(_referrer, (unsignedLongAt(_referrer)) | (1ULL << (markedBitFullShift())));
				/* end setIsMarkedOf:to: */
				_destIndex += 1;
			}
		}
		_sourceIndex += 1;
	}
	/* begin setRememberedSetSize: */
	/* begin getFromPermToOldSpaceRememberedSet */
	self_in_setRememberedSetSize = GIV(fromPermToOldSpaceRememberedSet);
	/* end getFromPermToOldSpaceRememberedSet */
	(self_in_setRememberedSetSize->rememberedSetSize) = _destIndex;
	if (_destIndex < ((self_in_setRememberedSetSize->rememberedSetLimit))) {
		(self_in_setRememberedSetSize->rememberedSetArray)[_destIndex] = 0;
	}
	/* end setRememberedSetSize: */
	/* begin rememberedSetWithIndexDo: */
	/* begin getFromPermToOldSpaceRememberedSet */
	self_in_rememberedSetWithIndexDo = GIV(fromPermToOldSpaceRememberedSet);
	/* end getFromPermToOldSpaceRememberedSet */
	/* begin rememberedSetWithIndexDo:startingAt: */
	for (_i = 0; _i < ((self_in_rememberedSetWithIndexDo->rememberedSetSize)); _i += 1) {
		{
			_oop = (self_in_rememberedSetWithIndexDo->rememberedSetArray)[_i];
			/* begin setIsMarkedOf:to: */
			assert(!(isFreeObject(_oop)));
			unsignedLongAtput(_oop, (unsignedLongAt(_oop)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
			/* end setIsMarkedOf:to: */
		}
	}
	/* end rememberedSetWithIndexDo:startingAt: */
	/* end rememberedSetWithIndexDo: */
	shrinkRememberedSet(getFromPermToOldSpaceRememberedSet());
	assert(allPermSpaceObjectsUnmarked());
}
/*	Perform an integrity/leak check using the heapMap. Set a bit at each free 
	chunk's header. */
/* SpurMemoryManager>>#clearLeakMapAndMapAccessibleFreeSpace */
static void
clearLeakMapAndMapAccessibleFreeSpace(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _followingWord;
	usqInt _followingWordAddress;
	sqInt _limit;
	sqInt _objOop2;
	sqInt _prevObj;
	sqInt _prevPrevObj;

	clearHeapMap();
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj = (_prevObj = null);
	_objOop2 = GIV(nilObj);
	while (1) {
		assert((_objOop2 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop2, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop2)) != 0);
		{
			if (((longAt(_objOop2)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
				heapMapAtWordPut(pointerForOop(_objOop2), 1);
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_limit = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l2;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l2:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
}
/* SpurMemoryManager>>#cloneInOldSpace:forPinning: */
static sqInt NoDbgRegParms
cloneInOldSpaceforPinning(sqInt _objOop, sqInt _forPinning)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _cogMethodOrMethodHeader;
	sqInt _fmt;
	sqInt _hash;
	int _hasYoung;
	sqInt _i;
	sqInt _newObj;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _oop;
	sqInt _rawHeader;
	sqInt _referent;
	sqInt _valuePointer;

	/* begin numSlotsOf: */
	assert((classIndexOf(_objOop)) > (isForwardedObjectClassIndexPun()));
	_numSlots2 = byteAt(_objOop + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOf: */
	_fmt = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	if (_forPinning) {
		_newObj = allocateSlotsForPinningInOldSpacebytesformatclassIndex(_numSlots, ((_numSlots == 0)
			 ? 8 + BaseHeaderSize
			 : (_numSlots << (shiftForWord())) + (((_numSlots >= (numSlotsMask()))
				 ? BaseHeaderSize + BaseHeaderSize
				 : BaseHeaderSize))), _fmt, (longAt(_objOop)) & (classIndexMask()));
	}
 else {
		_newObj = allocateSlotsInOldSpacebytesformatclassIndex(_numSlots, ((_numSlots == 0)
			 ? 8 + BaseHeaderSize
			 : (_numSlots << (shiftForWord())) + (((_numSlots >= (numSlotsMask()))
				 ? BaseHeaderSize + BaseHeaderSize
				 : BaseHeaderSize))), _fmt, (longAt(_objOop)) & (classIndexMask()));
	}
	if (!_newObj) {
		return 0;
	}
	if (_fmt <= 5) {
		_hasYoung = 0;
		for (_i = 0; _i < _numSlots; _i += 1) {
			_oop = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
			if (((_oop & (tagMask())) == 0) && (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin followForwarded: */
				assert(isUnambiguouslyForwarder(_oop));
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent = unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
				while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
				}
				_oop = _referent;
				/* end followForwarded: */
			}
			if (((_oop & (tagMask())) == 0) && (((_oop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_oop >= ((GIV(memoryMap)->newSpaceStart))))) {
				_hasYoung = 1;
			}
			{
				assert(!(isOopForwarded(_newObj)));
				longAtput((_newObj + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _oop);
			}
		}
		if (_hasYoung) {
			remember(getFromOldSpaceRememberedSet(), _newObj);
		}
	} else {
		for (_i = 0; _i < _numSlots; _i += 1) {
			/* begin storePointerUnchecked:ofObject:withValue: */
			_valuePointer = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
			assert(!(isOopForwarded(_newObj)));
			longAtput((_newObj + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _valuePointer);
			/* end storePointerUnchecked:ofObject:withValue: */
		}
		if (_fmt >= (firstCompiledMethodFormat())) {
			/* begin maybeFixClonedCompiledMethod: */
			assert(isOopCompiledMethod(_newObj));
			/* begin fetchPointer:ofObject: */
			_rawHeader = unsignedLongAt((_newObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if ((assert((((_rawHeader & 7) == 1)) || ((((usqInt) _rawHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _rawHeader ) >= (minCogMethodAddress())))), (_rawHeader & (smallIntegerTag())) == 0)) {
				/* begin rawHeaderOf:put: */
				_cogMethodOrMethodHeader = ((((CogMethod *) _rawHeader ))->methodHeader);
				assert(isCompiledMethodHeader(headerWhileForwardingOf(_newObj)));
				{
					assert(!(isOopForwarded(_newObj)));
					longAtput((_newObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ), _cogMethodOrMethodHeader);
				}
				/* end rawHeaderOf:put: */
			}
			/* end maybeFixClonedCompiledMethod: */
			if ((((_objOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_objOop >= ((GIV(memoryMap)->newSpaceStart)))) || (((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(getFromOldSpaceRememberedSet(), _newObj);
			}
		}
	}
	if (((_hash = (uint32AtPointer(_objOop + 4)) & (identityHashHalfWordMask()))) != 0) {
		/* begin setHashBitsOf:to: */
		assert((_hash >= 0) && (_hash <= (identityHashHalfWordMask())));
		uint32AtPointerput(_newObj + 4, (((uint32AtPointer(_newObj + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + _hash);
		/* end setHashBitsOf:to: */
	}
	if (
#    if IMMUTABILITY
			(/* begin isImmutable: */ ((((usqInt) (longAt(_objOop)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#    else /* IMMUTABILITY */
			0
#    endif /* IMMUTABILITY */
			) {
		/* begin setIsImmutableOf:to: */
		longAtput(_newObj, (longAt(_newObj)) | (1U << (immutableBitShift())));
		/* end setIsImmutableOf:to: */
	}
	return _newObj;
}
/* SpurMemoryManager>>#clone: */
sqInt
clone(sqInt _objOop)
{
	return cloneshouldAllocateInPermSpace(_objOop, 0);
}
/*	Attention: the shouldAllocateInPermSpace is only used by the become, as it 
	handles adding or not the new perm object to the remembered sets */
/* SpurMemoryManager>>#clone:shouldAllocateInPermSpace: */
static sqInt NoDbgRegParms
cloneshouldAllocateInPermSpace(sqInt _objOop, sqInt _shouldAllocateInPermSpace)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classIndex;
	sqInt _classIndex2;
	sqInt _classIndex3;
	sqInt _cogMethodOrMethodHeader;
	sqInt _fmt;
	int _hasToScheduleScavenge;
	int _hasYoung;
	sqInt _i;
	sqInt _newObj;
	sqInt _newObj2;
	usqInt _numBytes;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _oop;
	sqInt _rawHeader;
	sqInt _referent;
	sqInt _valuePointer;

	/* begin numSlotsOf: */
	assert((classIndexOf(_objOop)) > (isForwardedObjectClassIndexPun()));
	_numSlots2 = byteAt(_objOop + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOf: */
	_fmt = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	if (_shouldAllocateInPermSpace) {
		/* begin allocateSlotsInPermSpace:format:classIndex: */
		_classIndex = (longAt(_objOop)) & (classIndexMask());
		_newObj = allocateSlotsInPermSpacebytesformatclassIndex(_numSlots, ((_numSlots == 0)
			 ? 8 + BaseHeaderSize
			 : (_numSlots << (shiftForWord())) + (((_numSlots >= (numSlotsMask()))
				 ? BaseHeaderSize + BaseHeaderSize
				 : BaseHeaderSize))), _fmt, _classIndex);
		/* end allocateSlotsInPermSpace:format:classIndex: */
	} else {
		if (_numSlots > (((GIV(maxSlotsForNewSpaceAlloc) == 0)
			 ? (/* begin fixedFieldsOfClassFormatMask */ (1U << (fixedFieldsFieldWidth())) - 1 /* end fixedFieldsOfClassFormatMask */)
			 : GIV(maxSlotsForNewSpaceAlloc)))) {
			/* begin allocateSlotsInOldSpace:format:classIndex: */
			_classIndex2 = (longAt(_objOop)) & (classIndexMask());
			_newObj = allocateSlotsInOldSpacebytesformatclassIndex(_numSlots, ((_numSlots == 0)
				 ? 8 + BaseHeaderSize
				 : (_numSlots << (shiftForWord())) + (((_numSlots >= (numSlotsMask()))
					 ? BaseHeaderSize + BaseHeaderSize
					 : BaseHeaderSize))), _fmt, _classIndex2);
			/* end allocateSlotsInOldSpace:format:classIndex: */
		} else {
			/* begin allocateSlots:format:classIndex: */
			_classIndex3 = (longAt(_objOop)) & (classIndexMask());
			/* begin allocateSlots:format:classIndex:isPinned:isOldSpace: */
			if (_numSlots >= (numSlotsMask())) {
				if ((((usqInt) _numSlots ) >> 56) > 0) {
					_newObj = null;
					goto l11;
				}
				_numBytes = (BaseHeaderSize + BaseHeaderSize) + (_numSlots * BytesPerOop);
			} else {
				_numBytes = BaseHeaderSize + (((_numSlots < 1)
					 ? 8
					 : _numSlots * BytesPerOop));
			}
			_hasToScheduleScavenge = (GIV(freeStart) + _numBytes) > GIV(scavengeThreshold);
			if (_hasToScheduleScavenge || 0) {
				if (_hasToScheduleScavenge) {
					if (!GIV(needGCFlag)) {
						/* begin scheduleScavenge */
						GIV(needGCFlag) = 1;
						forceInterruptCheck();
						/* end scheduleScavenge */
					}
				}
				{
					_newObj = allocateSlotsInOldSpacebytesformatclassIndex(_numSlots, _numBytes, _fmt, _classIndex3);
					goto l11;
				}
			}
			_newObj2 = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(GIV(freeStart), _numSlots, _fmt, _classIndex3, 0);
			assert((_numBytes % (allocationUnit())) == 0);
			assert((_newObj2 % (allocationUnit())) == 0);
			GIV(freeStart) += _numBytes;
			_newObj = _newObj2;
			/* end allocateSlots:format:classIndex:isPinned:isOldSpace: */
			l11:
			;
			/* end allocateSlots:format:classIndex: */
		}
	}
	if (!_newObj) {
		return 0;
	}
	if (_fmt <= 5) {
		_hasYoung = 0;
		for (_i = 0; _i < _numSlots; _i += 1) {
			_oop = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
			if ((_oop & (tagMask())) == 0) {
				if (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					/* begin followForwarded: */
					assert(isUnambiguouslyForwarder(_oop));
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent = unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
					while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
					}
					_oop = _referent;
					/* end followForwarded: */
				}
				if (((_oop & (tagMask())) == 0) && (((_oop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_oop >= ((GIV(memoryMap)->newSpaceStart))))) {
					_hasYoung = 1;
				}
			}
			{
				assert(!(isOopForwarded(_newObj)));
				longAtput((_newObj + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _oop);
			}
		}
		if (_hasYoung && (!(((_newObj & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_newObj >= ((GIV(memoryMap)->newSpaceStart)))))) {
			remember(getFromOldSpaceRememberedSet(), _newObj);
		}
	} else {
		for (_i = 0; _i < _numSlots; _i += 1) {
			/* begin storePointerUnchecked:ofObject:withValue: */
			_valuePointer = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
			assert(!(isOopForwarded(_newObj)));
			longAtput((_newObj + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _valuePointer);
			/* end storePointerUnchecked:ofObject:withValue: */
		}
		if (_fmt >= (firstCompiledMethodFormat())) {
			/* begin maybeFixClonedCompiledMethod: */
			assert(isOopCompiledMethod(_newObj));
			/* begin fetchPointer:ofObject: */
			_rawHeader = unsignedLongAt((_newObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if ((assert((((_rawHeader & 7) == 1)) || ((((usqInt) _rawHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _rawHeader ) >= (minCogMethodAddress())))), (_rawHeader & (smallIntegerTag())) == 0)) {
				/* begin rawHeaderOf:put: */
				_cogMethodOrMethodHeader = ((((CogMethod *) _rawHeader ))->methodHeader);
				assert(isCompiledMethodHeader(headerWhileForwardingOf(_newObj)));
				{
					assert(!(isOopForwarded(_newObj)));
					longAtput((_newObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ), _cogMethodOrMethodHeader);
				}
				/* end rawHeaderOf:put: */
			}
			/* end maybeFixClonedCompiledMethod: */
			if (((_newObj & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask))) && ((((_objOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_objOop >= ((GIV(memoryMap)->newSpaceStart)))) || (((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0))) {
				remember(getFromOldSpaceRememberedSet(), _newObj);
			}
		}
	}
	return _newObj;
}
/* SpurMemoryManager>>#codeEnd */
uint64_t
codeEnd(void)
{
	return ((getMemoryMap())->codeZoneEnd);
}
/* SpurMemoryManager>>#codeStart */
uint64_t
codeStart(void)
{
	return ((getMemoryMap())->codeZoneStart);
}
/* SpurMemoryManager>>#compactClassIndexOf: */
sqInt
compactClassIndexOf(sqInt _objOop)
{
	/* begin classIndexOf: */
	return (longAt(_objOop)) & (classIndexMask());
	/* end classIndexOf: */
}
/*	print the count of marked and unmarked objects. 
	In addition if 1 is set in printFlags, short-print marked objects, 
	and/or if 2 is set, short-print unmarked obejcts. */
/* SpurMemoryManager>>#countMarkedAndUnmarkdObjects: */
void
countMarkedAndUnmarkdObjects(sqInt _printFlags)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	usqInt _limit;
	sqInt _limit2;
	sqInt _nm;
	int _nu;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	_nm = (_nu = 0);
	/* begin allObjectsDo: */
	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop2 = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop2, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((((usqInt) (longAt(_objOop2)) ) >> (markedBitFullShift())) & 1) != 0) {
					_nm += 1;
					if (_printFlags & 1) {
						shortPrintOop(_objOop2);
					}
				} else {
					_nu += 1;
					if (_printFlags & 2) {
						shortPrintOop(_objOop2);
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop2 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((((usqInt) (longAt(_objOop2)) ) >> (markedBitFullShift())) & 1) != 0) {
					_nm += 1;
					if (_printFlags & 1) {
						shortPrintOop(_objOop2);
					}
				} else {
					_nu += 1;
					if (_printFlags & 2) {
						shortPrintOop(_objOop2);
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop2 = GIV(freeStart);
			goto l9;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l9:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	/* begin allOldSpaceObjectsDo: */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop22 = GIV(nilObj);
	while (1) {
		assert((_objOop22 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop22)) != 0);
		{
			if (isEnumerableObject(_objOop22)) {
				{
					if (((((usqInt) (longAt(_objOop22)) ) >> (markedBitFullShift())) & 1) != 0) {
						_nm += 1;
						if (_printFlags & 1) {
							shortPrintOop(_objOop22);
						}
					} else {
						_nu += 1;
						if (_printFlags & 2) {
							shortPrintOop(_objOop22);
						}
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop22 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	/* end allOldSpaceObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (((((usqInt) (longAt(_currentObject)) ) >> (markedBitFullShift())) & 1) != 0) {
					_nm += 1;
					if (_printFlags & 1) {
						shortPrintOop(_currentObject);
					}
				} else {
					_nu += 1;
					if (_printFlags & 2) {
						shortPrintOop(_currentObject);
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
	{
		print("n marked: ");
		printNum(_nm);
		/* begin cr */
		print("\n");
		/* end cr */
	}
	{
		print("n unmarked: ");
		printNum(_nu);
		/* begin cr */
		print("\n");
		/* end cr */
	}
}
/*	Compute the current allocated bytes since last set. 
	This is the cumulative total in statAllocatedBytes plus the allocation 
	since the last scavenge.Slang infers the type of the difference between two unsigned variables as 
	signed. In this case we want it to be unsigned. */
/* SpurMemoryManager>>#currentAllocatedBytes */
static usqLong
currentAllocatedBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _use;

	_use = (GIV(totalHeapSizeIncludingBridges) - (GIV(numSegments) * (2 * BaseHeaderSize))) - GIV(totalFreeOldSpace);
	return (GIV(statAllocatedBytes) + (GIV(freeStart) - (((eden()).start)))) + (_use - GIV(oldSpaceUsePriorToScavenge));
}
/* SpurMemoryManager>>#doMoveToPermSpace:addToRememberedSet: */
static sqInt NoDbgRegParms
doMoveToPermSpaceaddToRememberedSet(sqInt _objOop, sqInt _shouldAddToRememberedSet)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classIndex;
	sqInt _contextSize;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _hash;
	sqInt _header;
	sqInt _header2;
	sqInt _i;
	sqInt _newObj;
	sqInt _numLiterals;
	usqInt _numPointerSlots;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots3;
	sqInt _referenced;
	sqInt _referent;
	int _refersNewSpace;
	int _refersOldSpace;
	sqInt _sp;

	/* begin numSlotsOf: */
	assert((classIndexOf(_objOop)) > (isForwardedObjectClassIndexPun()));
	_numSlots2 = byteAt(_objOop + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOf: */
	/* begin numPointerSlotsOf: */
	_fmt2 = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	if (_fmt2 <= 5) {
		if ((_fmt2 == (indexablePointersFormat())) && (((longAt(_objOop)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
			/* begin fetchStackPointerOf: */
			/* begin fetchPointer:ofObject: */
			_sp = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (!(((_sp & 7) == 1))) {
				_contextSize = 0;
				goto l8;
			}
			assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_objOop)));
			_contextSize = _sp >> 3;
			l8:
			;
			/* end fetchStackPointerOf: */
			_numPointerSlots = CtxtTempFrameStart + _contextSize;
			goto l12;
		}
		/* begin numSlotsOf: */
		assert((classIndexOf(_objOop)) > (isForwardedObjectClassIndexPun()));
		_numSlots3 = byteAt(_objOop + 7);
		_numPointerSlots = ((_numSlots3 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots3);
		goto l12;
		/* end numSlotsOf: */
	}
	if (_fmt2 == 7) {
		_numPointerSlots = 1;
		goto l12;
	}
	if (_fmt2 < (firstCompiledMethodFormat())) {
		_numPointerSlots = 0;
		goto l12;
	}
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_objOop));
	/* begin fetchPointer:ofObject: */
	_header2 = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header2 & 7) == 1)) {
		_header = _header2;
	} else {
		assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_header = ((((CogMethod *) _header2 ))->methodHeader);
	}
	/* end methodHeaderOf: */
	{
		assert(((_header & 7) == 1));
		_numLiterals = (_header >> 3) & AlternateHeaderNumLiteralsMask;
	}
	_numPointerSlots = _numLiterals + LiteralStart;
	l12:
	;
	/* end numPointerSlotsOf: */
	_fmt = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	_newObj = allocateSlotsInPermSpacebytesformatclassIndex(_numSlots, ((_numSlots == 0)
		 ? 8 + BaseHeaderSize
		 : (_numSlots << (shiftForWord())) + (((_numSlots >= (numSlotsMask()))
			 ? BaseHeaderSize + BaseHeaderSize
			 : BaseHeaderSize))), _fmt, (longAt(_objOop)) & (classIndexMask()));
	if (!_newObj) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrNoMemory;
		/* end primitiveFailFor: */
		return null;
	}
	_refersNewSpace = 0;
	_refersOldSpace = 0;
	for (_i = 0; _i < _numSlots; _i += 1) {
		_referenced = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		if ((_i < _numPointerSlots) && (((_referenced & (tagMask())) == 0) && (_referenced >= (startOfObjectMemory(GIV(memoryMap)))))) {
			if (((long64At(_referenced)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
				/* begin followForwarded: */
				assert(isUnambiguouslyForwarder(_referenced));
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent = unsignedLongAt((_referenced + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
				while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
				}
				_referenced = _referent;
				/* end followForwarded: */
			}
			if (!_refersNewSpace && (!((_referenced >= GIV(nilObj)) && (_referenced <= GIV(trueObj))))) {
				if (((_referenced & (((getMemoryMap())->spaceMaskToUse))) == (((getMemoryMap())->newSpaceMask))) && (_referenced >= (((getMemoryMap())->newSpaceStart)))) {
					_refersNewSpace = 1;
				} else {
					if ((_referenced & (((getMemoryMap())->spaceMaskToUse))) == (((getMemoryMap())->oldSpaceMask))) {
						_refersOldSpace = 1;
					}
				}
			}
		}
		{
			assert(!(isOopForwarded(_newObj)));
			longAtput((_newObj + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _referenced);
		}
	}
	if (((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0) {
		forgetObject(GIV(fromOldSpaceRememberedSet), _objOop);
	}
	if (_shouldAddToRememberedSet) {
		if (_refersNewSpace) {
			remember(getFromPermToNewSpaceRememberedSet(), _newObj);
		} else {
			if (_refersOldSpace) {
				rememberWithoutMarkingAsRemembered(getFromPermToOldSpaceRememberedSet(), _newObj);
			}
		}
	}
	if (((_hash = (uint32AtPointer(_objOop + 4)) & (identityHashHalfWordMask()))) != 0) {
		/* begin setHashBitsOf:to: */
		assert((_hash >= 0) && (_hash <= (identityHashHalfWordMask())));
		uint32AtPointerput(_newObj + 4, (((uint32AtPointer(_newObj + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + _hash);
		/* end setHashBitsOf:to: */
	}
	if (
#    if IMMUTABILITY
			(/* begin isImmutable: */ ((((usqInt) (longAt(_objOop)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#    else /* IMMUTABILITY */
			0
#    endif /* IMMUTABILITY */
			) {
		/* begin setIsImmutableOf:to: */
		longAtput(_newObj, (longAt(_newObj)) | (1U << (immutableBitShift())));
		/* end setIsImmutableOf:to: */
	}
	GIV(becomeEffectsFlags) = GIV(becomeEffectsFlags) | (becomeEffectFlagsFor(_objOop));
	/* begin forward:to: */
	/* begin set:classIndexTo:formatTo: */
	_classIndex = isForwardedObjectClassIndexPun();
	assert((_classIndex >= 0) && (_classIndex <= (classIndexMask())));
	assert((7 >= 0) && (7 <= (formatMask())));
	longAtput(_objOop, ((longAt(_objOop)) & (~((usqIntptr_t) (((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) + (classIndexMask())) ))) + (_classIndex + (7U << (formatShift()))));
	/* end set:classIndexTo:formatTo: */
	
#  if IMMUTABILITY
	{
		/* begin setIsImmutableOf:to: */
		longAtput(_objOop, (longAt(_objOop)) & (~((usqIntptr_t) (1U << (immutableBitShift())) )));
		/* end setIsImmutableOf:to: */
	}
#  endif /* IMMUTABILITY */
	/* begin storePointer:ofForwarder:withValue: */
	assert(isForwarded(_objOop));
	assert(!(isOopForwarded(_newObj)));
	if ((_objOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask))) {
		if (((_newObj & (tagMask())) == 0) && (((_newObj & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_newObj >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _objOop);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l14;
	}
	if (_newObj & (tagMask())) {
		goto l14;
	}
	if (!(_objOop >= 0x20000000000LL)) {
		goto l14;
	}
	if (_newObj >= 0x20000000000LL) {
		goto l14;
	}
	if ((_newObj >= GIV(nilObj)) && (_newObj <= GIV(trueObj))) {
		goto l14;
	}
	if (!(_newObj >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l14;
	}
	remember(getFromPermToNewSpaceRememberedSet(), _objOop);
	l14:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((_objOop + BaseHeaderSize) + (0U << (shiftForWord())), _newObj);
	/* end storePointer:ofForwarder:withValue: */
	if ((byteAt(_objOop + 7)) == 0) {
		byteAtput(_objOop + 7, 1);
	}
	/* end forward:to: */
	return _newObj;
}
/*	The inner shell for scavenge, abstrascted out so globalGarbageCollect can 
	use it. */
/* SpurMemoryManager>>#doScavenge: */
static void NoDbgRegParms
doScavenge(sqInt _tenuringCriterion)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	SpurNewSpaceSpace *_aNewSpace;
	sqInt _oldStart;
	sqInt _p;
	SpurNewSpaceSpace _temp;
	usqInt _use;

	/* begin doAllocationAccountingForScavenge */
	/* begin currentAllocatedBytes */
	_use = (GIV(totalHeapSizeIncludingBridges) - (GIV(numSegments) * (2 * BaseHeaderSize))) - GIV(totalFreeOldSpace);
	GIV(statAllocatedBytes) = (GIV(statAllocatedBytes) + (GIV(freeStart) - (((eden()).start)))) + (_use - GIV(oldSpaceUsePriorToScavenge));
	/* end currentAllocatedBytes */
	/* end doAllocationAccountingForScavenge */
	GIV(gcPhaseInProgress) = ScavengeInProgress;
	/* begin scavenge: */
	GIV(statSurvivorCount) = 0;
	GIV(tenureCriterion) = _tenuringCriterion;
	/* begin logStartScavenge */
	{
		(GIV(scavengeLogRecord).sEdenBytes = (freeStart0()) - ((GIV(eden).start)));
		(GIV(scavengeLogRecord).sPastBytes = (pastSpaceStart()) - ((GIV(pastSpace).start)));
		(GIV(scavengeLogRecord).sRememberedSetSize = ((getFromOldSpaceRememberedSet())->rememberedSetSize));
		(GIV(scavengeLogRecord).sRememberedSetRedZone = ((getFromOldSpaceRememberedSet())->rememberedSetRedZone));
		(GIV(scavengeLogRecord).sRememberedSetLimit = ((getFromOldSpaceRememberedSet())->rememberedSetLimit));
		(GIV(scavengeLogRecord).sStatTenures = GIV(statTenures));
	}
	/* end logStartScavenge */
	/* begin strategizeToLimitRememberedSet */
	if ((GIV(tenureCriterion) == TenureByAge) && ((((getFromOldSpaceRememberedSet())->rememberedSetSize)) >= (((getFromOldSpaceRememberedSet())->rememberedSetRedZone)))) {
		GIV(tenureCriterion) = TenureToShrinkRT;
		computeRefCountToShrinkRememberedSet();
	}
	/* end strategizeToLimitRememberedSet */
	/* begin logTenuringPolicy */
	{
		(GIV(scavengeLogRecord).tTenureCriterion = GIV(tenureCriterion));
		(GIV(scavengeLogRecord).tTenureThreshold = (((GIV(tenureCriterion) == TenureByAge) && (GIV(tenureThreshold) > ((GIV(pastSpace).start))))
			 ? GIV(tenureThreshold) - ((GIV(pastSpace).start))
			 : 0));
		(GIV(scavengeLogRecord).tRefCountToShrinkRT = GIV(refCountToShrinkRT));
	}
	/* end logTenuringPolicy */
	scavengeLoop();
	processWeaklings();
	/* begin computeTenuringThreshold */
	if (futureSpaceIsFull()) {
		GIV(tenureThreshold) = (round((((GIV(futureSpace).limit)) - ((GIV(futureSpace).start))) * (1.0 - GIV(tenuringProportion)))) + ((GIV(futureSpace).start));
	} else {
		GIV(tenureThreshold) = 0;
	}
	/* end computeTenuringThreshold */
	/* begin exchangeSurvivorSpaces */
	_temp = GIV(pastSpace);
	GIV(pastSpace) = GIV(futureSpace);
	GIV(futureSpace) = _temp;
	/* end exchangeSurvivorSpaces */
	/* begin logEndScavenge */
	{
		(GIV(scavengeLogRecord).eSurvivorBytes = GIV(futureSurvivorStart) - ((GIV(pastSpace).start)));
		(GIV(scavengeLogRecord).eRememberedSetSize = ((getFromOldSpaceRememberedSet())->rememberedSetSize));
		(GIV(scavengeLogRecord).eStatTenures = GIV(statTenures));
	}
	/* end logEndScavenge */
	/* begin initFutureSpaceStart */
	_oldStart = GIV(futureSurvivorStart);
	GIV(futureSurvivorStart) = (GIV(futureSpace).start);
	GIV(pastSpaceStart) = _oldStart;
	/* end initFutureSpaceStart */
	/* end scavenge: */
	assert(oopisGreaterThanOrEqualToandLessThanOrEqualTo(GIV(pastSpaceStart), ((pastSpace()).start), ((pastSpace()).limit)));
	GIV(freeStart) = ((eden()).start);
	/* begin initSpaceForAllocationCheck:limit: */
	_aNewSpace = ((SpurNewSpaceSpace *) (&(eden())) );
	if (checkAllocFiller()) {
		for (_p = (_aNewSpace->start); _p < GIV(scavengeThreshold); _p += BytesPerWord) {
			longAtput(_p, _p);
		}
	}
	/* end initSpaceForAllocationCheck:limit: */
	GIV(gcPhaseInProgress) = 0;
	/* begin resetAllocationAccountingAfterGC */
	GIV(oldSpaceUsePriorToScavenge) = (GIV(totalHeapSizeIncludingBridges) - (GIV(numSegments) * (2 * BaseHeaderSize))) - GIV(totalFreeOldSpace);
	/* end resetAllocationAccountingAfterGC */
}
/* SpurMemoryManager>>#doValidateObjectMemory */
static sqInt
doValidateObjectMemory(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _aReference;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	sqInt _idx;
	sqInt _iLimit;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;
	sqInt _referent;
	int _returnCode;

	_returnCode = 1;
	/* begin allObjectsDo: */
	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop2 = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop2, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					_referent = unsignedLongAt((_objOop2 + BaseHeaderSize) + (0U << (shiftForWord())));
					if (!(addressCouldBeObj(_referent))) {
						logError("Error found in object at %p", ((void*) _objOop2 ));
						_returnCode = 0;
					}
				} else {
					for (_idx = 0, _iLimit = (numPointerSlotsOf(_objOop2)) - 1; _idx <= _iLimit; _idx += 1) {
						_aReference = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _idx ) << (shiftForWord())) ));
						if (!((_aReference & (tagMask())) || ((addressCouldBeObj(_aReference)) || ((_aReference >= ((GIV(memoryMap)->codeZoneStart))) && (_aReference < ((GIV(memoryMap)->codeZoneEnd))))))) {
							logError("Error found in object at %p", ((void*) _objOop2 ));
							_returnCode = 0;
						}
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l2;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l2:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop2 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					_referent = unsignedLongAt((_objOop2 + BaseHeaderSize) + (0U << (shiftForWord())));
					if (!(addressCouldBeObj(_referent))) {
						logError("Error found in object at %p", ((void*) _objOop2 ));
						_returnCode = 0;
					}
				} else {
					for (_idx = 0, _iLimit = (numPointerSlotsOf(_objOop2)) - 1; _idx <= _iLimit; _idx += 1) {
						_aReference = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _idx ) << (shiftForWord())) ));
						if (!((_aReference & (tagMask())) || ((addressCouldBeObj(_aReference)) || ((_aReference >= ((GIV(memoryMap)->codeZoneStart))) && (_aReference < ((GIV(memoryMap)->codeZoneEnd))))))) {
							logError("Error found in object at %p", ((void*) _objOop2 ));
							_returnCode = 0;
						}
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop2 = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	/* begin allOldSpaceObjectsDo: */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop22 = GIV(nilObj);
	while (1) {
		assert((_objOop22 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop22)) != 0);
		{
			if (isEnumerableObject(_objOop22)) {
				{
					if (((long64At(_objOop22)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
						_referent = unsignedLongAt((_objOop22 + BaseHeaderSize) + (0U << (shiftForWord())));
						if (!(addressCouldBeObj(_referent))) {
							logError("Error found in object at %p", ((void*) _objOop22 ));
							_returnCode = 0;
						}
					} else {
						for (_idx = 0, _iLimit = (numPointerSlotsOf(_objOop22)) - 1; _idx <= _iLimit; _idx += 1) {
							_aReference = unsignedLongAt((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) _idx ) << (shiftForWord())) ));
							if (!((_aReference & (tagMask())) || ((addressCouldBeObj(_aReference)) || ((_aReference >= ((GIV(memoryMap)->codeZoneStart))) && (_aReference < ((GIV(memoryMap)->codeZoneEnd))))))) {
								logError("Error found in object at %p", ((void*) _objOop22 ));
								_returnCode = 0;
							}
						}
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop22 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	/* end allOldSpaceObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (((long64At(_currentObject)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					_referent = unsignedLongAt((_currentObject + BaseHeaderSize) + (0U << (shiftForWord())));
					if (!(addressCouldBeObj(_referent))) {
						logError("Error found in object at %p", ((void*) _currentObject ));
						_returnCode = 0;
					}
				} else {
					for (_idx = 0, _iLimit = (numPointerSlotsOf(_currentObject)) - 1; _idx <= _iLimit; _idx += 1) {
						_aReference = unsignedLongAt((_currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) _idx ) << (shiftForWord())) ));
						if (!((_aReference & (tagMask())) || ((addressCouldBeObj(_aReference)) || ((_aReference >= ((GIV(memoryMap)->codeZoneStart))) && (_aReference < ((GIV(memoryMap)->codeZoneEnd))))))) {
							logError("Error found in object at %p", ((void*) _currentObject ));
							_returnCode = 0;
						}
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
	return _returnCode;
}
/*	Instantiate an instance of a compact class. ee stands for execution engine 
	and implies that this allocation will *NOT* cause a GC. N.B. the 
	instantiated object 
	IS NOT FILLED and must be completed before returning it to Smalltalk. 
	Since this 
	call is used in routines that do just that we are safe. Break this rule 
	and die in GC. 
	Result is guaranteed to be young. */
/* SpurMemoryManager>>#eeInstantiateClassIndex:format:numSlots: */
sqInt
eeInstantiateClassIndexformatnumSlots(sqInt _knownClassIndex, sqInt _objFormat, sqInt _numSlots)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	assert((_numSlots >= 0) && ((_knownClassIndex != 0) && ((knownClassAtIndex(_knownClassIndex)) != GIV(nilObj))));
	assert((((_objFormat < (firstByteFormat()))
		 ? _objFormat
		 : _objFormat & (byteFormatMask()))) == (instSpecOfClass(knownClassAtIndex(_knownClassIndex))));
	return allocateNewSpaceSlotsformatclassIndex(_numSlots, _objFormat, _knownClassIndex);
}
/*	Remove all the entries on the stack. Do so by setting Topx to 0 
	on the first page, and adding all subsequent pages to the free list. */
/* SpurMemoryManager>>#emptyObjStack: */
static void NoDbgRegParms
emptyObjStack(sqInt _objStack)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _nextNextPage;
	sqInt _nextPage;
	sqInt _thang;

	if (_objStack == GIV(nilObj)) {
		return;
	}
	eassert(isValidObjStack(_objStack));
	/* begin storePointer:ofObjStack:withValue: */
	assert((formatOf(_objStack)) == (wordIndexableFormat()));
	unsignedLongAtput((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ), 0);
	/* end storePointer:ofObjStack:withValue: */
	_nextPage = unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ));
	while (_nextPage != 0) {
		_nextNextPage = unsignedLongAt((_nextPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ));
		/* begin storePointer:ofObjStack:withValue: */
		_thang = unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) ));
		assert((formatOf(_nextPage)) == (wordIndexableFormat()));
		unsignedLongAtput((_nextPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) ), _thang);
		/* end storePointer:ofObjStack:withValue: */
		/* begin storePointer:ofObjStack:withValue: */
		assert((formatOf(_nextPage)) == (wordIndexableFormat()));
		unsignedLongAtput((_nextPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ), 0);
		/* end storePointer:ofObjStack:withValue: */
		/* begin storePointer:ofObjStack:withValue: */
		assert((formatOf(_objStack)) == (wordIndexableFormat()));
		unsignedLongAtput((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) ), _nextPage);
		/* end storePointer:ofObjStack:withValue: */
		_nextPage = _nextNextPage;
	}
	/* begin storePointer:ofObjStack:withValue: */
	assert((formatOf(_objStack)) == (wordIndexableFormat()));
	unsignedLongAtput((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ), 0);
	/* end storePointer:ofObjStack:withValue: */
	eassert(isValidObjStack(_objStack));
}
/*	An obj stack is a stack of objects stored in a hidden root slot, such as 
	the markStack or the ephemeronQueue. It is a linked list of segments, 
	with the hot end at the head of the list. It is a word object. The stack 
	pointer is in ObjStackTopx and 0 means empty. The list goes through 
	ObjStackNextx. We don't want to shrink objStacks, since they're used 
	in GC and its good to keep their memory around. So unused pages 
	created by popping emptying pages are kept on the ObjStackFreex list. */
/* SpurMemoryManager>>#ensureRoomOnObjStackAt: */
static sqInt NoDbgRegParms
ensureRoomOnObjStackAt(sqInt _objStackRootIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classIndex;
	sqInt _classIndex2;
	sqInt _formatField;
	sqInt _formatField2;
	sqInt _freeOrNewPage;
	sqInt _stackOrNil;
	sqInt _thang;

	_stackOrNil = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _objStackRootIndex ) << (shiftForWord())) ));
	if ((_stackOrNil == GIV(nilObj)) || ((unsignedLongAt((_stackOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ))) >= ObjStackLimit)) {
		if (_stackOrNil == GIV(nilObj)) {
			_freeOrNewPage = 0;
		} else {
			_freeOrNewPage = unsignedLongAt((_stackOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) ));
		}
		if (_freeOrNewPage != 0) {
			/* begin storePointer:ofObjStack:withValue: */
			assert((formatOf(_stackOrNil)) == (wordIndexableFormat()));
			unsignedLongAtput((_stackOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) ), 0);
			/* end storePointer:ofObjStack:withValue: */
			assert(!GIV(marking) || (isMarked(_freeOrNewPage)));
		} else {
			/* begin allocateSlotsInOldSpace:format:classIndex: */
			_formatField2 = sixtyFourBitIndexableFormat();
			_classIndex2 = sixtyFourBitLongsClassIndexPun();
			_freeOrNewPage = allocateSlotsInOldSpacebytesformatclassIndex(ObjStackPageSlots, ((sqInt) (((usqInt) ObjStackPageSlots ) << (shiftForWord())) ) + (BaseHeaderSize + BaseHeaderSize), _formatField2, _classIndex2);
			/* end allocateSlotsInOldSpace:format:classIndex: */
			if (!_freeOrNewPage) {
				growOldSpaceByAtLeastcallingOperation(ObjStackPageSlots, "ensuring room on ObjStack");
				/* begin allocateSlotsInOldSpace:format:classIndex: */
				_formatField = sixtyFourBitIndexableFormat();
				_classIndex = sixtyFourBitLongsClassIndexPun();
				_freeOrNewPage = allocateSlotsInOldSpacebytesformatclassIndex(ObjStackPageSlots, ((sqInt) (((usqInt) ObjStackPageSlots ) << (shiftForWord())) ) + (BaseHeaderSize + BaseHeaderSize), _formatField, _classIndex);
				/* end allocateSlotsInOldSpace:format:classIndex: */
				if (!_freeOrNewPage) {
					error("no memory to allocate or extend obj stack");
				}
			}
			/* begin storePointer:ofObjStack:withValue: */
			assert((formatOf(_freeOrNewPage)) == (wordIndexableFormat()));
			unsignedLongAtput((_freeOrNewPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) ), 0);
			/* end storePointer:ofObjStack:withValue: */
			if (GIV(marking)) {
				/* begin setIsMarkedOf:to: */
				assert(!(isFreeObject(_freeOrNewPage)));
				unsignedLongAtput(_freeOrNewPage, (unsignedLongAt(_freeOrNewPage)) | (1ULL << (markedBitFullShift())));
				/* end setIsMarkedOf:to: */
			}
		}
		{
			/* begin storePointer:ofObjStack:withValue: */
			assert((formatOf(_freeOrNewPage)) == (wordIndexableFormat()));
			unsignedLongAtput((_freeOrNewPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackMyx ) << (shiftForWord())) ), _objStackRootIndex);
			/* end storePointer:ofObjStack:withValue: */
			/* begin storePointer:ofObjStack:withValue: */
			_thang = ((_stackOrNil == GIV(nilObj))
				 ? 0
				 : _stackOrNil);
			assert((formatOf(_freeOrNewPage)) == (wordIndexableFormat()));
			unsignedLongAtput((_freeOrNewPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ), _thang);
			/* end storePointer:ofObjStack:withValue: */
			/* begin storePointer:ofObjStack:withValue: */
			assert((formatOf(_freeOrNewPage)) == (wordIndexableFormat()));
			unsignedLongAtput((_freeOrNewPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ), 0);
			/* end storePointer:ofObjStack:withValue: */
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(GIV(hiddenRootsObj))));
			if (((GIV(hiddenRootsObj) & (tagMask())) == 0) && ((GIV(hiddenRootsObj) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((_freeOrNewPage & (tagMask())) == 0) && (((_freeOrNewPage & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_freeOrNewPage >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(GIV(hiddenRootsObj))) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), GIV(hiddenRootsObj));
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(GIV(hiddenRootsObj))) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l9;
			}
			if (_freeOrNewPage & (tagMask())) {
				goto l9;
			}
			if (!(GIV(hiddenRootsObj) >= 0x20000000000LL)) {
				goto l9;
			}
			if (_freeOrNewPage >= 0x20000000000LL) {
				goto l9;
			}
			if ((_freeOrNewPage >= GIV(nilObj)) && (_freeOrNewPage <= GIV(trueObj))) {
				goto l9;
			}
			if (!(_freeOrNewPage >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l9;
			}
			remember(getFromPermToNewSpaceRememberedSet(), GIV(hiddenRootsObj));
			l9:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _objStackRootIndex ) << (shiftForWord())) ), _freeOrNewPage);
			/* end storePointer:ofObject:withValue: */
		}
		assert(isValidObjStackAt(_objStackRootIndex));
		/* begin updateRootOfObjStackAt:with: */
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(GIV(hiddenRootsObj))));
		if (((GIV(hiddenRootsObj) & (tagMask())) == 0) && ((GIV(hiddenRootsObj) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_freeOrNewPage & (tagMask())) == 0) && (((_freeOrNewPage & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_freeOrNewPage >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(GIV(hiddenRootsObj))) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), GIV(hiddenRootsObj));
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(GIV(hiddenRootsObj))) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l12;
		}
		if (_freeOrNewPage & (tagMask())) {
			goto l12;
		}
		if (!(GIV(hiddenRootsObj) >= 0x20000000000LL)) {
			goto l12;
		}
		if (_freeOrNewPage >= 0x20000000000LL) {
			goto l12;
		}
		if ((_freeOrNewPage >= GIV(nilObj)) && (_freeOrNewPage <= GIV(trueObj))) {
			goto l12;
		}
		if (!(_freeOrNewPage >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l12;
		}
		remember(getFromPermToNewSpaceRememberedSet(), GIV(hiddenRootsObj));
		l12:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _objStackRootIndex ) << (shiftForWord())) ), _freeOrNewPage);
		/* end storePointer:ofObject:withValue: */
		switch (_objStackRootIndex) {
			case MarkStackRootIndex:
			{
				GIV(markStack) = _freeOrNewPage;
			}
			break;
			case WeaklingStackRootIndex:
			{
				GIV(weaklingStack) = _freeOrNewPage;
			}
			break;
			case MournQueueRootIndex:
			{
				GIV(mournQueue) = _freeOrNewPage;
			}
			break;
			default:
			error("Case not found and no otherwise clause");
		}
		_stackOrNil = _freeOrNewPage;
		/* end updateRootOfObjStackAt:with: */
	}
	assert(isValidObjStackAt(_objStackRootIndex));
	return _stackOrNil;
}
/*	Enter aBehavior into the class table and answer 0. Otherwise answer a 
	primitive failure code. */
/* SpurMemoryManager>>#enterIntoClassTable: */
static sqInt NoDbgRegParms
enterIntoClassTable(sqInt _aBehavior)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classIndex;
	sqInt _hash;
	sqInt _i;
	sqInt _iLimit;
	sqInt _initialMajorIndex;
	sqInt _majorIndex;
	sqInt _minorIndex;
	sqInt _numSlots;
	sqInt _numSlots2;
	usqInt _p;
	sqInt _page;

	_majorIndex = ((usqInt) GIV(classTableIndex) ) >> (classTableMajorIndexShift());
	_initialMajorIndex = _majorIndex;
	assert(_initialMajorIndex > 0);
	_minorIndex = GIV(classTableIndex) & ((1U << (classTableMajorIndexShift())) - 1);
	while (1) {
		_page = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _majorIndex ) << (shiftForWord())) ));
		if (_page == GIV(nilObj)) {
			/* begin allocateSlotsInOldSpace:format:classIndex: */
			_numSlots = 1U << (classTableMajorIndexShift());
			_classIndex = arrayClassIndexPun();
			_page = allocateSlotsInOldSpacebytesformatclassIndex(_numSlots, ((_numSlots == 0)
				 ? 8 + BaseHeaderSize
				 : ((sqInt) (((usqInt) _numSlots ) << (shiftForWord())) ) + (((_numSlots >= (numSlotsMask()))
					 ? BaseHeaderSize + BaseHeaderSize
					 : BaseHeaderSize))), 2, _classIndex);
			/* end allocateSlotsInOldSpace:format:classIndex: */
			if (!_page) {
				return PrimErrNoMemory;
			}
			/* begin fillObj:numSlots:with: */
			_numSlots2 = 1U << (classTableMajorIndexShift());
			assert(oopisLessThan(((_page + BaseHeaderSize) + (_numSlots2 * BytesPerOop)) - 1, addressAfter(_page)));
			for (_p = ((usqInt) (_page + BaseHeaderSize) ); _p <= ((usqInt) (((_page + BaseHeaderSize) + (_numSlots2 * BytesPerOop)) - 1) ); _p += 8) {
				longAtput(_p, GIV(nilObj));
			}
			/* end fillObj:numSlots:with: */
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(GIV(hiddenRootsObj))));
			if (((GIV(hiddenRootsObj) & (tagMask())) == 0) && ((GIV(hiddenRootsObj) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((_page & (tagMask())) == 0) && (((_page & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_page >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(GIV(hiddenRootsObj))) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), GIV(hiddenRootsObj));
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(GIV(hiddenRootsObj))) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l3;
			}
			if (_page & (tagMask())) {
				goto l3;
			}
			if (!(GIV(hiddenRootsObj) >= 0x20000000000LL)) {
				goto l3;
			}
			if (_page >= 0x20000000000LL) {
				goto l3;
			}
			if ((_page >= GIV(nilObj)) && (_page <= GIV(trueObj))) {
				goto l3;
			}
			if (!(_page >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l3;
			}
			remember(getFromPermToNewSpaceRememberedSet(), GIV(hiddenRootsObj));
			l3:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _majorIndex ) << (shiftForWord())) ), _page);
			/* end storePointer:ofObject:withValue: */
			GIV(numClassTablePages) += 1;
			_minorIndex = 0;
		}
		for (_i = _minorIndex, _iLimit = (1U << (classTableMajorIndexShift())) - 1; _i <= _iLimit; _i += 1) {
			if ((unsignedLongAt((_page + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ))) == GIV(nilObj)) {
				GIV(classTableIndex) = ((sqInt) (((usqInt) _majorIndex ) << (classTableMajorIndexShift())) ) + _i;
				assert(GIV(classTableIndex) >= (1U << (classTableMajorIndexShift())));
				/* begin storePointer:ofObject:withValue: */
				assert(!(isForwarded(_page)));
				if (((_page & (tagMask())) == 0) && ((_page & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
					if (((_aBehavior & (tagMask())) == 0) && (((_aBehavior & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_aBehavior >= ((GIV(memoryMap)->newSpaceStart))))) {
						/* begin possibleOldObjectStoreInto: */
						if (!(((((usqInt) (long64At(_page)) ) >> (rememberedBitShift())) & 1) != 0)) {
							remember(GIV(fromOldSpaceRememberedSet), _page);
						}
						/* end possibleOldObjectStoreInto: */
					}
				}
				/* begin possiblePermObjectStoreInto:value: */
				if (((((usqInt) (long64At(_page)) ) >> (rememberedBitShift())) & 1) != 0) {
					goto l5;
				}
				if (_aBehavior & (tagMask())) {
					goto l5;
				}
				if (!(_page >= 0x20000000000LL)) {
					goto l5;
				}
				if (_aBehavior >= 0x20000000000LL) {
					goto l5;
				}
				if ((_aBehavior >= GIV(nilObj)) && (_aBehavior <= GIV(trueObj))) {
					goto l5;
				}
				if (!(_aBehavior >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l5;
				}
				remember(getFromPermToNewSpaceRememberedSet(), _page);
				l5:
				;
				/* end possiblePermObjectStoreInto:value: */
				unsignedLongAtput((_page + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _aBehavior);
				/* end storePointer:ofObject:withValue: */
				/* begin setHashBitsOf:to: */
				_hash = GIV(classTableIndex);
				assert((_hash >= 0) && (_hash <= (identityHashHalfWordMask())));
				uint32AtPointerput(_aBehavior + 4, (((uint32AtPointer(_aBehavior + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + _hash);
				/* end setHashBitsOf:to: */
				assert((classAtIndex(rawHashBitsOf(_aBehavior))) == _aBehavior);
				return 0;
			}
		}
		_majorIndex = ((((_majorIndex + 1) & (classIndexMask())) < 1) ? 1 : (_majorIndex + 1) & (classIndexMask()));
		if (_majorIndex == _initialMajorIndex) {
			return PrimErrLimitExceeded;
		}
	}
	return 0;
}
/* SpurMemoryManager>>#ephemeronFormat */
static sqInt
ephemeronFormat(void)
{
	return 5;
}
/* SpurMemoryManager>>#existInstancesInNewSpaceOf: */
static sqInt NoDbgRegParms
existInstancesInNewSpaceOf(sqInt _classObj)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _classIndex;
	sqInt _followingWord;
	sqInt _followingWord2;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _limit;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _prevObj;
	sqInt _prevPrevObj;

	_classIndex = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask());
	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop2 = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop2, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((longAt(_objOop2)) & (classIndexMask())) == _classIndex) {
					return 1;
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l2;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l2:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop2 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((longAt(_objOop2)) & (classIndexMask())) == _classIndex) {
					return 1;
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop2 = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	return 0;
}
/* SpurMemoryManager>>#falseObject */
sqInt
falseObject(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(falseObj);
}
/* SpurMemoryManager>>#fetchByte:ofObject: */
sqInt
fetchByteofObject(sqInt _byteIndex, sqInt _objOop)
{
	return byteAt((_objOop + BaseHeaderSize) + _byteIndex);
}
/* SpurMemoryManager>>#fetchClassOfNonImm: */
static sqInt NoDbgRegParms NeverInline
fetchClassOfNonImm(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classIndex;
	sqInt _classTablePage;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;

	/* begin classIndexOf: */
	_classIndex = (longAt(_objOop)) & (classIndexMask());
	/* end classIndexOf: */
	if (_classIndex <= (classIsItselfClassIndexPun())) {
		if (_classIndex == (classIsItselfClassIndexPun())) {
			return _objOop;
		}
		if (_classIndex == (isForwardedObjectClassIndexPun())) {
			return GIV(nilObj);
		}
	}
	assert(_classIndex >= (arrayClassIndexPun()));
	/* begin classOrNilAtIndex: */
	assert((_classIndex <= (tagMask())) || (_classIndex >= (arrayClassIndexPun())));
	/* begin fetchPointer:ofObject: */
	_fieldIndex = ((usqInt) _classIndex ) >> (classTableMajorIndexShift());
	_classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_classTablePage == GIV(nilObj)) {
		return GIV(nilObj);
	}
	/* begin fetchPointer:ofObject: */
	_fieldIndex2 = _classIndex & ((1U << (classTableMajorIndexShift())) - 1);
	return unsignedLongAt((_classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end classOrNilAtIndex: */
}
/*	In 64 bits the tagBits are fixed and never used for anything else. 
	Applying the tag has 3 different values 
	If the tagBits are 001, the oop is a SmallInteger. 
	If the tagBits are 010, the oop is a Character. 
	If the tagBits are 101, the oop is a SmallFloat. 
	Otherwise it's tagBits are 000, the oop is an address and we fetch the 
	class from the header 
	 
	In 32 bits, the tagBits are variable. 
	If the tagBits are X1, the oop is a SmallInteger, and using the tagMask 
	will return 1 or 3. 
	Therefore the SmallInteger class is installed in both indexes 1 and 3. 
	If the tagBits are 10, the oop is a character and the class is installed 
	in index 2. 
	Otherwise the last tagBits are 00, which is an address so we fetch the 
	class from the header. */
/* SpurMemoryManager>>#fetchClassOf: */
sqInt
fetchClassOf(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _tagBits;

	return ((((_tagBits = _oop & (tagMask()))) != 0)
		 ? unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) ))
		 : fetchClassOfNonImm(_oop));
}
/*	In Spur an object's classIndex is the tag in all method caches. */
/* SpurMemoryManager>>#fetchClassTagOfNonImm: */
static sqInt NoDbgRegParms
fetchClassTagOfNonImm(sqInt _obj)
{
	/* begin classIndexOf: */
	return (longAt(_obj)) & (classIndexMask());
	/* end classIndexOf: */
}
/* SpurMemoryManager>>#fetchFloat32:ofObject: */
static float NoDbgRegParms
fetchFloat32ofObject(sqInt _index, sqInt _objOop)
{
	return float32At((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << 2) ));
}
/* SpurMemoryManager>>#fetchFloat64:ofObject: */
static double NoDbgRegParms
fetchFloat64ofObject(sqInt _index, sqInt _objOop)
{
	return float64At((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << 3) ));
}
/*	index by 32-bit units, and return a 32-bit value. Intended to replace 
	fetchWord:ofObject:  */
/* SpurMemoryManager>>#fetchLong32:ofObject: */
sqInt
fetchLong32ofObject(sqInt _fieldIndex, sqInt _oop)
{
	return long32At((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << 2) ));
}
/* SpurMemoryManager>>#fetchPointer:ofFreeChunk: */
static sqInt NoDbgRegParms
fetchPointerofFreeChunk(sqInt _fieldIndex, sqInt _objOop)
{
	return unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
}
/* SpurMemoryManager>>#fetchPointer:ofObject: */
sqInt
fetchPointerofObject(sqInt _fieldIndex, sqInt _objOop)
{
	return unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
}
/*	Answer, but do not remove, the largest free chunk in the free tree. 
	For some reasons, free lists are not considered (why?) */
/* SpurMemoryManager>>#findLargestFreeChunk */
static sqInt
findLargestFreeChunk(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _childNode;
	sqInt _fieldIndex;
	sqInt _treeNode;

	_treeNode = GIV(freeLists)[0];
	if (_treeNode == 0) {
		return null;
	}
	while (1) {
		/* begin assertValidFreeObject: */
		assert(assertInnerValidFreeObject(_treeNode));
		/* end assertValidFreeObject: */
		assert((bytesInObject(_treeNode)) >= ((numFreeLists()) * (allocationUnit())));
		/* begin fetchPointer:ofFreeChunk: */
		_fieldIndex = 4;
		_childNode = unsignedLongAt((_treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofFreeChunk: */
		if (!(_childNode != 0)) 
			break;
		_treeNode = _childNode;
	}
	return _treeNode;
}
/*	Print the oops of all string-like things that start with the same 
	characters as aCString */
/* SpurMemoryManager>>#findStringBeginningWith: */
void
findStringBeginningWith(char *_aCString)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _cssz;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	_cssz = strlen(_aCString);
	/* begin allObjectsDo: */
	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop2 = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop2, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if ((((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())) && (((lengthOfformat(_objOop2, (((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask()))) >= _cssz) && ((strncmp(_aCString, pointerForOop(_objOop2 + BaseHeaderSize), _cssz)) == 0))) {
					{
						printHex(_objOop2);
						/* begin space */
						printChar(' ');
						/* end space */
						printNum(lengthOfformat(_objOop2, (((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())));
						/* begin space */
						printChar(' ');
						/* end space */
						printOopShort(_objOop2);
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop2 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if ((((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())) && (((lengthOfformat(_objOop2, (((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask()))) >= _cssz) && ((strncmp(_aCString, pointerForOop(_objOop2 + BaseHeaderSize), _cssz)) == 0))) {
					{
						printHex(_objOop2);
						/* begin space */
						printChar(' ');
						/* end space */
						printNum(lengthOfformat(_objOop2, (((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())));
						/* begin space */
						printChar(' ');
						/* end space */
						printOopShort(_objOop2);
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop2 = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	/* begin allOldSpaceObjectsDo: */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop22 = GIV(nilObj);
	while (1) {
		assert((_objOop22 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop22)) != 0);
		{
			if (isEnumerableObject(_objOop22)) {
				{
					if ((((((usqInt) (longAt(_objOop22)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())) && (((lengthOfformat(_objOop22, (((usqInt) (longAt(_objOop22)) ) >> (formatShift())) & (formatMask()))) >= _cssz) && ((strncmp(_aCString, pointerForOop(_objOop22 + BaseHeaderSize), _cssz)) == 0))) {
						{
							printHex(_objOop22);
							/* begin space */
							printChar(' ');
							/* end space */
							printNum(lengthOfformat(_objOop22, (((usqInt) (longAt(_objOop22)) ) >> (formatShift())) & (formatMask())));
							/* begin space */
							printChar(' ');
							/* end space */
							printOopShort(_objOop22);
							/* begin cr */
							print("\n");
							/* end cr */
						}
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop22 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	/* end allOldSpaceObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if ((((((usqInt) (longAt(_currentObject)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())) && (((lengthOfformat(_currentObject, (((usqInt) (longAt(_currentObject)) ) >> (formatShift())) & (formatMask()))) >= _cssz) && ((strncmp(_aCString, pointerForOop(_currentObject + BaseHeaderSize), _cssz)) == 0))) {
					{
						printHex(_currentObject);
						/* begin space */
						printChar(' ');
						/* end space */
						printNum(lengthOfformat(_currentObject, (((usqInt) (longAt(_currentObject)) ) >> (formatShift())) & (formatMask())));
						/* begin space */
						printChar(' ');
						/* end space */
						printOopShort(_currentObject);
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
}
/*	Print the oops of all string-like things that have the same characters as 
	aCString  */
/* SpurMemoryManager>>#findString: */
void
findString(char *_aCString)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _cssz;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	_cssz = strlen(_aCString);
	/* begin allObjectsDo: */
	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop2 = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop2, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if ((((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())) && (((lengthOfformat(_objOop2, (((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask()))) == _cssz) && ((strncmp(_aCString, pointerForOop(_objOop2 + BaseHeaderSize), _cssz)) == 0))) {
					{
						printHex(_objOop2);
						/* begin space */
						printChar(' ');
						/* end space */
						printOopShort(_objOop2);
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop2 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if ((((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())) && (((lengthOfformat(_objOop2, (((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask()))) == _cssz) && ((strncmp(_aCString, pointerForOop(_objOop2 + BaseHeaderSize), _cssz)) == 0))) {
					{
						printHex(_objOop2);
						/* begin space */
						printChar(' ');
						/* end space */
						printOopShort(_objOop2);
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop2 = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	/* begin allOldSpaceObjectsDo: */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop22 = GIV(nilObj);
	while (1) {
		assert((_objOop22 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop22)) != 0);
		{
			if (isEnumerableObject(_objOop22)) {
				{
					if ((((((usqInt) (longAt(_objOop22)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())) && (((lengthOfformat(_objOop22, (((usqInt) (longAt(_objOop22)) ) >> (formatShift())) & (formatMask()))) == _cssz) && ((strncmp(_aCString, pointerForOop(_objOop22 + BaseHeaderSize), _cssz)) == 0))) {
						{
							printHex(_objOop22);
							/* begin space */
							printChar(' ');
							/* end space */
							printOopShort(_objOop22);
							/* begin cr */
							print("\n");
							/* end cr */
						}
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop22 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	/* end allOldSpaceObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if ((((((usqInt) (longAt(_currentObject)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())) && (((lengthOfformat(_currentObject, (((usqInt) (longAt(_currentObject)) ) >> (formatShift())) & (formatMask()))) == _cssz) && ((strncmp(_aCString, pointerForOop(_currentObject + BaseHeaderSize), _cssz)) == 0))) {
					{
						printHex(_currentObject);
						/* begin space */
						printChar(' ');
						/* end space */
						printOopShort(_currentObject);
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
}
/* SpurMemoryManager>>#firstAccessibleObject */
static sqInt
firstAccessibleObject(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _savedTenuringThreshold;
	sqInt _threshold;

	assert(GIV(nilObj) == ((GIV(memoryMap)->oldSpaceStart)));
	/* begin flushNewSpace */
	/* begin getRawTenuringThreshold */
	_savedTenuringThreshold = GIV(tenureThreshold);
	/* end getRawTenuringThreshold */
	/* begin setRawTenuringThreshold: */
	_threshold = ((sqInt) ((GIV(memoryMap)->newSpaceEnd)) );
	GIV(tenureThreshold) = _threshold;
	/* end setRawTenuringThreshold: */
	scavengingGCTenuringIf(TenureByAge);
	/* begin setRawTenuringThreshold: */
	GIV(tenureThreshold) = _savedTenuringThreshold;
	/* end setRawTenuringThreshold: */
	assert(((GIV(fromOldSpaceRememberedSet)->rememberedSetSize)) == 0);
	assert(GIV(pastSpaceStart) == (((pastSpace()).start)));
	assert(GIV(freeStart) == (((eden()).start)));
	/* end flushNewSpace */
	return GIV(nilObj);
}
/* SpurMemoryManager>>#firstBytePointerOfDataObject: */
void *
firstBytePointerOfDataObject(sqInt _objOop)
{
	sqInt _fmt;

	_fmt = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		return 0;
	}
	/* begin firstFixedField: */
	return pointerForOop(_objOop + BaseHeaderSize);
	/* end firstFixedField: */
}
/*	for the message send breakpoint; selectors can be immediates. */
/* SpurMemoryManager>>#firstFixedFieldOfMaybeImmediate: */
static void * NoDbgRegParms
firstFixedFieldOfMaybeImmediate(sqInt _oop)
{
	return ((_oop & (tagMask()))
		 ? ((void *) _oop )
		 : (/* begin firstFixedField: */ pointerForOop(_oop + BaseHeaderSize) /* end firstFixedField: */));
}
/* SpurMemoryManager>>#firstFixedField: */
void *
firstFixedField(sqInt _objOop)
{
	return pointerForOop(_objOop + BaseHeaderSize);
}
/*	NOTE: overridden in various simulator subclasses to add coercion to 
	CArray, so please duplicate any changes. 
	There are only two important cases, both for objects with named inst vars, 
	i.e. formats 2,3 & 5. 
	The first indexable field for formats 2 & 5 is the slot count (by 
	convention, even though that's off the end 
	of the object). For 3 we must go to the class. */
/* SpurMemoryManager>>#firstIndexableField: */
void *
firstIndexableField(sqInt _objOop)
{
	sqInt _classFormat;
	sqInt _classPointer;
	sqInt _fmt;

	_fmt = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	if (_fmt <= (weakArrayFormat())) {
		if (_fmt == 2) {
			return pointerForOop(_objOop + BaseHeaderSize);
		}
		if (_fmt >= (indexablePointersFormat())) {
			/* begin formatOfClass: */
			_classPointer = fetchClassOfNonImm(_objOop);
			_classFormat = (unsignedLongAt((_classPointer + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
			/* end formatOfClass: */
			return pointerForOop((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (_classFormat & ((1U << (fixedFieldsFieldWidth())) - 1)) ) << (shiftForWord())) ));
		}
		return 0;
	}
	if ((_fmt >= (sixtyFourBitIndexableFormat())) && (_fmt < (firstCompiledMethodFormat()))) {
		return pointerForOop(_objOop + BaseHeaderSize);
	}
	return 0;
}
/* SpurMemoryManager>>#fixedFieldsOfClassFormatMask */
sqInt
fixedFieldsOfClassFormatMask(void)
{
	return (1U << (fixedFieldsFieldWidth())) - 1;
}
/* SpurMemoryManager>>#fixedFieldsOfClassFormat: */
sqInt
fixedFieldsOfClassFormat(sqInt _classFormat)
{
	return _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
}
/* SpurMemoryManager>>#fixedFieldsOfClass: */
static sqInt NoDbgRegParms
fixedFieldsOfClass(sqInt _objOop)
{
	sqInt _classFormat;

	/* begin fixedFieldsOfClassFormat: */
	_classFormat = (unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	return _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	/* end fixedFieldsOfClassFormat: */
}
/* SpurMemoryManager>>#fixedFieldsOf:format:length: */
static sqInt NoDbgRegParms
fixedFieldsOfformatlength(sqInt _objOop, sqInt _fmt, sqInt _wordLength)
{
	sqInt _class;
	sqInt _classFormat;

	if ((_fmt >= (sixtyFourBitIndexableFormat())) || (_fmt == 2)) {
		return 0;
	}
	if (_fmt < 2) {
		return _wordLength;
	}
	_class = fetchClassOfNonImm(_objOop);
	/* begin fixedFieldsOfClassFormat: */
	_classFormat = (unsignedLongAt((_class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	return _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	/* end fixedFieldsOfClassFormat: */
}
/*	Private helper for followField:ofObject: to avoid code duplication for 
	rare case. */
/* SpurMemoryManager>>#fixFollowedField:ofObject:withInitialValue: */
static sqInt NoDbgRegParms NeverInline
fixFollowedFieldofObjectwithInitialValue(sqInt _fieldIndex, sqInt _anObject, sqInt _initialValue)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _objOop;

	assert(isOopForwarded(_initialValue));
	_objOop = _initialValue;
	do {
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_objOop = unsignedLongAt((_objOop + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
	} while (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0));
	/* begin storePointer:ofObject:withValue: */
	assert(!(isForwarded(_anObject)));
	if (((_anObject & (tagMask())) == 0) && ((_anObject & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((_objOop & (tagMask())) == 0) && (((_objOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_objOop >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_anObject)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _anObject);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(_anObject)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l3;
	}
	if (_objOop & (tagMask())) {
		goto l3;
	}
	if (!(_anObject >= 0x20000000000LL)) {
		goto l3;
	}
	if (_objOop >= 0x20000000000LL) {
		goto l3;
	}
	if ((_objOop >= GIV(nilObj)) && (_objOop <= GIV(trueObj))) {
		goto l3;
	}
	if (!(_objOop >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l3;
	}
	remember(getFromPermToNewSpaceRememberedSet(), _anObject);
	l3:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((_anObject + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ), _objOop);
	/* end storePointer:ofObject:withValue: */
	return _objOop;
}
/*	Make sure the oop at fieldIndex in anObject is not forwarded (follow the 
	forwarder there-in if so). Answer the (possibly followed) oop at 
	fieldIndex.  */
/* SpurMemoryManager>>#followField:ofObject: */
static sqInt NoDbgRegParms
followFieldofObject(sqInt _fieldIndex, sqInt _anObject)
{
	sqInt _objOop;

	/* begin fetchPointer:ofObject: */
	_objOop = unsignedLongAt((_anObject + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		_objOop = fixFollowedFieldofObjectwithInitialValue(_fieldIndex, _anObject, _objOop);
	}
	return _objOop;
}
/*	Follow pointers in the object to depth. 
	Answer if any forwarders were found. 
	How to avoid cyclic structures?? A temproary mark bit? */
/* SpurMemoryManager>>#followForwardedObjectFields:toDepth: */
sqInt
followForwardedObjectFieldstoDepth(sqInt _objOop, sqInt _depth)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	int _found;
	sqInt _i;
	sqInt _iLimit;
	sqInt _oop;
	sqInt _referent;

	_found = 0;
	assert((isPointers(_objOop)) || (isOopCompiledMethod(_objOop)));
	for (_i = 0, _iLimit = (numPointerSlotsOf(_objOop)) - 1; _i <= _iLimit; _i += 1) {
		/* begin fetchPointer:ofObject: */
		_oop = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if ((_oop & (tagMask())) == 0) {
			if (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
				_found = 1;
				/* begin followForwarded: */
				assert(isUnambiguouslyForwarder(_oop));
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent = unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
				while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
				}
				_oop = _referent;
				/* end followForwarded: */
				/* begin storePointer:ofObject:withValue: */
				assert(!(isForwarded(_objOop)));
				if (((_objOop & (tagMask())) == 0) && ((_objOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
					if (((_oop & (tagMask())) == 0) && (((_oop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_oop >= ((GIV(memoryMap)->newSpaceStart))))) {
						/* begin possibleOldObjectStoreInto: */
						if (!(((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0)) {
							remember(GIV(fromOldSpaceRememberedSet), _objOop);
						}
						/* end possibleOldObjectStoreInto: */
					}
				}
				/* begin possiblePermObjectStoreInto:value: */
				if (((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0) {
					goto l6;
				}
				if (_oop & (tagMask())) {
					goto l6;
				}
				if (!(_objOop >= 0x20000000000LL)) {
					goto l6;
				}
				if (_oop >= 0x20000000000LL) {
					goto l6;
				}
				if ((_oop >= GIV(nilObj)) && (_oop <= GIV(trueObj))) {
					goto l6;
				}
				if (!(_oop >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l6;
				}
				remember(getFromPermToNewSpaceRememberedSet(), _objOop);
				l6:
				;
				/* end possiblePermObjectStoreInto:value: */
				unsignedLongAtput((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _oop);
				/* end storePointer:ofObject:withValue: */
			}
			if ((_depth > 0) && ((((_oop & (tagMask())) == 0) && (isAnyPointerFormat((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())))) && (followForwardedObjectFieldstoDepth(_oop, _depth - 1)))) {
				_found = 1;
			}
		}
	}
	return _found;
}
/*	Follow a forwarding pointer. THis must be a loop because we cannot prevent 
	forwarders to 
	forwarders being created by lazy become. Consider the following example by 
	Igor Stasenko: 
	array := { a. b. c }. 
	- array at: 1 points to &a. array at: 2 points to &b. array at: 3 points 
	to &c 
	a becomeForward: b 
	- array at: 1 still points to &a. array at: 2 still points to &b. array 
	at: 3 still points to &c 
	b becomeForward: c. 
	- array at: 1 still points to &a. array at: 2 still points to &b. array 
	at: 3 still points to &c 
	- when accessing array first one has to follow a forwarding chain: 
	&a -> &b -> c */
/* SpurMemoryManager>>#followForwarded: */
sqInt
followForwarded(sqInt _objOop)
{
	sqInt _referent;

	assert(isUnambiguouslyForwarder(_objOop));
	/* begin fetchPointer:ofMaybeForwardedObject: */
	_referent = unsignedLongAt((_objOop + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofMaybeForwardedObject: */
	while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
	}
	return _referent;
}
/*	like formatOfClass: but check the existence of the format. 
	return -1 there is no format or a non integer format */
/* SpurMemoryManager>>#formatOfClassSafe: */
sqInt
formatOfClassSafe(sqInt _oop)
{
	sqInt _classFormat;
	sqInt _classObj;

	_classObj = ((((_oop & (tagMask())) == 0) && (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))
		 ? noInlineFollowForwarded(_oop)
		 : _oop);
	if (!((_classObj & (tagMask())) == 0)) {
		return -1;
	}
	if (!((numSlotsOfAny(_classObj)) >= InstanceSpecificationIndex)) {
		return -1;
	}
	/* begin fetchPointer:ofObject: */
	_classFormat = unsignedLongAt((_classObj + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (!(((_classFormat & 7) == 1))) {
		return -1;
	}
	return _classFormat >> 3;
}
/* SpurMemoryManager>>#formatOfClass: */
sqInt
formatOfClass(sqInt _classPointer)
{
	return (unsignedLongAt((_classPointer + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
}
/*	0 = 0 sized objects (UndefinedObject True False et al) 
	1 = non-indexable objects with inst vars (Point et al) 
	2 = indexable objects with no inst vars (Array et al) 
	3 = indexable objects with inst vars (MethodContext AdditionalMethodState 
	et al) 
	4 = weak indexable objects with inst vars (WeakArray et al) 
	5 = weak non-indexable objects with inst vars (ephemerons) (Ephemeron) 
	6 unused, reserved for exotic pointer objects? 
	7 Forwarded Object, 1st field is pointer, rest of fields are ignored 
	8 unused, reserved for exotic non-pointer objects? 
	9 64-bit indexable 
	10 - 11 32-bit indexable	(11 unused in 32 bits) 
	12 - 15 16-bit indexable	(14 & 15 unused in 32-bits) 
	16 - 23 byte indexable		(20-23 unused in 32-bits) 
	24 - 31 compiled method	(28-31 unused in 32-bits)A note on performance. Since the format field is, by design, aligned on a 
	byte boundary 
	in the fourth byte of the header we could access it via 
	^(self byteAt: objOop + 3) bitAnd: self formatMask 
	but al least on e.g. Core i7 x86-64 using the clang 6 compiler, this makes 
	no difference, 
	or at least any change is in the noise. */
/* SpurMemoryManager>>#formatOf: */
static sqInt NoDbgRegParms
formatOf(sqInt _objOop)
{
	return (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
}
/*	A special format used by the GC to follow only the first pointer. */
/* SpurMemoryManager>>#forwardedFormat */
static sqInt
forwardedFormat(void)
{
	return 7;
}
/*	for linking objecs on each free list, or, during pigCompact, doubly- 
	linking the free objects in address order using the xor link hack. */
/* SpurMemoryManager>>#freeChunkNextIndex */
static sqInt
freeChunkNextIndex(void)
{
	return 0;
}
/*	for organizing the tree of large free chunks. */
/* SpurMemoryManager>>#freeChunkParentIndex */
static sqInt
freeChunkParentIndex(void)
{
	return 2;
}
/*	For linking objecs on each free list, doubly-linking the free objects. 
	Free chunks of size 1 do not have a prev index. */
/* SpurMemoryManager>>#freeChunkPrevIndex */
static sqInt
freeChunkPrevIndex(void)
{
	return 1;
}
/* SpurMemoryManager>>#freeChunkWithBytes:at: */
static sqInt NoDbgRegParms
freeChunkWithBytesat(sqInt _bytes, sqInt _address)
{
	sqInt _freeChunk;

	assert(isInOldSpace(_address));
	assert((segmentContainingObj(_address)) == (segmentContainingObj(_address + _bytes)));
	_freeChunk = initFreeChunkWithBytesat(_bytes, _address);
	addToFreeListbytes(_freeChunk, _bytes);
	assert(_freeChunk == (objectStartingAt(_address)));
	return _freeChunk;
}
/*	Free an object in oldSpace. 
	DO NOT Coalesce, so original objOop remains valid. This could be useful if 
	you (or some iterator) reuse it. */
/* SpurMemoryManager>>#freeObjectWithoutCoalesce: */
sqInt
freeObjectWithoutCoalesce(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _bytes;
	usqInt _start;

	assert(isInOldSpace(_objOop));
	if (((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0) {
		forgetObject(getFromOldSpaceRememberedSet(), _objOop);
	}
	_bytes = bytesInObject(_objOop);
	_start = (((byteAt(_objOop + 7)) == (numSlotsMask()))
		 ? _objOop - BaseHeaderSize
		 : _objOop);
	GIV(totalFreeOldSpace) += _bytes;
	return freeChunkWithBytesat(_bytes, _start);
}
/*	Free an object in oldSpace. Coalesce if possible to reduce fragmentation. 
	Warning: because of coalescion, the original objOop can become an invalid 
	entity pointer. 
	See freeObjectWithoutCoalesce: for a safer version */
/* SpurMemoryManager>>#freeObject: */
sqInt
freeObject(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	usqInt _bytes;
	usqInt _chunkBytes;
	sqInt _next;
	usqInt _numSlots;
	usqInt _start;

	assert(isInOldSpace(_objOop));
	if (((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0) {
		forgetObject(GIV(fromOldSpaceRememberedSet), _objOop);
	}
	_bytes = bytesInObject(_objOop);
	_start = (((byteAt(_objOop + 7)) == (numSlotsMask()))
		 ? _objOop - BaseHeaderSize
		 : _objOop);
	/* begin objectStartingAt: */
	_address = _start + _bytes;
	_numSlots = byteAt(_address + 7);
	_next = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	if (((longAt(_next)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
		/* begin detachFreeObject: */
		_chunkBytes = bytesInObject(_next);
		GIV(totalFreeOldSpace) -= _chunkBytes;
		unlinkFreeChunkchunkBytes(_next, _chunkBytes);
		/* end detachFreeObject: */
		_bytes += bytesInObject(_next);
	}
	GIV(totalFreeOldSpace) += _bytes;
	return freeChunkWithBytesat(_bytes, _start);
}
/*	Free an object in PermSpace. Coalesce if possible to reduce fragmentation. 
	Warning: because of coalescion, the original objOop can become an invalid 
	entity pointer. We assume the objects are not in the remembered sets */
/* SpurMemoryManager>>#freePermObject: */
sqInt
freePermObject(sqInt _objOop)
{
	sqInt _address;
	usqInt _bytes;
	sqInt _next;
	usqInt _numSlots;
	usqInt _start;

	assert(isPermanent(_objOop));
	assert(!(isInRememberedSet(getFromPermToOldSpaceRememberedSet(), _objOop)));
	assert(!(isInRememberedSet(getFromPermToNewSpaceRememberedSet(), _objOop)));
	_bytes = bytesInObject(_objOop);
	_start = (((byteAt(_objOop + 7)) == (numSlotsMask()))
		 ? _objOop - BaseHeaderSize
		 : _objOop);
	/* begin objectStartingAt: */
	_address = _start + _bytes;
	_numSlots = byteAt(_address + 7);
	_next = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	if (((longAt(_next)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
		_bytes += bytesInObject(_next);
	}
	return initFreeChunkWithBytesat(_bytes, _start);
}
/*	Perform a full eager compacting GC. Answer the size of the largest free 
	chunk. for profiling */
/* SpurMemoryManager>>#fullGC */
usqLong NeverInline
fullGC(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong compactionStartUsecs;
	usqLong gcMarkEndUsecs;
	VMRememberedSet * self_in_removeObjectAt;
	sqInt _address;
	sqInt _aValue;
	sqInt _i;
	int _index;
	sqLong _newRememberedSetSize;
	usqInt _numSlots;
	sqInt _obj;
	sqInt _objOop;
	sqInt _segIndex;

	GIV(needGCFlag) = 0;
	GIV(gcStartUsecs) = ioUTCMicrosecondsNow();
	GIV(statMarkCount) = 0;
	preGCAction(GCModeFull);
	/* begin globalGarbageCollect */
	assert(validObjStacks());
	assert(isEmptyObjStack(GIV(markStack)));
	assert(isEmptyObjStack(GIV(weaklingStack)));
	markObjects(1);
	gcMarkEndUsecs = ioUTCMicrosecondsNow();
	/* begin forgetUnmarkedRememberedObjectsFromOldSpace */
	_index = 0;
	while (_index < (((getFromOldSpaceRememberedSet())->rememberedSetSize))) {
		_obj = ((getFromOldSpaceRememberedSet())->rememberedSetArray)[_index];
		if (((((usqInt) (longAt(_obj)) ) >> (markedBitFullShift())) & 1) != 0) {
			_index += 1;
		} else {
			/* begin setIsRememberedOf:to: */
			/* begin unsignedLong64At:put: */
			_aValue = (uint64AtPointer(_obj)) & (~((usqIntptr_t) (1U << (rememberedBitShift())) ));
			uint64AtPointerput(_obj, _aValue);
			/* end unsignedLong64At:put: */
			/* end setIsRememberedOf:to: */
			/* begin removeObjectAt: */
			/* begin getFromOldSpaceRememberedSet */
			self_in_removeObjectAt = GIV(fromOldSpaceRememberedSet);
			/* end getFromOldSpaceRememberedSet */
			_newRememberedSetSize = ((self_in_removeObjectAt->rememberedSetSize)) - 1;
			(self_in_removeObjectAt->rememberedSetArray)[_index] = (self_in_removeObjectAt->rememberedSetArray)[_newRememberedSetSize];
			/* begin setRememberedSetSize: */
			(self_in_removeObjectAt->rememberedSetSize) = _newRememberedSetSize;
			if (_newRememberedSetSize < ((self_in_removeObjectAt->rememberedSetLimit))) {
				(self_in_removeObjectAt->rememberedSetArray)[_newRememberedSetSize] = 0;
			}
			/* end setRememberedSetSize: */
			/* end removeObjectAt: */
		}
	}
	assert((((getFromOldSpaceRememberedSet())->rememberedSetSize)) >= 0);
	/* end forgetUnmarkedRememberedObjectsFromOldSpace */
	doScavenge(MarkOnTenure);
	runLeakCheckerForexcludeUnmarkedObjsclassIndicesShouldBeValid(GCModeFull, 1, 1);
	compactionStartUsecs = ioUTCMicrosecondsNow();
	/* begin prepareForGlobalSweep */
	GIV(sweepIndex) = 0;
	for (_i = 0; _i < GIV(numSegments); _i += 1) {
		((GIV(segments)[_i]).containsPinned = 0);
	}
	/* begin setIsMarkedOf:to: */
	/* begin bridgeAt: */
	_segIndex = GIV(numSegments) - 1;
	/* begin objectStartingAt: */
	_address = ((((&(GIV(segments)[_segIndex]))->segSize)) + (((&(GIV(segments)[_segIndex]))->segStart))) - (2 * BaseHeaderSize);
	_numSlots = byteAt(_address + 7);
	_objOop = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	/* end bridgeAt: */
	assert(!(isFreeObject(_objOop)));
	unsignedLongAtput(_objOop, (unsignedLongAt(_objOop)) | (1ULL << (markedBitFullShift())));
	/* end setIsMarkedOf:to: */
	/* end prepareForGlobalSweep */
	compact();
	/* begin attemptToShrink */
	if ((GIV(totalFreeOldSpace) > GIV(shrinkThreshold)) && ((GIV(totalFreeOldSpace) > GIV(growHeadroom)) && (shrinkObjectMemory((((GIV(totalFreeOldSpace) - GIV(growHeadroom)) < GIV(growHeadroom)) ? GIV(growHeadroom) : GIV(totalFreeOldSpace) - GIV(growHeadroom)))))) {
		GIV(statShrinkMemory) += 1;
	}
	/* end attemptToShrink */
	/* begin setHeapSizeAtPreviousGC */
	GIV(heapSizeAtPreviousGC) = (GIV(totalHeapSizeIncludingBridges) - (GIV(numSegments) * (2 * BaseHeaderSize))) - GIV(totalFreeOldSpace);
	/* begin resetAllocationAccountingAfterGC */
	GIV(oldSpaceUsePriorToScavenge) = (GIV(totalHeapSizeIncludingBridges) - (GIV(numSegments) * (2 * BaseHeaderSize))) - GIV(totalFreeOldSpace);
	/* end resetAllocationAccountingAfterGC */
	/* end setHeapSizeAtPreviousGC */
	assert(validObjStacks());
	assert(isEmptyObjStack(GIV(markStack)));
	assert(isEmptyObjStack(GIV(weaklingStack)));
	assert(allObjectsUnmarked());
	runLeakCheckerFor(GCModeFull);
	/* end globalGarbageCollect */
	postGCAction(GCModeFull);
	GIV(statGCEndUsecs) = ioUTCMicrosecondsNow();
	/* begin updateFullGCStats */
	GIV(statFullGCs) += 1;
	GIV(statFullGCUsecs) += GIV(statGCEndUsecs) - GIV(gcStartUsecs);
	GIV(statCompactionUsecs) += GIV(statGCEndUsecs) - compactionStartUsecs;
	if (!(GIV(gcSweepEndUsecs) == 0)) {
		GIV(statSweepUsecs) += GIV(gcSweepEndUsecs) - compactionStartUsecs;
	}
	GIV(statMarkUsecs) += gcMarkEndUsecs - GIV(gcStartUsecs);
	/* end updateFullGCStats */
	return (((GIV(freeLists)[0]) != 0)
		 ? bytesInObject(findLargestFreeChunk())
		 : 0);
}
/* SpurMemoryManager>>#getAvoidSearchingSegmentsWithPinnedObjects */
sqInt
getAvoidSearchingSegmentsWithPinnedObjects(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(avoidSearchingSegmentsWithPinnedObjects);
}
/* SpurMemoryManager>>#getFromOldSpaceRememberedSet */
VMRememberedSet *
getFromOldSpaceRememberedSet(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(fromOldSpaceRememberedSet);
}
/* SpurMemoryManager>>#getFromPermToNewSpaceRememberedSet */
VMRememberedSet *
getFromPermToNewSpaceRememberedSet(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(fromPermToNewSpaceRememberedSet);
}
/* SpurMemoryManager>>#getFromPermToOldSpaceRememberedSet */
VMRememberedSet *
getFromPermToOldSpaceRememberedSet(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(fromPermToOldSpaceRememberedSet);
}
/* SpurMemoryManager>>#getHeapGrowthToSizeGCRatio */
static float
getHeapGrowthToSizeGCRatio(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(heapGrowthToSizeGCRatio);
}
/* SpurMemoryManager>>#getMaxOldSpaceSize */
usqInt
getMaxOldSpaceSize(void)
{
	return maxOldSpaceSize;
}
/* SpurMemoryManager>>#getMemoryMap */
VMMemoryMap *
getMemoryMap(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(memoryMap);
}
/* SpurMemoryManager>>#goodContextSize: */
static sqInt NoDbgRegParms
goodContextSize(sqInt _oop)
{
	usqInt _numSlots;
	usqInt _numSlots2;

	/* begin numSlotsOf: */
	assert((classIndexOf(_oop)) > (isForwardedObjectClassIndexPun()));
	_numSlots2 = byteAt(_oop + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_oop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOf: */
	return (_numSlots == SmallContextSlots) || (_numSlots == LargeContextSlots);
}
/*	Attempt to grow memory by at least minAmmount bytes. 
	Answer the size of the new segment in bytes, or nil if the attempt failed. */
/* SpurMemoryManager>>#growOldSpaceByAtLeast:callingOperation: */
static size_t NoDbgRegParms
growOldSpaceByAtLeastcallingOperation(sqInt _minAmmount, char *_aString)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _ammount;
	sqInt _anInteger;
	sqInt _bytes;
	sqInt _freeChunk;
	sqInt _headroom;
	sqInt _i;
	sqInt _interval;
	SpurSegmentInfo *_segInfo;
	sqInt _start;
	usqInt _total;
	usqInt _total2;

	GIV(statGrowMemory) += 1;
	_ammount = _minAmmount + ((BaseHeaderSize * 2) + (2 * BaseHeaderSize));
	_ammount = 1ULL << (highBit(_ammount - 1));
	_ammount = ((_ammount < GIV(growHeadroom)) ? GIV(growHeadroom) : _ammount);
	if (maxOldSpaceSize > 0) {
		/* begin totalBytesInSegments */
		_total2 = 0;
		for (_i = 0; _i < GIV(numSegments); _i += 1) {
			_total2 += ((GIV(segments)[_i]).segSize);
		}
		assert(GIV(totalHeapSizeIncludingBridges) == _total2);
		_total = _total2;
		/* end totalBytesInSegments */
		if (_total >= maxOldSpaceSize) {
			logError("Could not allocate more memory while %s. MaxOldSpaceSize reached.", _aString);
			return null;
		}
		_headroom = maxOldSpaceSize - _total;
		if (_headroom < _ammount) {
			if (_headroom < (_minAmmount + ((BaseHeaderSize * 2) + (2 * BaseHeaderSize)))) {
				logError("Required space is bigger than the headroom while %s. Could not allocate", _aString);
				return null;
			}
			_ammount = _headroom;
		}
	}
	_start = ioUTCMicrosecondsNow();
	{
		_segInfo = addSegmentOfSize(_ammount);
		if (_segInfo == null) {
			return 0;
		} else {
			/* begin assimilateNewSegment: */
			if ((((_segInfo->segSize)) + ((_segInfo->segStart))) >= ((GIV(memoryMap)->oldSpaceEnd))) {
				/* begin setOldSpaceEnd: */
				_anInteger = (GIV(freeOldSpaceStart) = (((_segInfo->segSize)) + ((_segInfo->segStart))) - (2 * BaseHeaderSize));
				(GIV(memoryMap)->oldSpaceEnd) = _anInteger;
				assert((((GIV(memoryMap)->permSpaceStart)) == 0) || (_anInteger < ((GIV(memoryMap)->permSpaceStart))));
				/* end setOldSpaceEnd: */
			}
			/* end assimilateNewSegment: */
			/* begin addFreeChunkWithBytes:at: */
			_bytes = ((_segInfo->segSize)) - (2 * BaseHeaderSize);
			_address = (_segInfo->segStart);
			GIV(totalFreeOldSpace) += _bytes;
			_freeChunk = freeChunkWithBytesat(_bytes, _address);
			/* end addFreeChunkWithBytes:at: */
			assert(_freeChunk == (objectStartingAt((_segInfo->segStart))));
			assert((addressAfter(_freeChunk)) == ((segLimit(_segInfo)) - (bridgeSize())));
			/* begin checkFreeSpace: */
			assert(bitsSetInFreeSpaceMaskForAllFreeLists());
			assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
			if ((checkForLeaks & (GCModeFreeSpace | GCModeFreeSpace)) == (GCModeFreeSpace | GCModeFreeSpace)) {
				runLeakCheckerForFreeSpace(GCModeFreeSpace);
			}
			/* end checkFreeSpace: */
			checkSegments();
			_interval = (ioUTCMicrosecondsNow()) - _start;
			if (_interval > GIV(statMaxAllocSegmentTime)) {
				GIV(statMaxAllocSegmentTime) = _interval;
			}
			return (_segInfo->segSize);
		}
	}
	return 0;
}
/* SpurMemoryManager>>#hasIdentityHash: */
static sqInt NoDbgRegParms
hasIdentityHash(sqInt _objOop)
{
	return (uint32AtPointer(_objOop + 4)) & (identityHashHalfWordMask());
}
/* SpurMemoryManager>>#hasOldReferents: */
static sqInt NoDbgRegParms
hasOldReferents(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _iLimit;
	sqInt _referenced2;
	sqInt _referent;

	/* begin hasReferents:satisfying: */
	for (_i = 0, _iLimit = (numPointerSlotsOf(_objOop)) - 1; _i <= _iLimit; _i += 1) {
		/* begin fetchPointer:ofObject: */
		_referenced2 = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_referenced2 & (tagMask())) == 0) && (_referenced2 >= (startOfObjectMemory(GIV(memoryMap))))) {
			if (((_referenced2 & (tagMask())) == 0) && (((long64At(_referenced2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin followForwarded: */
				assert(isUnambiguouslyForwarder(_referenced2));
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent = unsignedLongAt((_referenced2 + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
				while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
				}
				_referenced2 = _referent;
				/* end followForwarded: */
				/* begin storePointer:ofObject:withValue: */
				assert(!(isForwarded(_objOop)));
				if (((_objOop & (tagMask())) == 0) && ((_objOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
					if (((_referenced2 & (tagMask())) == 0) && (((_referenced2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_referenced2 >= ((GIV(memoryMap)->newSpaceStart))))) {
						/* begin possibleOldObjectStoreInto: */
						if (!(((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0)) {
							remember(GIV(fromOldSpaceRememberedSet), _objOop);
						}
						/* end possibleOldObjectStoreInto: */
					}
				}
				/* begin possiblePermObjectStoreInto:value: */
				if (((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0) {
					goto l6;
				}
				if (_referenced2 & (tagMask())) {
					goto l6;
				}
				if (!(_objOop >= 0x20000000000LL)) {
					goto l6;
				}
				if (_referenced2 >= 0x20000000000LL) {
					goto l6;
				}
				if ((_referenced2 >= GIV(nilObj)) && (_referenced2 <= GIV(trueObj))) {
					goto l6;
				}
				if (!(_referenced2 >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l6;
				}
				remember(getFromPermToNewSpaceRememberedSet(), _objOop);
				l6:
				;
				/* end possiblePermObjectStoreInto:value: */
				unsignedLongAtput((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _referenced2);
				/* end storePointer:ofObject:withValue: */
			}
			if ((!((_referenced2 >= GIV(nilObj)) && (_referenced2 <= GIV(trueObj)))) && (((_referenced2 & (tagMask())) == 0) && ((_referenced2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask))))) {
				return 1;
			}
		}
	}
	return 0;
	/* end hasReferents:satisfying: */
}
/* SpurMemoryManager>>#hasYoungReferents: */
static sqInt NoDbgRegParms
hasYoungReferents(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _iLimit;
	sqInt _referenced2;
	sqInt _referent;

	/* begin hasReferents:satisfying: */
	for (_i = 0, _iLimit = (numPointerSlotsOf(_objOop)) - 1; _i <= _iLimit; _i += 1) {
		/* begin fetchPointer:ofObject: */
		_referenced2 = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_referenced2 & (tagMask())) == 0) && (_referenced2 >= (startOfObjectMemory(GIV(memoryMap))))) {
			if (((_referenced2 & (tagMask())) == 0) && (((long64At(_referenced2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin followForwarded: */
				assert(isUnambiguouslyForwarder(_referenced2));
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent = unsignedLongAt((_referenced2 + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
				while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
				}
				_referenced2 = _referent;
				/* end followForwarded: */
				/* begin storePointer:ofObject:withValue: */
				assert(!(isForwarded(_objOop)));
				if (((_objOop & (tagMask())) == 0) && ((_objOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
					if (((_referenced2 & (tagMask())) == 0) && (((_referenced2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_referenced2 >= ((GIV(memoryMap)->newSpaceStart))))) {
						/* begin possibleOldObjectStoreInto: */
						if (!(((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0)) {
							remember(GIV(fromOldSpaceRememberedSet), _objOop);
						}
						/* end possibleOldObjectStoreInto: */
					}
				}
				/* begin possiblePermObjectStoreInto:value: */
				if (((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0) {
					goto l6;
				}
				if (_referenced2 & (tagMask())) {
					goto l6;
				}
				if (!(_objOop >= 0x20000000000LL)) {
					goto l6;
				}
				if (_referenced2 >= 0x20000000000LL) {
					goto l6;
				}
				if ((_referenced2 >= GIV(nilObj)) && (_referenced2 <= GIV(trueObj))) {
					goto l6;
				}
				if (!(_referenced2 >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l6;
				}
				remember(getFromPermToNewSpaceRememberedSet(), _objOop);
				l6:
				;
				/* end possiblePermObjectStoreInto:value: */
				unsignedLongAtput((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _referenced2);
				/* end storePointer:ofObject:withValue: */
			}
			if (((_referenced2 & (tagMask())) == 0) && (((_referenced2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_referenced2 >= ((GIV(memoryMap)->newSpaceStart))))) {
				return 1;
			}
		}
	}
	return 0;
	/* end hasReferents:satisfying: */
}
/*	The header format in LSB is 
	MSB:	| 8: numSlots		| (on a byte boundary) 
	| 2 bits				|	(msb,lsb = {isMarked,?}) 
	| 22: identityHash	| (on a word boundary) 
	| 3 bits				|	(msb <-> lsb = {isGrey,isPinned,isRemembered} 
	| 5: format			| (on a byte boundary) 
	| 2 bits				|	(msb,lsb = {isImmutable,?}) 
	| 22: classIndex		| (on a word boundary) : LSB 
	The remaining bits (7) are used for 
	isImmutable	(bit 23) 
	isRemembered	(bit 29) 
	isPinned		(bit 30) 
	isGrey			(bit 31) 
	isMarked		(bit 55) 
	leaving 2 unused bits, each next to a 22-bit field, allowing those fields 
	to be 
	expanded to 23 bits.. The three bit field { isGrey, isPinned, isRemembered 
	} is for bits that are never set in young objects. This allows the 
	remembered table to be pruned when full by using these bits as a reference 
	count of 
	newSpace objects from the remembered table. Objects with a high count 
	should be tenured to prune the remembered table. */
/* SpurMemoryManager>>#headerForSlots:format:classIndex: */
usqLong
headerForSlotsformatclassIndex(sqInt _numSlots, sqInt _formatField, sqInt _classIndex)
{
	return ((((usqLong) _numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) _formatField ) << (formatShift())) )) + _classIndex;
}
/*	The header format in LSB is 
	MSB:	| 8: numSlots		| (on a byte boundary) 
	| 2 bits				|	(msb,lsb = {isMarked,?}) 
	| 22: identityHash	| (on a word boundary) 
	| 3 bits				|	(msb <-> lsb = {isGrey,isPinned,isRemembered} 
	| 5: format			| (on a byte boundary) 
	| 2 bits				|	(msb,lsb = {isImmutable,?}) 
	| 22: classIndex		| (on a word boundary) : LSB 
	The remaining bits (7) are used for 
	isImmutable	(bit 23) 
	isRemembered	(bit 29) 
	isPinned		(bit 30) 
	isGrey			(bit 31) 
	isMarked		(bit 55) 
	leaving 2 unused bits, each next to a 22-bit field, allowing those fields 
	to be 
	expanded to 23 bits.. The three bit field { isGrey, isPinned, isRemembered 
	} is for bits that are never set in young objects. This allows the 
	remembered table to be pruned when full by using these bits as a reference 
	count of 
	newSpace objects from the remembered table. Objects with a high count 
	should be tenured to prune the remembered table. */
/* SpurMemoryManager>>#headerForSlots:hash:format:classIndex: */
static usqLong NoDbgRegParms
headerForSlotshashformatclassIndex(sqInt _numSlots, sqInt _hash, sqInt _formatField, sqInt _classIndex)
{
	return (((((usqLong) _numSlots ) << (numSlotsFullShift())) + (((usqLong) _hash ) << (identityHashFullWordShift()))) + ((sqInt) (((usqInt) _formatField ) << (formatShift())) )) + _classIndex;
}
/*	Answer the number of extra root slots in the root of the hidden root 
	object.  */
/* SpurMemoryManager>>#hiddenRootSlots */
static sqInt
hiddenRootSlots(void)
{
	return 8;
}
/*	mask the immutable bit in the base header word */
/* SpurMemoryManager>>#immutableBitMask */

#if IMMUTABILITY
sqInt
immutableBitMask(void)
{
	return 1U << (immutableBitShift());
}
#endif /* IMMUTABILITY */
/* SpurMemoryManager>>#indexOf:in: */
sqInt
indexOfin(sqInt _anElement, sqInt _anObject)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _i;
	usqInt _numSlots;
	usqInt _numSlots2;

	_fmt = (((usqInt) (longAt(_anObject)) ) >> (formatShift())) & (formatMask());
	if (_fmt <= 5) {
		/* begin numSlotsOf: */
		assert((classIndexOf(_anObject)) > (isForwardedObjectClassIndexPun()));
		_numSlots2 = byteAt(_anObject + 7);
		_numSlots = ((_numSlots2 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_anObject - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots2);
		/* end numSlotsOf: */
		for (_i = 0; _i <= _numSlots; _i += 1) {
			if (_anElement == (unsignedLongAt((_anObject + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
				return _i;
			}
		}
	}
	if (_fmt >= (firstByteFormat())) {
		if (_fmt >= (firstCompiledMethodFormat())) {
			/* begin primitiveFailFor: */
			return (GIV(primFailCode) = PrimErrUnsupported);
			/* end primitiveFailFor: */
		}
		/* begin numBytesOfBytes: */
		_fmt2 = (((usqInt) (longAt(_anObject)) ) >> (formatShift())) & (formatMask());
		assert(_fmt2 >= (firstByteFormat()));
		_numSlots = ((numSlotsOf(_anObject)) << (shiftForWord())) - (_fmt2 & 7);
		/* end numBytesOfBytes: */
		for (_i = 0; _i <= _numSlots; _i += 1) {
			if (byteAt((_anObject + BaseHeaderSize) + _i)) {
				return _i;
			}
		}
	}
	if (_fmt >= (firstShortFormat())) {
		_numSlots = ((usqInt) (numBytesOf(_anObject)) ) >> 1;
		for (_i = 0; _i <= _numSlots; _i += 1) {
			if (_anElement == ((unsigned short) (shortAt((_anObject + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << 1) ))) )) {
				return _i;
			}
		}
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		_numSlots = ((usqInt) (numBytesOf(_anObject)) ) >> 3;
		for (_i = 0; _i <= _numSlots; _i += 1) {
			if (_anElement == (long64At((_anObject + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << 3) )))) {
				return _i;
			}
		}
	}
	if (_fmt >= (firstLongFormat())) {
		_numSlots = ((usqInt) (numBytesOf(_anObject)) ) >> 2;
		for (_i = 0; _i <= _numSlots; _i += 1) {
			if (_anElement == (long32At((_anObject + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << 2) )))) {
				return _i;
			}
		}
	}
	return -1;
}
/*	Part of reorderReversedTreeList:. Switch treeNode with newNode in 
	the tree, but do nothing to the list linked through freeChunkNextIndex. */
/* SpurMemoryManager>>#inFreeTreeReplace:with: */
static void NoDbgRegParms
inFreeTreeReplacewith(sqInt _treeNode, sqInt _newNode)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _fieldIndex;
	sqInt _i;
	sqInt _iLimit;
	sqInt _relative;

	/* begin storePointer:ofFreeChunk:withValue: */
	assert(isFreeObject(_newNode));
	assert(1);
	unsignedLongAtput((_newNode + BaseHeaderSize) + (1U << (shiftForWord())), 0);
	/* end storePointer:ofFreeChunk:withValue: */
	for (_i = 2, _iLimit = 4; _i <= _iLimit; _i += 1) {
		/* begin fetchPointer:ofFreeChunk: */
		_relative = unsignedLongAt((_treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		/* end fetchPointer:ofFreeChunk: */
		if (_i == 2) {
			if (_relative == 0) {
				assert((GIV(freeLists)[0]) == _treeNode);
				GIV(freeLists)[0] = _newNode;
			} else {
				/* begin storePointer:ofFreeChunk:withValue: */
				if (_treeNode == (unsignedLongAt((_relative + BaseHeaderSize) + (3U << (shiftForWord()))))) {
					/* begin freeChunkSmallerIndex */
					_fieldIndex = 3;
					/* end freeChunkSmallerIndex */
				} else {
					/* begin freeChunkLargerIndex */
					_fieldIndex = 4;
					/* end freeChunkLargerIndex */
				}
				assert(isFreeObject(_relative));
				assert((_newNode == 0) || (isFreeObject(_newNode)));
				unsignedLongAtput((_relative + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ), _newNode);
				/* end storePointer:ofFreeChunk:withValue: */
			}
		}
 else {
			if (_relative != 0) {
				assert((fetchPointerofFreeChunk(freeChunkParentIndex(), _relative)) == _treeNode);
				/* begin storePointer:ofFreeChunk:withValue: */
				assert(isFreeObject(_relative));
				assert((_newNode == 0) || (isFreeObject(_newNode)));
				unsignedLongAtput((_relative + BaseHeaderSize) + (2U << (shiftForWord())), _newNode);
				/* end storePointer:ofFreeChunk:withValue: */
			}
		}
		/* begin storePointer:ofFreeChunk:withValue: */
		assert(isFreeObject(_newNode));
		assert((_relative == 0) || (isFreeObject(_relative)));
		unsignedLongAtput((_newNode + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _relative);
		/* end storePointer:ofFreeChunk:withValue: */
		/* begin storePointer:ofFreeChunk:withValue: */
		assert(isFreeObject(_treeNode));
		assert(1);
		unsignedLongAtput((_treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), 0);
		/* end storePointer:ofFreeChunk:withValue: */
	}
}
/*	Answer how much headroom to allocate, if any, on loading the image. 
	If the image already conatins lots of free space, we should not allocate 
	lots more. */
/* SpurMemoryManager>>#initialHeadroom:givenFreeOldSpaceInImage: */
static sqInt NoDbgRegParms
initialHeadroomgivenFreeOldSpaceInImage(sqInt _extraVmMemory, sqInt _freeOldSpaceInImage)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _headroom;

	if (_extraVmMemory == 0) {
		_headroom = ((!GIV(growHeadroom))
			 ? (16 * 1024) * 1024
			 : GIV(growHeadroom));
	} else {
		_headroom = _extraVmMemory;
	}
	if (_freeOldSpaceInImage >= _headroom) {
		return 0;
	}
	if (_freeOldSpaceInImage >= ((_headroom * 7) / 8)) {
		return _headroom / 8;
	}
	if (_freeOldSpaceInImage >= ((_headroom * 3) / 4)) {
		return _headroom / 4;
	}
	if (_freeOldSpaceInImage >= ((_headroom * 5) / 8)) {
		return (_headroom * 3) / 8;
	}
	if (_freeOldSpaceInImage >= (_headroom / 2)) {
		return _headroom / 2;
	}
	return _headroom;
}
/* SpurMemoryManager>>#initialInstanceOf: */
static sqInt NoDbgRegParms
initialInstanceOf(sqInt _classObj)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _classIndex;
	sqInt _classIndex2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	_classIndex = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask());
	if (_classIndex == 0) {
		return null;
	}
	/* begin flushNewSpaceInstancesOf: */
	_classIndex2 = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask());
	if (_classIndex2 == 0) {
		goto l2;
	}
	/* begin tenuringClassIndex: */
	GIV(tenuringClassIndex) = _classIndex2;
	/* end tenuringClassIndex: */
	scavengingGCTenuringIf(TenureByClass);
	assert(!(existInstancesInNewSpaceOf(_classObj)));
	l2:
	;
	/* end flushNewSpaceInstancesOf: */
	/* begin allObjectsDo: */
	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop2 = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop2, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (_classIndex == ((longAt(_objOop2)) & (classIndexMask()))) {
					return _objOop2;
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop2 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (_classIndex == ((longAt(_objOop2)) & (classIndexMask()))) {
					return _objOop2;
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop2 = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	/* begin allOldSpaceObjectsDo: */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop22 = GIV(nilObj);
	while (1) {
		assert((_objOop22 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop22)) != 0);
		{
			if (isEnumerableObject(_objOop22)) {
				{
					if (_classIndex == ((longAt(_objOop22)) & (classIndexMask()))) {
						return _objOop22;
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop22 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	/* end allOldSpaceObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (_classIndex == ((longAt(_currentObject)) & (classIndexMask()))) {
					return _currentObject;
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
	return null;
}
/*	Reinitialize the free list info. The freeLists object needs to be swizzled 
	because its neither a free, nor a pointer object. Free objects have 
	already been swizzled in adjustAllOopsBy: */
/* SpurMemoryManager>>#initializeFreeSpacePostLoad: */
static void NoDbgRegParms
initializeFreeSpacePostLoad(sqInt _freeListObj)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _iLimit;

	assert((numSlotsOf(_freeListObj)) == (numFreeLists()));
	assert((formatOf(_freeListObj)) == (wordIndexableFormat()));
	GIV(freeLists) = firstIndexableField(_freeListObj);
	GIV(freeListsMask) = 0;
	for (_i = 0, _iLimit = 64 - 1; _i <= _iLimit; _i += 1) {
		if ((GIV(freeLists)[_i]) != 0) {
			GIV(freeListsMask) = GIV(freeListsMask) | (1ULL << _i);
			GIV(freeLists)[_i] = swizzleObj(GIV(freeLists)[_i]);
		}
	}
}
/* SpurMemoryManager>>#initializeHeaderOfStartAddress:numSlots:format:classIndex:pinned: */
static sqInt NoDbgRegParms
initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(sqInt _startAddress, sqInt _numSlots, sqInt _formatField, sqInt _classIndex, sqInt _isPinned)
{
	sqInt _pinFlag;

	_pinFlag = ((sqInt) _isPinned );
	if (_numSlots >= (numSlotsMask())) {
		flag("endianness");
		long64Atput(_startAddress, ((sqInt) (((usqInt) (numSlotsMask()) ) << (numSlotsFullShift())) ) + _numSlots);
		long64Atput(_startAddress + BaseHeaderSize, (headerForSlotsformatclassIndex(numSlotsMask(), _formatField, _classIndex)) | ((sqInt) (((usqInt) _pinFlag ) << (pinnedBitShift())) ));
		return _startAddress + BaseHeaderSize;
	} else {
		long64Atput(_startAddress, (((((usqLong) _numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) _formatField ) << (formatShift())) )) + _classIndex) | ((sqInt) (((usqInt) _pinFlag ) << (pinnedBitShift())) ));
		return _startAddress;
	}
}
/* SpurMemoryManager>>#initializeNewSpaceVariables */
static void NeverInline
initializeNewSpaceVariables(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	SpurNewSpaceSpace *_aNewSpace;
	sqInt _p;

	GIV(freeStart) = ((eden()).start);
	GIV(pastSpaceStart) = ((pastSpace()).start);
	GIV(scavengeThreshold) = ((((eden()).limit)) - ((((GIV(eden).limit)) - ((GIV(eden).start))) / 64)) - (interpreterAllocationReserveBytes());
	(GIV(memoryMap)->newSpaceStart = (((((pastSpace()).start)) < (((futureSpace()).start))) ? ((pastSpace()).start) : ((futureSpace()).start)));
	assert(((GIV(memoryMap)->newSpaceStart)) < (((eden()).start)));
	/* begin initSpaceForAllocationCheck:limit: */
	_aNewSpace = ((SpurNewSpaceSpace *) (&(eden())) );
	if (checkAllocFiller()) {
		for (_p = (_aNewSpace->start); _p < GIV(scavengeThreshold); _p += BytesPerWord) {
			longAtput(_p, _p);
		}
	}
	/* end initSpaceForAllocationCheck:limit: */
}
/*	Initialize object memory variables at startup time. Assume oldSpaceEnd at 
	al are 
	initialised by the image-reading code via 
	setHeapBase:memoryLimit:endOfMemory:. oldSpaceEnd is assumed to point to 
	the end of the last object in the image. 
	Assume: image reader also initializes the following variables: 
	specialObjectsOop 
	lastHashCatch mis-initializations leading to bad translations to C */
/* SpurMemoryManager>>#initializeObjectMemory: */
static void NoDbgRegParms
initializeObjectMemory(sqInt _bytesToShift)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _anInteger;
	sqInt _anOop;
	sqInt _cameFrom;
	usqInt _chunkBytes;
	sqInt _classIndex;
	sqInt _classIndex2;
	sqInt _classTableRoot;
	sqInt _currentObject;
	sqInt _field;
	sqInt _fieldAddr;
	sqInt _fieldAddr2;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;
	sqInt _fieldIndex3;
	sqInt _fieldIndex4;
	sqInt _fieldIndex5;
	sqInt _fieldOop;
	sqInt _fieldOop2;
	sqInt _firstObj;
	sqInt _followingWord;
	sqInt _followingWord2;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	sqInt _freeChunk;
	sqInt _freeListObj;
	usqInt _freeOldStart;
	sqInt _i;
	sqInt _i2;
	sqInt _i3;
	sqInt _iLimit;
	sqInt _iLimit2;
	sqInt _index;
	sqInt _largeChild;
	usqInt _limit;
	sqInt _limit2;
	int _min;
	sqInt _nilObjPreSwizzle;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots3;
	sqInt _obj;
	sqInt _smallChild;
	usqInt _startOfFreeOldSpace;
	sqInt _treeNode;
	sqInt _valuePointer;
	sqInt _valuePointer3;

	assert(BaseHeaderSize == BaseHeaderSize);
	assert(((sqInt) ((maxSlotsForAlloc()) * BytesPerWord) ) > 0);
	{
		initSegmentBridgeWithBytesat(2 * BaseHeaderSize, ((GIV(memoryMap)->oldSpaceEnd)) - (2 * BaseHeaderSize));
	}
	/* begin adjustAllOopsBy: */
	assert(newSpaceIsEmpty());
	/* begin countNumClassPagesPreSwizzle: */
	/* begin objectStartingAt: */
	_address2 = ((sqInt) ((GIV(memoryMap)->oldSpaceStart)) );
	_numSlots3 = byteAt(_address2 + 7);
	_firstObj = ((_numSlots3 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	_classTableRoot = noInlineObjectAfterlimit(noInlineObjectAfterlimit(noInlineObjectAfterlimit(noInlineObjectAfterlimit(_firstObj, (GIV(memoryMap)->oldSpaceEnd)), (GIV(memoryMap)->oldSpaceEnd)), (GIV(memoryMap)->oldSpaceEnd)), (GIV(memoryMap)->oldSpaceEnd));
	_nilObjPreSwizzle = ((GIV(memoryMap)->oldSpaceStart)) - _bytesToShift;
	/* begin numSlotsOf: */
	assert((classIndexOf(_classTableRoot)) > (isForwardedObjectClassIndexPun()));
	_numSlots2 = byteAt(_classTableRoot + 7);
	GIV(numClassTablePages) = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_classTableRoot - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOf: */
	assert(GIV(numClassTablePages) == ((classTableRootSlots()) + (hiddenRootSlots())));
	for (_i3 = 2; _i3 < GIV(numClassTablePages); _i3 += 1) {
		if ((unsignedLongAt((_classTableRoot + BaseHeaderSize) + ((sqInt) (((usqInt) _i3 ) << (shiftForWord())) ))) == _nilObjPreSwizzle) {
			GIV(numClassTablePages) = _i3;
			goto l20;
		}
	}
	l20:
	;
	/* end countNumClassPagesPreSwizzle: */
	if ((_bytesToShift == 0) && ((numSegments()) == 1)) {
		goto l25;
	}
	/* begin objectStartingAt: */
	_address = ((sqInt) ((GIV(memoryMap)->oldSpaceStart)) );
	_numSlots = byteAt(_address + 7);
	_obj = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	while (oopisLessThan(_obj, GIV(freeOldSpaceStart))) {
		_classIndex2 = (longAt(_obj)) & (classIndexMask());
		if (_classIndex2 >= (isForwardedObjectClassIndexPun())) {
			/* begin swizzleFieldsOfObject: */
			_fieldAddr = _obj + (lastPointerOfWhileSwizzling(_obj));
			while (oopisGreaterThanOrEqualTo(_fieldAddr, _obj + BaseHeaderSize)) {
				_fieldOop = longAt(_fieldAddr);
				if ((_fieldOop & (tagMask())) == 0) {
					longAtput(_fieldAddr, swizzleObj(_fieldOop));
				}
				_fieldAddr -= BytesPerOop;
			}
			/* end swizzleFieldsOfObject: */
		} else {
			if (_classIndex2 == (isFreeObjectClassIndexPun())) {
				/* begin swizzleFieldsOfFreeChunk: */
				/* begin fetchPointer:ofFreeChunk: */
				_fieldIndex4 = 0;
				_field = unsignedLongAt((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex4 ) << (shiftForWord())) ));
				/* end fetchPointer:ofFreeChunk: */
				if (_field != 0) {
					/* begin storePointerNoAssert:ofFreeChunk:withValue: */
					_fieldIndex5 = 0;
					_valuePointer = swizzleObj(_field);
					unsignedLongAtput((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex5 ) << (shiftForWord())) ), _valuePointer);
					/* end storePointerNoAssert:ofFreeChunk:withValue: */
				}
				_chunkBytes = bytesInObject(_obj);
				if (_chunkBytes >= (64 * 8)) {
					for (_index = 2, _iLimit2 = 4; _index <= _iLimit2; _index += 1) {
						/* begin fetchPointer:ofFreeChunk: */
						_field = unsignedLongAt((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
						/* end fetchPointer:ofFreeChunk: */
						if (_field != 0) {
							/* begin storePointerNoAssert:ofFreeChunk:withValue: */
							_valuePointer3 = swizzleObj(_field);
							unsignedLongAtput((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ), _valuePointer3);
							/* end storePointerNoAssert:ofFreeChunk:withValue: */
						}
					}
				}
				/* end swizzleFieldsOfFreeChunk: */
			}
		}
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress = addressAfter(_obj);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit2)) {
			_obj = _limit2;
			goto l19;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_obj = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l19:
		;
		/* end objectAfter:limit: */
	}
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				/* begin swizzleFieldsOfObject: */
				_fieldAddr2 = _currentObject + (lastPointerOfWhileSwizzling(_currentObject));
				while (oopisGreaterThanOrEqualTo(_fieldAddr2, _currentObject + BaseHeaderSize)) {
					_fieldOop2 = longAt(_fieldAddr2);
					if ((_fieldOop2 & (tagMask())) == 0) {
						longAtput(_fieldAddr2, swizzleObj(_fieldOop2));
					}
					_fieldAddr2 -= BytesPerOop;
				}
				/* end swizzleFieldsOfObject: */
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l13;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_currentObject = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l13:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	l25:
	;
	/* end adjustAllOopsBy: */
	GIV(specialObjectsOop) = swizzleObj(GIV(specialObjectsOop));
	/* begin fetchPointer:ofObject: */
	GIV(nilObj) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) NilObject ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	GIV(falseObj) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) FalseObject ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	GIV(trueObj) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) TrueObject ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(GIV(nilObj) == ((GIV(memoryMap)->oldSpaceStart)));
	assert(GIV(falseObj) == (oldSpaceObjectAfter(GIV(nilObj))));
	assert(GIV(trueObj) == (oldSpaceObjectAfter(GIV(falseObj))));
	_freeListObj = oldSpaceObjectAfter(GIV(trueObj));
	/* begin setHiddenRootsObj: */
	_anOop = oldSpaceObjectAfter(_freeListObj);
	GIV(hiddenRootsObj) = _anOop;
	assert(validClassTableRootPages());
	/* begin fetchPointer:ofObject: */
	GIV(classTableFirstPage) = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	assert(((numSlotsOf(GIV(classTableFirstPage))) - 1) == (classTableMinorIndexMask()));
	flag("remove at some stage");
	if (((longAt(GIV(classTableFirstPage))) & (classIndexMask())) != (arrayClassIndexPun())) {
		/* begin setClassIndexOf:to: */
		_classIndex = arrayClassIndexPun();
		assert((_classIndex >= 0) && (_classIndex <= (classIndexMask())));
		longAtput(GIV(classTableFirstPage), ((longAt(GIV(classTableFirstPage))) & (~((usqIntptr_t) (classIndexMask()) ))) + _classIndex);
		/* end setClassIndexOf:to: */
	}
	/* begin classTableRootSlots */
	GIV(numClassTablePages) = 1U << (22 - (classTableMajorIndexShift()));
	/* end classTableRootSlots */
	for (_i = 2; _i < GIV(numClassTablePages); _i += 1) {
		if ((unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ))) == GIV(nilObj)) {
			GIV(numClassTablePages) = _i;
			GIV(classTableIndex) = ((sqInt) (((usqInt) ((((GIV(numClassTablePages) - 1) < 1) ? 1 : GIV(numClassTablePages) - 1)) ) << (classTableMajorIndexShift())) );
			goto l7;
		}
	}
	GIV(classTableIndex) = 1U << (classTableMajorIndexShift());
	l7:
	;
	/* end setHiddenRootsObj: */
	GIV(markStack) = swizzleObjStackAt(MarkStackRootIndex);
	GIV(weaklingStack) = swizzleObjStackAt(WeaklingStackRootIndex);
	GIV(mournQueue) = swizzleObjStackAt(MournQueueRootIndex);
	assert(validObjStacks());
	assert(isEmptyObjStack(GIV(markStack)));
	assert(isEmptyObjStack(GIV(weaklingStack)));
	initializeFreeSpacePostLoad(_freeListObj);
	collapseSegmentsPostSwizzle();
	/* begin assertBridge */
	assert(isSegmentBridge(bridgeAt(0)));
	assert((numSlotsOfAny(bridgeAt(0))) == 0);
	/* end assertBridge */
	/* begin updateFreeLists */
	{
		_min = 3;
	}
	for (_i2 = _min, _iLimit = 64 - 1; _i2 <= _iLimit; _i2 += 1) {
		updateListStartingAt(GIV(freeLists)[_i2]);
	}
	/* begin freeTreeNodesDo: */
	_treeNode = GIV(freeLists)[0];
	if (_treeNode == 0) {
		goto l10;
	}
	_cameFrom = -1;
	do {
		assert((bytesInObject(_treeNode)) >= ((numFreeLists()) * (allocationUnit())));
		/* begin fetchPointer:ofFreeChunk: */
		_fieldIndex2 = 3;
		_smallChild = unsignedLongAt((_treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
		/* end fetchPointer:ofFreeChunk: */
		/* begin fetchPointer:ofFreeChunk: */
		_fieldIndex3 = 4;
		_largeChild = unsignedLongAt((_treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex3 ) << (shiftForWord())) ));
		/* end fetchPointer:ofFreeChunk: */
		assert((_smallChild == 0) || (_treeNode == (fetchPointerofFreeChunk(freeChunkParentIndex(), _smallChild))));
		assert((_largeChild == 0) || (_treeNode == (fetchPointerofFreeChunk(freeChunkParentIndex(), _largeChild))));
		if (((_smallChild == 0) && (_largeChild == 0)) || (((_largeChild == 0)
			 ? _cameFrom == _smallChild
			 : _cameFrom == _largeChild))) {
			{
				updateListStartingAt(_treeNode);
			}
			_cameFrom = _treeNode;
			/* begin fetchPointer:ofFreeChunk: */
			_fieldIndex = 2;
			_treeNode = unsignedLongAt((_treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofFreeChunk: */
		} else {
			if ((_smallChild != 0) && (_cameFrom != _smallChild)) {
				_treeNode = _smallChild;
			} else {
				assert(_largeChild != 0);
				_treeNode = _largeChild;
			}
			_cameFrom = -1;
		}
	} while (_treeNode != 0);
	l10:
	;
	/* end freeTreeNodesDo: */
	/* end updateFreeLists */
	/* begin computeFreeSpacePostSwizzle */
	GIV(totalFreeOldSpace) = totalFreeListBytes();
	/* begin checkFreeSpace: */
	assert(bitsSetInFreeSpaceMaskForAllFreeLists());
	assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
	/* end checkFreeSpace: */
	/* end computeFreeSpacePostSwizzle */
	/* begin initializeOldSpaceFirstFree: */
	_startOfFreeOldSpace = GIV(freeOldSpaceStart);
	_limit = ((GIV(memoryMap)->oldSpaceEnd)) - (2 * BaseHeaderSize);
	if (_limit > _startOfFreeOldSpace) {
		GIV(totalFreeOldSpace) += _limit - _startOfFreeOldSpace;
		_freeOldStart = _startOfFreeOldSpace;
		{
			while ((_limit - _freeOldStart) >= (1ULL << 32)) {
				_freeChunk = freeChunkWithBytesat(1ULL << 32, _freeOldStart);
				_freeOldStart += 1ULL << 32;
				assert(_freeOldStart == (addressAfter(_freeChunk)));
			}
		}
		if (_freeOldStart < _limit) {
			_freeChunk = freeChunkWithBytesat(_limit - _freeOldStart, _freeOldStart);
			assert((addressAfter(_freeChunk)) == _limit);
		}
	}
	/* begin setOldSpaceEnd: */
	_anInteger = ((sqInt) (((GIV(memoryMap)->oldSpaceEnd)) - (2 * BaseHeaderSize)) );
	(GIV(memoryMap)->oldSpaceEnd) = _anInteger;
	assert((((GIV(memoryMap)->permSpaceStart)) == 0) || (_anInteger < ((GIV(memoryMap)->permSpaceStart))));
	/* end setOldSpaceEnd: */
	GIV(freeOldSpaceStart) = (GIV(memoryMap)->oldSpaceEnd);
	/* begin checkFreeSpace: */
	assert(bitsSetInFreeSpaceMaskForAllFreeLists());
	assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
	if ((checkForLeaks & (GCModeFreeSpace | GCModeFreeSpace)) == (GCModeFreeSpace | GCModeFreeSpace)) {
		runLeakCheckerForFreeSpace(GCModeFreeSpace);
	}
	/* end checkFreeSpace: */
	/* end initializeOldSpaceFirstFree: */
	initializeNewSpaceVariables();
	initializeRememberedSetShouldStartEmpty(GIV(fromOldSpaceRememberedSet), 1);
	initializeRememberedSetShouldStartEmpty(GIV(fromPermToOldSpaceRememberedSet), 0);
	(GIV(fromPermToOldSpaceRememberedSet)->doFullScan = 1);
	initializeRememberedSetShouldStartEmpty(GIV(fromPermToNewSpaceRememberedSet), 1);
	checkSegments();
	/* begin biasForGC */
	GIV(biasForGC) = 1;
	/* end biasForGC */
	GIV(growHeadroom) = (16 * 1024) * 1024;
	GIV(shrinkThreshold) = (32 * 1024) * 1024;
	/* begin setHeapSizeAtPreviousGC */
	GIV(heapSizeAtPreviousGC) = (GIV(totalHeapSizeIncludingBridges) - (GIV(numSegments) * (2 * BaseHeaderSize))) - GIV(totalFreeOldSpace);
	/* begin resetAllocationAccountingAfterGC */
	GIV(oldSpaceUsePriorToScavenge) = (GIV(totalHeapSizeIncludingBridges) - (GIV(numSegments) * (2 * BaseHeaderSize))) - GIV(totalFreeOldSpace);
	/* end resetAllocationAccountingAfterGC */
	/* end setHeapSizeAtPreviousGC */
	GIV(heapGrowthToSizeGCRatio) = 0.333333;
}
/*	print free chunks in freeTree in order. */
/* SpurMemoryManager>>#inOrderPrintFreeTree:printList: */
void
inOrderPrintFreeTreeprintList(sqInt _freeChunk, sqInt _printNextList)
{
	sqInt _next;

	if (((_next = unsignedLongAt((_freeChunk + BaseHeaderSize) + (3U << (shiftForWord()))))) != 0) {
		inOrderPrintFreeTreeprintList(_next, _printNextList);
	}
	printFreeChunkprintAsTreeNode(_freeChunk, 1);
	if (_printNextList) {
		_next = _freeChunk;
		while (((_next = unsignedLongAt((_next + BaseHeaderSize) + (0U << (shiftForWord()))))) != 0) {
			/* begin tab */
			printChar('	');
			/* end tab */
			printFreeChunkprintAsTreeNode(_next, 0);
		}
	}
	if (((_next = unsignedLongAt((_freeChunk + BaseHeaderSize) + (4U << (shiftForWord()))))) != 0) {
		inOrderPrintFreeTreeprintList(_next, _printNextList);
	}
}
/*	in an effort to fix a compiler bug with two-way become post r3427Do become in place by swapping object contents. */
/* SpurMemoryManager>>#inPlaceBecome:and:copyHashFlag: */
static void NoDbgRegParms NeverInline
inPlaceBecomeandcopyHashFlag(sqInt _obj1, sqInt _obj2, sqInt _copyHashFlag)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _fmt;
	sqLong _hashBits;
	sqLong _header1;
	sqLong _header2;
	sqInt _i;
	sqInt _iLimit;
	sqInt _o1HasYoung;
	int _o2HasYoung;
	sqLong _remembered;
	sqInt _temp1;
	sqInt _temp2;

	assert((numSlotsOf(_obj1)) == (numSlotsOf(_obj2)));
	assert(((rawHashBitsOf(_obj1)) == 0) || ((classOrNilAtIndex(rawHashBitsOf(_obj1))) != _obj1));
	assert(((rawHashBitsOf(_obj2)) == 0) || ((classOrNilAtIndex(rawHashBitsOf(_obj2))) != _obj2));
	{
		/* begin cleverSwapHeaders:and:copyHashFlag: */
		_header1 = long64At(_obj1);
		_header2 = long64At(_obj2);
		_remembered = (_header1 ^ _header2) & (1U << (rememberedBitShift()));
		if (_remembered != 0) {
			_header1 = _header1 ^ _remembered;
			_header2 = _header2 ^ _remembered;
		}
		if (!_copyHashFlag) {
			_hashBits = (_header1 ^ _header2) & 0x3FFFFF00000000LL;
			if (_hashBits != 0) {
				_header1 = _header1 ^ _hashBits;
				_header2 = _header2 ^ _hashBits;
			}
		}
		long64Atput(_obj1, _header2);
		long64Atput(_obj2, _header1);
		/* end cleverSwapHeaders:and:copyHashFlag: */
	}
	_o1HasYoung = (_o2HasYoung = 0);
	for (_i = 0, _iLimit = (numSlotsOf(_obj1)) - 1; _i <= _iLimit; _i += 1) {
		/* begin fetchPointer:ofObject: */
		_temp1 = unsignedLongAt((_obj1 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* begin fetchPointer:ofObject: */
		_temp2 = unsignedLongAt((_obj2 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		{
			assert(!(isOopForwarded(_obj1)));
			longAtput((_obj1 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _temp2);
		}
		{
			assert(!(isOopForwarded(_obj2)));
			longAtput((_obj2 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _temp1);
		}
		if (((_temp2 & (tagMask())) == 0) && (((_temp2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_temp2 >= ((GIV(memoryMap)->newSpaceStart))))) {
			_o1HasYoung = 1;
		}
		if (((_temp1 & (tagMask())) == 0) && (((_temp1 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_temp1 >= ((GIV(memoryMap)->newSpaceStart))))) {
			_o2HasYoung = 1;
		}
	}
	if (_o1HasYoung && ((_obj1 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		_fmt = (((usqInt) (longAt(_obj1)) ) >> (formatShift())) & (formatMask());
		if (!((_fmt >= (sixtyFourBitIndexableFormat())) && (_fmt < (firstCompiledMethodFormat())))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_obj1)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _obj1);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	if (_o2HasYoung && ((_obj2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		_fmt = (((usqInt) (longAt(_obj2)) ) >> (formatShift())) & (formatMask());
		if (!((_fmt >= (sixtyFourBitIndexableFormat())) && (_fmt < (firstCompiledMethodFormat())))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_obj2)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _obj2);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
}
/*	Answer the number of slots in a class. For example the instanceSizeOf:  
	ClassPoint is 2, for the x & y slots. The instance size of non-pointer 
	classes is 0. */
/* SpurMemoryManager>>#instanceSizeOf: */
sqInt
instanceSizeOf(sqInt _classObj)
{
	assert(addressCouldBeClassObj(_classObj));
	return ((unsignedLongAt((_classObj + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3) & ((1U << (fixedFieldsFieldWidth())) - 1);
}
/* SpurMemoryManager>>#instantiateClass:indexableSize: */
sqInt
instantiateClassindexableSize(sqInt _classObj, sqInt _nElements)
{
	return instantiateClassindexableSizeisPinnedisOldSpace(_classObj, _nElements, 0, 0);
}
/* SpurMemoryManager>>#instantiateClass:indexableSize:isPinned: */
sqInt
instantiateClassindexableSizeisPinned(sqInt _classObj, sqInt _nElements, sqInt _isPinned)
{
	return instantiateClassindexableSizeisPinnedisOldSpace(_classObj, _nElements, _isPinned, 0);
}
/* SpurMemoryManager>>#instantiateClass:isPinned:isOldSpace: */
static sqInt NoDbgRegParms
instantiateClassisPinnedisOldSpace(sqInt _classObj, sqInt _isPinned, sqInt _isOldSpace)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classFormat;
	sqInt _classFormat2;
	sqInt _classIndex;
	sqInt _classObj2;
	sqInt _err;
	sqInt _hash;
	int _hasToScheduleScavenge;
	sqInt _instSpec;
	sqInt _newObj;
	sqInt _newObj2;
	usqInt _numBytes;
	sqInt _numSlots;
	usqInt _p;

	/* begin formatOfClassSafe: */
	_classObj2 = ((((_classObj & (tagMask())) == 0) && (((long64At(_classObj)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))
		 ? noInlineFollowForwarded(_classObj)
		 : _classObj);
	if (!((_classObj2 & (tagMask())) == 0)) {
		_classFormat = -1;
		goto l8;
	}
	if (!((numSlotsOfAny(_classObj2)) >= InstanceSpecificationIndex)) {
		_classFormat = -1;
		goto l8;
	}
	/* begin fetchPointer:ofObject: */
	_classFormat2 = unsignedLongAt((_classObj2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (!(((_classFormat2 & 7) == 1))) {
		_classFormat = -1;
		goto l8;
	}
	_classFormat = _classFormat2 >> 3;
	l8:
	;
	/* end formatOfClassSafe: */
	if (_classFormat == -1) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadReceiver;
		/* end primitiveFailFor: */
		return null;
	}
	_instSpec = (((usqInt) _classFormat ) >> (fixedFieldsFieldWidth())) & (formatMask());
	if (!((_instSpec <= 1) || (_instSpec == 5))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadReceiver;
		/* end primitiveFailFor: */
		return null;
	}
	{
		assert(addressCouldBeClassObj(_classObj));
		_classIndex = ((((_hash = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask()))) != 0)
			 ? _hash
			 : ((objCouldBeClassObj(_classObj))
				 ? ((((_err = enterIntoClassTable(_classObj))) != 0)
					 ? -_err
					 : (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask()))
				 : -PrimErrBadReceiver));
	}
	if (_classIndex < 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = -_classIndex;
		/* end primitiveFailFor: */
		return null;
	}
	/* begin fixedFieldsOfClassFormat: */
	_numSlots = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	/* end fixedFieldsOfClassFormat: */
	/* begin allocateSlots:format:classIndex:isPinned:isOldSpace: */
	if (_numSlots >= (numSlotsMask())) {
		if ((((usqInt) _numSlots ) >> 56) > 0) {
			_newObj = null;
			goto l9;
		}
		_numBytes = (BaseHeaderSize + BaseHeaderSize) + (_numSlots * BytesPerOop);
	} else {
		_numBytes = BaseHeaderSize + (((_numSlots < 1)
			 ? 8
			 : _numSlots * BytesPerOop));
	}
	_hasToScheduleScavenge = (GIV(freeStart) + _numBytes) > GIV(scavengeThreshold);
	if (_hasToScheduleScavenge || (_isPinned || _isOldSpace)) {
		if (_hasToScheduleScavenge) {
			if (!GIV(needGCFlag)) {
				/* begin scheduleScavenge */
				GIV(needGCFlag) = 1;
				forceInterruptCheck();
				/* end scheduleScavenge */
			}
		}
		if (_isPinned) {
			_newObj = allocateSlotsForPinningInOldSpacebytesformatclassIndex(_numSlots, _numBytes, _instSpec, _classIndex);
			goto l9;
		}
 else {
			_newObj = allocateSlotsInOldSpacebytesformatclassIndex(_numSlots, _numBytes, _instSpec, _classIndex);
			goto l9;
		}
	}
	_newObj2 = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(GIV(freeStart), _numSlots, _instSpec, _classIndex, 0);
	assert((_numBytes % (allocationUnit())) == 0);
	assert((_newObj2 % (allocationUnit())) == 0);
	GIV(freeStart) += _numBytes;
	_newObj = _newObj2;
	l9:
	;
	/* end allocateSlots:format:classIndex:isPinned:isOldSpace: */
	if (_newObj == null) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrNoMemory;
		/* end primitiveFailFor: */
	} else {
		/* begin fillObj:numSlots:with: */
		assert(oopisLessThan(((_newObj + BaseHeaderSize) + (_numSlots * BytesPerOop)) - 1, addressAfter(_newObj)));
		for (_p = ((usqInt) (_newObj + BaseHeaderSize) ); _p <= ((usqInt) (((_newObj + BaseHeaderSize) + (_numSlots * BytesPerOop)) - 1) ); _p += 8) {
			longAtput(_p, GIV(nilObj));
		}
		/* end fillObj:numSlots:with: */
	}
	return _newObj;
}
/* SpurMemoryManager>>#instSpecOfClassFormat: */
sqInt
instSpecOfClassFormat(sqInt _classFormat)
{
	return (((usqInt) _classFormat ) >> (fixedFieldsFieldWidth())) & (formatMask());
}
/*	This field in a class's format inst var corresponds to the 5-bit format 
	field stored in every object header */
/* SpurMemoryManager>>#instSpecOfClass: */
static sqInt NoDbgRegParms
instSpecOfClass(sqInt _classPointer)
{
	sqInt _classFormat;

	/* begin instSpecOfClassFormat: */
	_classFormat = (unsignedLongAt((_classPointer + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	return (((usqInt) _classFormat ) >> (fixedFieldsFieldWidth())) & (formatMask());
	/* end instSpecOfClassFormat: */
}
/*	the inverse of isPureBitsFormat: */
/* SpurMemoryManager>>#isAnyPointerFormat: */
static sqInt NoDbgRegParms
isAnyPointerFormat(sqInt _format)
{
	return (_format <= 5) || (_format >= (firstCompiledMethodFormat()));
}
/*	Answer if this is an indexable object with pointer elements, e.g., an 
	array  */
/* SpurMemoryManager>>#isArrayNonImm: */
sqInt
isArrayNonImm(sqInt _oop)
{
	return ((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) == 2;
}
/*	Answer true if this is an indexable object with pointer elements, e.g., an 
	array  */
/* SpurMemoryManager>>#isArray: */
sqInt
isArray(sqInt _oop)
{
	return ((_oop & (tagMask())) == 0) && (((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) == 2);
}
/*	Answer true if the argument contains indexable bytes. See comment in 
	formatOf: Note: Includes CompiledMethods. */
/* SpurMemoryManager>>#isBytes: */
sqInt
isBytes(sqInt _oop)
{
	return ((_oop & (tagMask())) == 0) && (((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat()));
}
/* SpurMemoryManager>>#isCharacterObject: */
sqInt
isCharacterObject(sqInt _oop)
{
	return _oop & (characterTag());
}
/* SpurMemoryManager>>#isCharacterValue: */
sqInt
isCharacterValue(sqInt _anInteger)
{
	return (_anInteger >= 0) && (_anInteger <= ((1U << 30) - 1));
}
/*	Answer if aClass exists at only one index in the class table. Be careful 
	not to 
	be misled by classes that have puns, such as Array. */
/* SpurMemoryManager>>#isClassAtUniqueIndex: */
static sqInt NoDbgRegParms
isClassAtUniqueIndex(sqInt _aClass)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classOrNil;
	sqInt _expectedIndex;
	sqInt _i;
	sqInt _iLimit;
	sqInt _index;
	sqInt _j;
	sqInt _page;

	_expectedIndex = (uint32AtPointer(_aClass + 4)) & (identityHashHalfWordMask());
	/* begin classTableEntriesDo: */
	for (_i = 0; _i < GIV(numClassTablePages); _i += 1) {
		_page = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		for (_j = 0, _iLimit = (1U << (classTableMajorIndexShift())) - 1; _j <= _iLimit; _j += 1) {
			_classOrNil = unsignedLongAt((_page + BaseHeaderSize) + ((sqInt) (((usqInt) _j ) << (shiftForWord())) ));
			if (_classOrNil != GIV(nilObj)) {
				{
					_index = ((sqInt) (((usqInt) _i ) << (classTableMajorIndexShift())) ) + _j;
					if ((_classOrNil == _aClass) && ((_index != _expectedIndex) && (_index > (lastClassIndexPun())))) {
						return 0;
					}
				}
			}
		}
	}
	/* end classTableEntriesDo: */
	return 1;
}
/* SpurMemoryManager>>#isCompiledMethodFormat: */
static sqInt NoDbgRegParms
isCompiledMethodFormat(sqInt _format)
{
	return _format >= (firstCompiledMethodFormat());
}
/*	Answer whether the argument header has compiled method format */
/* SpurMemoryManager>>#isCompiledMethodHeader: */
static sqInt NoDbgRegParms
isCompiledMethodHeader(sqInt _objHeader)
{
	return ((((usqInt) _objHeader ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat());
}
/*	Answer whether the argument object is of compiled method format */
/* SpurMemoryManager>>#isCompiledMethod: */
sqInt
isCompiledMethod(sqInt _objOop)
{
	return ((((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat());
}
/* SpurMemoryManager>>#isContextHeader: */
static sqInt NoDbgRegParms
isContextHeader(sqInt _aHeader)
{
	return (_aHeader & (classIndexMask())) == ClassMethodContextCompactIndex;
}
/* SpurMemoryManager>>#isContext: */
static sqInt NoDbgRegParms
isContext(sqInt _oop)
{
	return ((_oop & (tagMask())) == 0) && (((longAt(_oop)) & (classIndexMask())) == ClassMethodContextCompactIndex);
}
/* SpurMemoryManager>>#isEmptyObjStack: */
static sqInt NoDbgRegParms
isEmptyObjStack(sqInt _objStack)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (_objStack == GIV(nilObj)) {
		return 1;
	}
	eassert(isValidObjStack(_objStack));
	return (0 == (unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) )))) && (0 == (unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ))));
}
/*	Answer if objOop should be included in an allObjects...Do: enumeration. 
	This is for assert-checking only. */
/* SpurMemoryManager>>#isEnumerableObjectNoAssert: */
static sqInt NoDbgRegParms
isEnumerableObjectNoAssert(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classIndex;

	/* begin classIndexOf: */
	_classIndex = (longAt(_objOop)) & (classIndexMask());
	/* end classIndexOf: */
	return (_classIndex >= (isForwardedObjectClassIndexPun())) && (_classIndex < (GIV(numClassTablePages) * (1U << (classTableMajorIndexShift()))));
}
/*	Answer if objOop should be included in an allObjects...Do: enumeration. 
	Non-objects should be excluded; these are bridges and free chunks. */
/* SpurMemoryManager>>#isEnumerableObject: */
static sqInt NoDbgRegParms
isEnumerableObject(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classIndex;

	/* begin classIndexOf: */
	_classIndex = (longAt(_objOop)) & (classIndexMask());
	/* end classIndexOf: */
	assert(((uint64AtPointer(_objOop)) != 0) && (_classIndex < (GIV(numClassTablePages) * (classTablePageSize()))));
	return _classIndex >= (isForwardedObjectClassIndexPun());
}
/* SpurMemoryManager>>#isEphemeronFormat: */
static sqInt NoDbgRegParms
isEphemeronFormat(sqInt _format)
{
	return _format == 5;
}
/* SpurMemoryManager>>#isEphemeron: */
static sqInt NoDbgRegParms
isEphemeron(sqInt _objOop)
{
	sqInt _format;

	assert(isNonImmediate(_objOop));
	/* begin isEphemeronFormat: */
	_format = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	return _format == 5;
	/* end isEphemeronFormat: */
}
/* SpurMemoryManager>>#isFixedSizePointerFormat: */
sqInt
isFixedSizePointerFormat(sqInt _format)
{
	return (_format <= 1) || (_format == 5);
}
/* SpurMemoryManager>>#isForwardedClassTag: */
static sqInt NoDbgRegParms
isForwardedClassTag(sqInt _classIndex)
{
	return _classIndex == (isForwardedObjectClassIndexPun());
}
/*	Answer if objOop is that if a forwarder. Take advantage of 
	isForwardedObjectClassIndexPun being a power of two to generate a more 
	efficient test than the straight-forward 
	(self classIndexOf: objOop) = self isForwardedObjectClassIndexPun 
	at the cost of this being ambiguous with free chunks. So either never 
	apply this to free chunks 
	or guard with (self isFreeObject: foo) not. So far the idiom has been to 
	guard with isFreeObject:self assert: (self isFreeObject: objOop) not. */
/* SpurMemoryManager>>#isForwarded: */
sqInt
isForwarded(sqInt _objOop)
{
	return ((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
}
/* SpurMemoryManager>>#isFreeObject: */
static sqInt NoDbgRegParms
isFreeObject(sqInt _objOop)
{
	return ((longAt(_objOop)) & (classIndexMask())) == (isFreeObjectClassIndexPun());
}
/* SpurMemoryManager>>#isFreeOop: */
static sqInt NoDbgRegParms
isFreeOop(sqInt _oop)
{
	return ((_oop & (tagMask())) == 0) && (((longAt(_oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun()));
}
/* SpurMemoryManager>>#isImmediate: */
sqInt
isImmediate(sqInt _oop)
{
	return _oop & (tagMask());
}
/* SpurMemoryManager>>#isIndexable: */
sqInt
isIndexable(sqInt _objOop)
{
	sqInt _fmt;

	_fmt = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	return (_fmt >= 2) && ((_fmt <= (weakArrayFormat())) || (_fmt >= (sixtyFourBitIndexableFormat())));
}
/* SpurMemoryManager>>#isInEden: */
static sqInt NoDbgRegParms
isInEden(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return oopisGreaterThanOrEqualToandLessThan(_objOop, ((eden()).start), GIV(freeStart));
}
/* SpurMemoryManager>>#isInFutureSpace: */
static sqInt NoDbgRegParms
isInFutureSpace(sqInt _address)
{
	return oopisGreaterThanOrEqualToandLessThan(_address, ((futureSpace()).start), futureSurvivorStart());
}
/*	Answer if the given address is in ST object memory. */
/* SpurMemoryManager>>#isInMemory: */
sqInt
isInMemory(sqInt _address)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;

	if ((oopisLessThan(_address, (GIV(memoryMap)->newSpaceEnd))) && (oopisGreaterThanOrEqualTo(_address, (GIV(memoryMap)->newSpaceStart)))) {
		return (oopisGreaterThanOrEqualToandLessThan(_address, ((eden()).start), GIV(freeStart))) || ((oopisGreaterThanOrEqualToandLessThan(_address, ((pastSpace()).start), GIV(pastSpaceStart))) || ((GIV(gcPhaseInProgress) == ScavengeInProgress) && (oopisGreaterThanOrEqualToandLessThan(_address, ((futureSpace()).start), futureSurvivorStart()))));
	}
	/* begin isInSegments: */
	for (_i = 0; _i < GIV(numSegments); _i += 1) {
		if (_address < (((GIV(segments)[_i]).segStart))) {
			return 0;
		}
		if (_address < ((((GIV(segments)[_i]).segSize)) + (((GIV(segments)[_i]).segStart)))) {
			return 1;
		}
	}
	return 0;
	/* end isInSegments: */
}
/* SpurMemoryManager>>#isInNewSpace: */
static sqInt NoDbgRegParms
isInNewSpace(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return (oopisLessThan(_objOop, (GIV(memoryMap)->newSpaceEnd))) && (oopisGreaterThanOrEqualTo(_objOop, (GIV(memoryMap)->newSpaceStart)));
}
/* SpurMemoryManager>>#isInOldSpace: */
sqInt
isInOldSpace(sqInt _address)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return oopisGreaterThanOrEqualToandLessThan(_address, (GIV(memoryMap)->oldSpaceStart), (GIV(memoryMap)->oldSpaceEnd));
}
/* SpurMemoryManager>>#isInPastSpace: */
static sqInt NoDbgRegParms
isInPastSpace(sqInt _address)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return oopisGreaterThanOrEqualToandLessThan(_address, ((pastSpace()).start), GIV(pastSpaceStart));
}
/* SpurMemoryManager>>#isInPermSpace: */
sqInt
isInPermSpace(sqInt _address)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return oopisGreaterThanOrEqualToandLessThan(_address, (GIV(memoryMap)->permSpaceStart), (GIV(memoryMap)->permSpaceEnd));
}
/* SpurMemoryManager>>#isLargeFreeObject: */
static sqInt NoDbgRegParms
isLargeFreeObject(sqInt _objOop)
{
	return (bytesInObject(_objOop)) >= (64 * 8);
}
/* SpurMemoryManager>>#isMarkedOrPermanent: */
sqInt
isMarkedOrPermanent(sqInt _anOop)
{
	return (((((usqInt) (longAt(_anOop)) ) >> (markedBitFullShift())) & 1) != 0) || (((_anOop & (tagMask())) == 0) && (_anOop >= 0x20000000000LL));
}
/* SpurMemoryManager>>#isMaybeFiredEphemeron: */
static sqInt NoDbgRegParms
isMaybeFiredEphemeron(sqInt _objOop)
{
	sqInt _format;

	/* begin isMaybeFiredEphemeronFormat: */
	_format = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	return (_format <= 5) && (odd(_format));
	/* end isMaybeFiredEphemeronFormat: */
}
/* SpurMemoryManager>>#isNonImmediate: */
sqInt
isNonImmediate(sqInt _oop)
{
	return (_oop & (tagMask())) == 0;
}
/*	Note that (sadly) this is not the negation of `isForwarded`. 
	`isForwarded` performs an unconditional memory access that can cause a 
	crash (or an erroneous result) when applied on immediates. */
/* SpurMemoryManager>>#isNotForwarded: */
sqInt
isNotForwarded(sqInt _oop)
{
	return (_oop & (tagMask())) || (!(((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0));
}
/* SpurMemoryManager>>#isObjEphemeron: */
static sqInt NoDbgRegParms
isObjEphemeron(sqInt _objOop)
{
	sqInt _format;

	/* begin isEphemeronFormat: */
	_format = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	return _format == 5;
	/* end isEphemeronFormat: */
}
/* SpurMemoryManager>>#isObjImmutable: */
static sqInt NoDbgRegParms
isObjImmutable(sqInt _anOop)
{
	return 
#    if IMMUTABILITY
			(/* begin isImmutable: */ ((((usqInt) (longAt(_anOop)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#    else /* IMMUTABILITY */
			0
#    endif /* IMMUTABILITY */
			;
}
/* SpurMemoryManager>>#isOld: */
sqInt
isOld(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((_oop & (tagMask())) == 0) && ((_oop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)));
}
/*	Answer whether the oop is an object of compiled method format */
/* SpurMemoryManager>>#isOopCompiledMethod: */
sqInt
isOopCompiledMethod(sqInt _oop)
{
	return ((_oop & (tagMask())) == 0) && (((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()));
}
/* SpurMemoryManager>>#isOopForwarded: */
sqInt
isOopForwarded(sqInt _oop)
{
	return ((_oop & (tagMask())) == 0) && (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0);
}
/* SpurMemoryManager>>#isOopImmutable: */
sqInt
isOopImmutable(sqInt _oop)
{
	return (_oop & (tagMask())) || (((((usqInt) (longAt(_oop)) ) >> (immutableBitShift())) & 1) != 0);
}
/* SpurMemoryManager>>#isOopMutable: */
sqInt
isOopMutable(sqInt _oop)
{
	return ((_oop & (tagMask())) == 0) && (!(((((usqInt) (longAt(_oop)) ) >> (immutableBitShift())) & 1) != 0));
}
/* SpurMemoryManager>>#isPermanent: */
sqInt
isPermanent(sqInt _oop)
{
	return ((_oop & (tagMask())) == 0) && (_oop >= 0x20000000000LL);
}
/* SpurMemoryManager>>#isPermSpaceRememberedSetSane */
sqInt
isPermSpaceRememberedSetSane(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _currentObject;
	sqInt _followingWord;
	usqInt _followingWordAddress;
	int _isValid;
	sqInt _referenced;
	sqInt _refersNewSpace;
	sqInt _refersOldSpace;

	_isValid = 1;
	/* begin allPermSpaceForwarded:ObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (((long64At(_currentObject)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					{
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referenced = unsignedLongAt((_currentObject + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
						_refersOldSpace = ((_referenced & (((getMemoryMap())->spaceMaskToUse))) == (((getMemoryMap())->newSpaceMask))) && (_referenced >= (((getMemoryMap())->newSpaceStart)));
						_refersNewSpace = (_referenced & (((getMemoryMap())->spaceMaskToUse))) == (((getMemoryMap())->oldSpaceMask));
						if (!(isPermSpaceRememberedSetSaneMemberwithNewSpaceRefswithOldSpaceRefs(_currentObject, _refersNewSpace, _refersOldSpace))) {
							_isValid = 0;
						}
					}
				} else {
					{
						_refersNewSpace = hasYoungReferents(_currentObject);
						_refersOldSpace = hasOldReferents(_currentObject);
						if (!(isPermSpaceRememberedSetSaneMemberwithNewSpaceRefswithOldSpaceRefs(_currentObject, _refersNewSpace, _refersOldSpace))) {
							_isValid = 0;
						}
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_currentObject = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allPermSpaceForwarded:ObjectsDo: */
	return _isValid;
}
/* SpurMemoryManager>>#isPermSpaceRememberedSetSaneMember:withNewSpaceRefs:withOldSpaceRefs: */
static sqInt NoDbgRegParms
isPermSpaceRememberedSetSaneMemberwithNewSpaceRefswithOldSpaceRefs(sqInt _objOop, sqInt _refersNewSpace, sqInt _refersOldSpace)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMRememberedSet * self_in_isInRememberedSet;
	VMRememberedSet * self_in_isInRememberedSet2;
	sqInt _i;
	sqInt _i2;
	sqInt _isInPermToNewRememberedSet;
	sqInt _isInPermToOldRememberedSet;

	/* begin isInRememberedSet: */
	/* begin getFromPermToNewSpaceRememberedSet */
	self_in_isInRememberedSet = GIV(fromPermToNewSpaceRememberedSet);
	/* end getFromPermToNewSpaceRememberedSet */
	for (_i = 0; _i < ((self_in_isInRememberedSet->rememberedSetSize)); _i += 1) {
		if (((self_in_isInRememberedSet->rememberedSetArray)[_i]) == _objOop) {
			_isInPermToNewRememberedSet = 1;
			goto l2;
		}
	}
	_isInPermToNewRememberedSet = 0;
	l2:
	;
	/* end isInRememberedSet: */
	/* begin isInRememberedSet: */
	/* begin getFromPermToOldSpaceRememberedSet */
	self_in_isInRememberedSet2 = GIV(fromPermToOldSpaceRememberedSet);
	/* end getFromPermToOldSpaceRememberedSet */
	for (_i2 = 0; _i2 < ((self_in_isInRememberedSet2->rememberedSetSize)); _i2 += 1) {
		if (((self_in_isInRememberedSet2->rememberedSetArray)[_i2]) == _objOop) {
			_isInPermToOldRememberedSet = 1;
			goto l3;
		}
	}
	_isInPermToOldRememberedSet = 0;
	l3:
	;
	/* end isInRememberedSet: */
	if (_isInPermToNewRememberedSet && (_refersNewSpace || _refersOldSpace)) {
		if (!(((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0)) {
			logError("Offending Object: %p", _objOop);
			error("Object should be marked as remembered");
			return 0;
		}
	}
	if (_refersNewSpace && !_isInPermToNewRememberedSet) {
		logError("Offending Object: %p", _objOop);
		error("Object should be in remembered set (Perm to New)");
		return 0;
	}
	if (_isInPermToNewRememberedSet && (!_refersNewSpace && !_refersOldSpace)) {
		logError("Offending Object: %p", _objOop);
		error("Object should not be in remembered set (Perm to New)");
		return 0;
	}
	if (_refersOldSpace && (!_isInPermToNewRememberedSet && !_isInPermToOldRememberedSet)) {
		logError("Offending Object: %p", _objOop);
		error("Object should not be in remembered set (Perm to Old)");
		return 0;
	}
	return 1;
}
/* SpurMemoryManager>>#isPinned: */
sqInt
isPinned(sqInt _objOop)
{
	return ((((usqInt) (longAt(_objOop)) ) >> (pinnedBitShift())) & 1) != 0;
}
/*	Answer if the argument has only fields that can hold oops. See comment in 
	formatOf:  */
/* SpurMemoryManager>>#isPointers: */
sqInt
isPointers(sqInt _oop)
{
	return ((_oop & (tagMask())) == 0) && (((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) <= 5);
}
/*	the inverse of isAnyPointerFormat: */
/* SpurMemoryManager>>#isPureBitsFormat: */
static sqInt NoDbgRegParms
isPureBitsFormat(sqInt _format)
{
	return (_format >= (sixtyFourBitIndexableFormat())) && (_format < (firstCompiledMethodFormat()));
}
/*	Answer if obj is young. Require that obj is non-immediate. Override to 
	filter-out Cog methods */
/* SpurMemoryManager>>#isReallyYoungObject: */
sqInt
isReallyYoungObject(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	assert(isNonImmediate(_objOop));
	return (oopisLessThan(_objOop, (GIV(memoryMap)->newSpaceEnd))) && (oopisGreaterThanOrEqualTo(_objOop, (GIV(memoryMap)->newSpaceStart)));
}
/*	Answer if oop is young. */
/* SpurMemoryManager>>#isReallyYoung: */
sqInt
isReallyYoung(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((_oop & (tagMask())) == 0) && ((assert(isNonImmediate(_oop)), (oopisLessThan(_oop, (GIV(memoryMap)->newSpaceEnd))) && (oopisGreaterThanOrEqualTo(_oop, (GIV(memoryMap)->newSpaceStart)))));
}
/* SpurMemoryManager>>#isRemembered: */
static sqInt NoDbgRegParms
isRemembered(sqInt _objOop)
{
	return ((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0;
}
/*	Maybe this should be in SpurSegmentManager only */
/* SpurMemoryManager>>#isSegmentBridge: */
static sqInt NoDbgRegParms
isSegmentBridge(sqInt _objOop)
{
	return ((longAt(_objOop)) & (classIndexMask())) == (segmentBridgePun());
}
/* SpurMemoryManager>>#isSemaphoreOop: */
static sqInt NoDbgRegParms
isSemaphoreOop(sqInt _anOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((_anOop & (tagMask())) == 0) && (((longAt(_anOop)) & (classIndexMask())) == (rawHashBitsOf(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassSemaphore ) << (shiftForWord())) )))));
}
/*	This version is private to SpurMemoryManager (for asserts, etc). It does 
	not take advantage of the power-of0two optimization in isForwarded:. */
/* SpurMemoryManager>>#isUnambiguouslyForwarder: */
sqInt
isUnambiguouslyForwarder(sqInt _objOop)
{
	return ((longAt(_objOop)) & (classIndexMask())) == (isForwardedObjectClassIndexPun());
}
/* SpurMemoryManager>>#isValidClassTag: */
sqInt
isValidClassTag(sqInt _classIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classOrNil;
	sqInt _classTablePage;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;

	assert((_classIndex >= 0) && (_classIndex <= ((1U << (classIndexFieldWidth())) - 1)));
	/* begin classOrNilAtIndex: */
	assert((_classIndex <= (tagMask())) || (_classIndex >= (arrayClassIndexPun())));
	/* begin fetchPointer:ofObject: */
	_fieldIndex = ((usqInt) _classIndex ) >> (classTableMajorIndexShift());
	_classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_classTablePage == GIV(nilObj)) {
		_classOrNil = GIV(nilObj);
		goto l3;
	}
	/* begin fetchPointer:ofObject: */
	_fieldIndex2 = _classIndex & ((1U << (classTableMajorIndexShift())) - 1);
	_classOrNil = unsignedLongAt((_classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	l3:
	;
	/* end classOrNilAtIndex: */
	return (_classOrNil != GIV(nilObj)) && (((uint32AtPointer(_classOrNil + 4)) & (identityHashHalfWordMask())) == _classIndex);
}
/*	Answer if the obj stack at objStackRootIndex is valid. */
/* SpurMemoryManager>>#isValidObjStackAt: */
static sqInt NoDbgRegParms
isValidObjStackAt(sqInt _objStackRootIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _stackOrNil;

	/* begin fetchPointer:ofObject: */
	_stackOrNil = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _objStackRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	return (_stackOrNil == GIV(nilObj)) || (isValidObjStackPagemyIndexfirstPage(_stackOrNil, _objStackRootIndex, 1));
}
/*	Just check the page itself. */
/* SpurMemoryManager>>#isValidObjStackPage:myIndex: */
static sqInt NoDbgRegParms
isValidObjStackPagemyIndex(sqInt _objStackPage, sqInt _myx)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (!(((longAt(_objStackPage)) & (classIndexMask())) == (sixtyFourBitLongsClassIndexPun()))) {
		GIV(objStackInvalidBecause) = "wrong class index";
		GIV(invalidObjStackPage) = _objStackPage;
		return 0;
	}
	if (!(((((usqInt) (longAt(_objStackPage)) ) >> (formatShift())) & (formatMask())) == (sixtyFourBitIndexableFormat()))) {
		GIV(objStackInvalidBecause) = "wrong format";
		GIV(invalidObjStackPage) = _objStackPage;
		return 0;
	}
	if (!((numSlotsOfAny(_objStackPage)) == ObjStackPageSlots)) {
		GIV(objStackInvalidBecause) = "wrong num slots";
		GIV(invalidObjStackPage) = _objStackPage;
		return 0;
	}
	if (!(_myx == (unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackMyx ) << (shiftForWord())) ))))) {
		GIV(objStackInvalidBecause) = "wrong myx";
		GIV(invalidObjStackPage) = _objStackPage;
		return 0;
	}
	if (GIV(marking) && (!(((((usqInt) (longAt(_objStackPage)) ) >> (markedBitFullShift())) & 1) != 0))) {
		GIV(objStackInvalidBecause) = "marking but page is unmarked";
		GIV(invalidObjStackPage) = _objStackPage;
		return 0;
	}
	return 1;
}
/*	Answer if the obj stack at stackRootIndex is valid. */
/* SpurMemoryManager>>#isValidObjStackPage:myIndex:firstPage: */
static sqInt NoDbgRegParms
isValidObjStackPagemyIndexfirstPage(sqInt _objStackPage, sqInt _myx, sqInt _isFirstPage)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _freeOrNextPage;
	sqInt _index;
	char *_ns;
	sqInt _page;

	if (!(isValidObjStackPagemyIndex(_objStackPage, _myx))) {
		return 0;
	}
	/* begin fetchPointer:ofObject: */
	_freeOrNextPage = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	while (_freeOrNextPage != 0) {
		if (!_isFirstPage) {
			GIV(objStackInvalidBecause) = "free page on other than first page";
			GIV(invalidObjStackPage) = _objStackPage;
			return 0;
		}
		if (_freeOrNextPage == (unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) )))) {
			GIV(objStackInvalidBecause) = "free page = next page";
			GIV(invalidObjStackPage) = _freeOrNextPage;
			return 0;
		}
		if (!(isValidObjStackPagemyIndex(_freeOrNextPage, _myx))) {
			{
				_ns = malloc(((strlen(GIV(objStackInvalidBecause))) + (strlen(", on next page"))) + 2);
				strcpy(_ns, GIV(objStackInvalidBecause));
				GIV(objStackInvalidBecause) = strcat(_ns, ", on next page");
			}
			return 0;
		}
		/* begin fetchPointer:ofObject: */
		_page = unsignedLongAt((_freeOrNextPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if ((_page == _freeOrNextPage) || (_page == _objStackPage)) {
			GIV(objStackInvalidBecause) = "circularity in free page list";
			GIV(invalidObjStackPage) = _page;
			return 0;
		}
		_freeOrNextPage = _page;
	}
	if (_isFirstPage) {
		if (!((_myx >= (1U << (22 - (classTableMajorIndexShift())))) && (_myx <= (((1U << (22 - (classTableMajorIndexShift()))) + 8) - 1)))) {
			GIV(objStackInvalidBecause) = "myx out of range";
			GIV(invalidObjStackPage) = _objStackPage;
			return 0;
		}
		if (!((unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _myx ) << (shiftForWord())) ))) == _objStackPage)) {
			GIV(objStackInvalidBecause) = "firstPage is not root";
			GIV(invalidObjStackPage) = _objStackPage;
			return 0;
		}
	}
	/* begin fetchPointer:ofObject: */
	_index = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (!((_index >= 0) && (_index <= ObjStackLimit))) {
		GIV(objStackInvalidBecause) = "bad topx";
		GIV(invalidObjStackPage) = _objStackPage;
		return 0;
	}
	/* begin fetchPointer:ofObject: */
	_freeOrNextPage = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_freeOrNextPage == 0) {
		return 1;
	}
	if (_freeOrNextPage == _objStackPage) {
		GIV(objStackInvalidBecause) = "circularity in objStack page list";
		GIV(invalidObjStackPage) = _objStackPage;
		return 0;
	}
	return isValidObjStackPagemyIndexfirstPage(_freeOrNextPage, _myx, 0);
}
/*	Answer if the obj stack at objStackRootIndex is valid. */
/* SpurMemoryManager>>#isValidObjStack: */
static sqInt NoDbgRegParms
isValidObjStack(sqInt _objStack)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (!((addressCouldBeObj(_objStack)) && ((numSlotsOfAny(_objStack)) == ObjStackPageSlots))) {
		GIV(objStackInvalidBecause) = "first page not obj or wrong size";
		GIV(invalidObjStackPage) = _objStack;
		return 0;
	}
	return isValidObjStackPagemyIndexfirstPage(_objStack, unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackMyx ) << (shiftForWord())) )), 1);
}
/* SpurMemoryManager>>#isValidToMoveToPermSpace: */
static sqInt NoDbgRegParms
isValidToMoveToPermSpace(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _fmt;

	if ((_objOop & (tagMask())) || ((_objOop >= GIV(nilObj)) && (_objOop <= GIV(trueObj)))) {
		return 0;
	}
	if (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		return 0;
	}
	if (((((usqInt) (longAt(_objOop)) ) >> (pinnedBitShift())) & 1) != 0) {
		return 0;
	}
	_fmt = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	return !((_fmt == (weakArrayFormat())) || (_fmt == 5));
}
/* SpurMemoryManager>>#isWeakFormat: */
static sqInt NoDbgRegParms
isWeakFormat(sqInt _format)
{
	return _format == (weakArrayFormat());
}
/* SpurMemoryManager>>#isWeakNonImm: */
static sqInt NoDbgRegParms
isWeakNonImm(sqInt _objOop)
{
	sqInt _format;

	/* begin isWeakFormat: */
	_format = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	return _format == (weakArrayFormat());
	/* end isWeakFormat: */
}
/*	Answer if the argument has only weak fields that can hold oops. See 
	comment in formatOf: */
/* SpurMemoryManager>>#isWeak: */
sqInt
isWeak(sqInt _oop)
{
	return ((_oop & (tagMask())) == 0) && (isWeakFormat((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())));
}
/*	Answer if the contains only indexable words or bytes (no oops). See 
	comment in formatOf:Note: Excludes CompiledMethods. */
/* SpurMemoryManager>>#isWordsOrBytes: */
sqInt
isWordsOrBytes(sqInt _oop)
{
	return ((_oop & (tagMask())) == 0) && (isPureBitsFormat((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())));
}
/*	Answer if the argument contains only indexable words (no oops). See 
	comment in formatOf: */
/* SpurMemoryManager>>#isWords: */
sqInt
isWords(sqInt _oop)
{
	return ((_oop & (tagMask())) == 0) && ((((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) >= (firstLongFormat())) && (((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) <= ((firstShortFormat()) - 1)));
}
/*	Answer if oop is young. */
/* SpurMemoryManager>>#isYoung: */
sqInt
isYoung(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((_oop & (tagMask())) == 0) && (((_oop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_oop >= ((GIV(memoryMap)->newSpaceStart))));
}
/*	Answer if oop is an instance of the given class. If the class has a 
	(non-zero) compactClassIndex use that to speed up the check. N.B. Inlining 
	should result in classOop not being accessed if oop's compact class index 
	and compactClassIndex are non-zero. */
/* SpurMemoryManager>>#is:instanceOf:compactClassIndex: */
static sqInt NoDbgRegParms
isinstanceOfcompactClassIndex(sqInt _oop, sqInt _classOop, sqInt _compactClassIndex)
{
	sqInt _ccIndex;

	if (_oop & (tagMask())) {
		return 0;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	assert(!(isImmediate(_oop)));
	/* begin classIndexOf: */
	_ccIndex = (longAt(_oop)) & (classIndexMask());
	/* end classIndexOf: */
	if (_compactClassIndex != 0) {
		return _compactClassIndex == _ccIndex;
	}
 else {
		return _classOop == (classAtIndex(_ccIndex));
	}
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
}
/* SpurMemoryManager>>#is:onObjStack: */
static sqInt NoDbgRegParms
isonObjStack(sqInt _oop, sqInt _objStack)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _index;
	sqInt _nextPage;

	if (_objStack == GIV(nilObj)) {
		return 0;
	}
	assert((numSlotsOfAny(_objStack)) == ObjStackPageSlots);
	_index = (unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ))) + ObjStackNextx;
	while (_index >= ObjStackFixedSlots) {
		if (_oop == (unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) )))) {
			return 1;
		}
		_index -= 1;
	}
	/* begin fetchPointer:ofObject: */
	_nextPage = unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_nextPage != 0) {
		if (isonObjStack(_oop, _nextPage)) {
			return 1;
		}
	}
	return 0;
}
/*	Answer the object the ephemeron guards. This is its first element. */
/* SpurMemoryManager>>#keyOfEphemeron: */
static sqInt NoDbgRegParms
keyOfEphemeron(sqInt _objOop)
{
	assert((isNonImmediate(_objOop)) && (isObjEphemeron(_objOop)));
	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((_objOop + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
}
/* SpurMemoryManager>>#knownClassAtIndex: */
static sqInt NoDbgRegParms
knownClassAtIndex(sqInt _classIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	assert((_classIndex >= 1) && (_classIndex <= (classTablePageSize())));
	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _classIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/* SpurMemoryManager>>#lastPointerFormat */
static sqInt
lastPointerFormat(void)
{
	return 5;
}
/*	Answer the byte offset of the last pointer field of the given object. 
	Works with CompiledMethods, as well as ordinary objects. 
	Does not examine the stack pointer of contexts to be sure to swizzle 
	the nils that fill contexts on snapshot. 
	It is invariant that on image load no object contains a forwarding 
	pointer, and the image contains no forwarders (see class comment). */
/* SpurMemoryManager>>#lastPointerOfWhileSwizzling: */
sqInt
lastPointerOfWhileSwizzling(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _fmt;
	sqInt _header;
	sqInt _header2;

	_fmt = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	assert(_fmt != (forwardedFormat()));
	if (_fmt <= 5) {
		return (((numSlotsOf(_objOop)) - 1) * BytesPerOop) + BaseHeaderSize;
	}
	if (_fmt < (firstCompiledMethodFormat())) {
		return 0;
	}
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_objOop));
	/* begin fetchPointer:ofObject: */
	_header2 = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header2 & 7) == 1)) {
		_header = _header2;
	} else {
		assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_header = ((((CogMethod *) _header2 ))->methodHeader);
	}
	/* end methodHeaderOf: */
	return (((((assert(((_header & 7) == 1)), (_header >> 3) & AlternateHeaderNumLiteralsMask)) + LiteralStart) - 1) * BytesPerOop) + BaseHeaderSize;
}
/*	Answer the byte offset of the last pointer field of the given object. 
	Works with CompiledMethods, as well as ordinary objects. */
/* SpurMemoryManager>>#lastPointerOf: */
sqInt
lastPointerOf(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _contextSize;
	sqInt _fmt;
	sqInt _header;
	sqInt _header2;
	sqInt _sp;

	_fmt = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	assert(_fmt != (forwardedFormat()));
	if (_fmt <= 5) {
		if ((_fmt == (indexablePointersFormat())) && (((longAt(_objOop)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
			/* begin fetchStackPointerOf: */
			/* begin fetchPointer:ofObject: */
			_sp = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (!(((_sp & 7) == 1))) {
				_contextSize = 0;
				goto l3;
			}
			assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_objOop)));
			_contextSize = _sp >> 3;
			l3:
			;
			/* end fetchStackPointerOf: */
			return (((CtxtTempFrameStart - 1) + _contextSize) * BytesPerOop) + BaseHeaderSize;
		}
		return (((numSlotsOf(_objOop)) - 1) * BytesPerOop) + BaseHeaderSize;
	}
	if (_fmt < (firstCompiledMethodFormat())) {
		return 0;
	}
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_objOop));
	/* begin fetchPointer:ofObject: */
	_header2 = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header2 & 7) == 1)) {
		_header = _header2;
	} else {
		assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_header = ((((CogMethod *) _header2 ))->methodHeader);
	}
	/* end methodHeaderOf: */
	return (((((assert(((_header & 7) == 1)), (_header >> 3) & AlternateHeaderNumLiteralsMask)) + LiteralStart) - 1) * BytesPerOop) + BaseHeaderSize;
}
/* SpurMemoryManager>>#leakCheckBecome */
sqInt
leakCheckBecome(void)
{
	return (checkForLeaks & GCModeBecome) != 0;
}
/* SpurMemoryManager>>#leakCheckFullGC */
sqInt
leakCheckFullGC(void)
{
	return (checkForLeaks & GCModeFull) != 0;
}
/* SpurMemoryManager>>#leakCheckIncremental */
sqInt
leakCheckIncremental(void)
{
	return (checkForLeaks & GCModeIncremental) != 0;
}
/* SpurMemoryManager>>#leakCheckNewSpaceGC */
sqInt
leakCheckNewSpaceGC(void)
{
	return (checkForLeaks & GCModeNewSpace) != 0;
}
/*	for the message send breakpoint; selectors can be immediates. */
/* SpurMemoryManager>>#lengthOfMaybeImmediate: */
static sqInt NoDbgRegParms
lengthOfMaybeImmediate(sqInt _oop)
{
	sqInt _fmt;
	usqInt _numSlots;
	usqInt _numSlots2;

	if (_oop & (tagMask())) {
		return 0;
	}
	/* begin lengthOf:format: */
	_fmt = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOfAny: */
	_numSlots2 = byteAt(_oop + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_oop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOfAny: */
	if (_fmt <= 5) {
		return _numSlots;
	}
	if (_fmt >= (firstByteFormat())) {
		return (_numSlots << (shiftForWord())) - (_fmt & 7);
	}
	if (_fmt >= (firstShortFormat())) {
		return (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
	}
	if (_fmt >= (firstLongFormat())) {
		return (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		return _numSlots;
	}
	return 0;
	/* end lengthOf:format: */
}
/*	Answer the number of indexable units in the given object. 
	For a CompiledMethod, the size of the method header (in bytes) should 
	be subtracted from the result. */
/* SpurMemoryManager>>#lengthOf: */
sqInt
lengthOf(sqInt _objOop)
{
	sqInt _fmt;
	usqInt _numSlots;
	usqInt _numSlots2;

	/* begin lengthOf:format: */
	_fmt = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOfAny: */
	_numSlots2 = byteAt(_objOop + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOfAny: */
	if (_fmt <= 5) {
		return _numSlots;
	}
	if (_fmt >= (firstByteFormat())) {
		return (_numSlots << (shiftForWord())) - (_fmt & 7);
	}
	if (_fmt >= (firstShortFormat())) {
		return (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
	}
	if (_fmt >= (firstLongFormat())) {
		return (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		return _numSlots;
	}
	return 0;
	/* end lengthOf:format: */
}
/* SpurMemoryManager>>#literalCountOfMethodHeader: */
sqInt
literalCountOfMethodHeader(sqInt _header)
{
	assert(((_header & 7) == 1));
	return (_header >> 3) & AlternateHeaderNumLiteralsMask;
}
/* SpurMemoryManager>>#literalCountOf: */
sqInt
literalCountOf(sqInt _methodPointer)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _header;
	sqInt _header2;

	/* begin literalCountOfMethodHeader: */
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_methodPointer));
	/* begin fetchPointer:ofObject: */
	_header2 = unsignedLongAt((_methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header2 & 7) == 1)) {
		_header = _header2;
	} else {
		assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_header = ((((CogMethod *) _header2 ))->methodHeader);
	}
	/* end methodHeaderOf: */
	assert(((_header & 7) == 1));
	return (_header >> 3) & AlternateHeaderNumLiteralsMask;
	/* end literalCountOfMethodHeader: */
}
/*	Scan the heap printing the oops of any and all objects that are instances 
	of aClassOop */
/* SpurMemoryManager>>#longPrintInstancesOf: */
void
longPrintInstancesOf(sqInt _aClassOop)
{
	sqInt _classIndex;

	_classIndex = (uint32AtPointer(_aClassOop + 4)) & (identityHashHalfWordMask());
	if (_classIndex != (isFreeObjectClassIndexPun())) {
		longPrintInstancesWithClassIndex(_classIndex);
	}
}
/*	Scan the heap printing any and all objects whose classIndex equals the 
	argument.  */
/* SpurMemoryManager>>#longPrintInstancesWithClassIndex: */
void
longPrintInstancesWithClassIndex(sqInt _classIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	/* begin allHeapEntitiesDo: */
	/* begin allOldSpaceEntitiesDo: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop2 = GIV(nilObj);
	while (1) {
		assert((_objOop2 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop2, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop2)) != 0);
		{
			if (((longAt(_objOop2)) & (classIndexMask())) == _classIndex) {
				{
					longPrintOop(_objOop2);
					/* begin cr */
					print("\n");
					/* end cr */
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop2;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop2 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop2 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceEntitiesDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop, _limit)) {
		{
			if (((longAt(_objOop)) & (classIndexMask())) == _classIndex) {
				{
					longPrintOop(_objOop);
					/* begin cr */
					print("\n");
					/* end cr */
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop = _limit;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop, GIV(freeStart))) {
		{
			if (((longAt(_objOop)) & (classIndexMask())) == _classIndex) {
				{
					longPrintOop(_objOop);
					/* begin cr */
					print("\n");
					/* end cr */
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (((longAt(_currentObject)) & (classIndexMask())) == _classIndex) {
					{
						longPrintOop(_currentObject);
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allHeapEntitiesDo: */
}
/*	Scan the heap long printing the oops of any and all objects that refer to 
	anOop  */
/* SpurMemoryManager>>#longPrintReferencesTo: */
void
longPrintReferencesTo(sqInt _anOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	sqInt _i;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots3;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;
	int _prntObj;

	_prntObj = 0;
	/* begin allObjectsDo: */
	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots3 = byteAt(_address + 7);
	_objOop2 = ((_numSlots3 == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop2, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if ((((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) <= 5) || (((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()))) {
					if (((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
						_i = (literalCountOfMethodHeader(methodHeaderOf(_objOop2))) + LiteralStart;
					} else {
						if (((longAt(_objOop2)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
							_i = CtxtTempFrameStart + (fetchStackPointerOf(_objOop2));
						} else {
							/* begin numSlotsOf: */
							assert((classIndexOf(_objOop2)) > (isForwardedObjectClassIndexPun()));
							_numSlots = byteAt(_objOop2 + 7);
							_i = ((_numSlots == (numSlotsMask()))
								 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop2 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
								 : _numSlots);
							/* end numSlotsOf: */
						}
					}
					while (((_i -= 1)) >= 0) {
						if (_anOop == (unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
							{
								printHex(_objOop2);
								print(" @ ");
								printNum(_i);
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_prntObj = 1;
							_i = 0;
						}
					}
					if (_prntObj) {
						_prntObj = 0;
						longPrintOop(_objOop2);
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop2 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if ((((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) <= 5) || (((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()))) {
					if (((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
						_i = (literalCountOfMethodHeader(methodHeaderOf(_objOop2))) + LiteralStart;
					} else {
						if (((longAt(_objOop2)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
							_i = CtxtTempFrameStart + (fetchStackPointerOf(_objOop2));
						} else {
							/* begin numSlotsOf: */
							assert((classIndexOf(_objOop2)) > (isForwardedObjectClassIndexPun()));
							_numSlots = byteAt(_objOop2 + 7);
							_i = ((_numSlots == (numSlotsMask()))
								 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop2 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
								 : _numSlots);
							/* end numSlotsOf: */
						}
					}
					while (((_i -= 1)) >= 0) {
						if (_anOop == (unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
							{
								printHex(_objOop2);
								print(" @ ");
								printNum(_i);
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_prntObj = 1;
							_i = 0;
						}
					}
					if (_prntObj) {
						_prntObj = 0;
						longPrintOop(_objOop2);
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop2 = GIV(freeStart);
			goto l9;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l9:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	/* begin allOldSpaceObjectsDo: */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop22 = GIV(nilObj);
	while (1) {
		assert((_objOop22 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop22)) != 0);
		{
			if (isEnumerableObject(_objOop22)) {
				{
					if ((((((usqInt) (longAt(_objOop22)) ) >> (formatShift())) & (formatMask())) <= 5) || (((((usqInt) (longAt(_objOop22)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()))) {
						if (((((usqInt) (longAt(_objOop22)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
							_i = (literalCountOfMethodHeader(methodHeaderOf(_objOop22))) + LiteralStart;
						} else {
							if (((longAt(_objOop22)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
								_i = CtxtTempFrameStart + (fetchStackPointerOf(_objOop22));
							} else {
								/* begin numSlotsOf: */
								assert((classIndexOf(_objOop22)) > (isForwardedObjectClassIndexPun()));
								_numSlots = byteAt(_objOop22 + 7);
								_i = ((_numSlots == (numSlotsMask()))
									 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop22 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
									 : _numSlots);
								/* end numSlotsOf: */
							}
						}
						while (((_i -= 1)) >= 0) {
							if (_anOop == (unsignedLongAt((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
								{
									printHex(_objOop22);
									print(" @ ");
									printNum(_i);
									/* begin cr */
									print("\n");
									/* end cr */
								}
								_prntObj = 1;
								_i = 0;
							}
						}
						if (_prntObj) {
							_prntObj = 0;
							longPrintOop(_objOop22);
						}
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop22 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	/* end allOldSpaceObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if ((((((usqInt) (longAt(_currentObject)) ) >> (formatShift())) & (formatMask())) <= 5) || (((((usqInt) (longAt(_currentObject)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()))) {
					if (((((usqInt) (longAt(_currentObject)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
						_i = (literalCountOfMethodHeader(methodHeaderOf(_currentObject))) + LiteralStart;
					} else {
						if (((longAt(_currentObject)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
							_i = CtxtTempFrameStart + (fetchStackPointerOf(_currentObject));
						} else {
							/* begin numSlotsOf: */
							assert((classIndexOf(_currentObject)) > (isForwardedObjectClassIndexPun()));
							_numSlots = byteAt(_currentObject + 7);
							_i = ((_numSlots == (numSlotsMask()))
								 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_currentObject - BaseHeaderSize)) ) << 8) ) ) ) >> 8
								 : _numSlots);
							/* end numSlotsOf: */
						}
					}
					while (((_i -= 1)) >= 0) {
						if (_anOop == (unsignedLongAt((_currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
							{
								printHex(_currentObject);
								print(" @ ");
								printNum(_i);
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_prntObj = 1;
							_i = 0;
						}
					}
					if (_prntObj) {
						_prntObj = 0;
						longPrintOop(_currentObject);
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
}
/* SpurMemoryManager>>#mapExtraRoots */
static void
mapExtraRoots(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _oop;

	if (shouldRemapObj(GIV(specialObjectsOop))) {
		GIV(specialObjectsOop) = remapObj(GIV(specialObjectsOop));
	}
	assert(GIV(remapBufferCount) == 0);
	for (_i = 1; _i <= GIV(extraRootCount); _i += 1) {
		_oop = GIV(extraRoots)[_i][0];
		if (!((_oop & (tagMask())) || (((longAt(_oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())))) {
			if (shouldRemapObj(_oop)) {
				GIV(extraRoots)[_i][0] = remapObj(_oop);
			}
		}
	}
}
/* SpurMemoryManager>>#mapMournQueue */
static void NeverInline
mapMournQueue(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i2;
	sqInt _mourner;
	sqInt _numOnThisPage;
	sqInt _objStackPage;
	sqInt _referent;

	/* begin objStack:do: */
	if (GIV(mournQueue) == GIV(nilObj)) {
		goto l8;
	}
	eassert(isValidObjStack(GIV(mournQueue)));
	_objStackPage = GIV(mournQueue);
	while (_objStackPage != 0) {
		/* begin fetchPointer:ofObject: */
		_numOnThisPage = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		for (_i2 = (_numOnThisPage + ObjStackFixedSlots) - 1; _i2 >= ObjStackFixedSlots; _i2 += -1) {
			{
				/* begin fetchPointer:ofObject: */
				_mourner = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) _i2 ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if ((_mourner & (tagMask())) == 0) {
					if (((long64At(_mourner)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
						/* begin followForwarded: */
						assert(isUnambiguouslyForwarder(_mourner));
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent = unsignedLongAt((_mourner + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
						while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
							/* begin fetchPointer:ofMaybeForwardedObject: */
							_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
							/* end fetchPointer:ofMaybeForwardedObject: */
						}
						_mourner = _referent;
						/* end followForwarded: */
					}
					if (!(isScavengeSurvivor(_mourner))) {
						_mourner = copyAndForwardMourner(_mourner);
					}
					{
						assert(!(isOopForwarded(_objStackPage)));
						longAtput((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) _i2 ) << (shiftForWord())) ), _mourner);
					}
				}
			}
		}
		/* begin fetchPointer:ofObject: */
		_objStackPage = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
	}
	l8:
	;
	/* end objStack:do: */
}
/*	Helper for markAndTrace:. 
	Mark the argument, and answer if its fields should be scanned now. 
	Immediate objects don't need to be marked. 
	Already marked objects have already been processed. 
	Pure bits objects don't need scanning, although their class does. 
	Weak objects should be pushed on the weakling stack. 
	TODO: something about ephemerons. 
	Anything else need scanning. */
/* SpurMemoryManager>>#markAndShouldScan: */
static sqInt NoDbgRegParms
markAndShouldScan(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _format;
	sqInt _objStack;

	if (_objOop & (tagMask())) {
		return 0;
	}
	assert(!(isForwarded(_objOop)));
	if (((((usqInt) (longAt(_objOop)) ) >> (markedBitFullShift())) & 1) != 0) {
		assert(!(isPermanentObject(GIV(memoryMap), _objOop)));
		return 0;
	}
	if (!(_objOop >= 0x20000000000LL)) {
		/* begin setIsMarkedOf:to: */
		assert(!(isFreeObject(_objOop)));
		unsignedLongAtput(_objOop, (unsignedLongAt(_objOop)) | (1ULL << (markedBitFullShift())));
		/* end setIsMarkedOf:to: */
	}
	_format = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	if ((_format >= (sixtyFourBitIndexableFormat())) && (_format < (firstCompiledMethodFormat()))) {
		if (((longAt(_objOop)) & (classIndexMask())) > (lastClassIndexPun())) {
			markAndTraceClassOf(_objOop);
		}
		return 0;
	}
	if (_format == (weakArrayFormat())) {
		/* begin push:onObjStack: */
		_objStack = GIV(weaklingStack);
		assert(addressCouldBeOop(_objOop));
		if (_objOop & (tagMask())) {
			assert(_objStack == GIV(markStack));
			assert(addressCouldBeObj(topOfObjStack(((0 == (fetchPointerofObject(ObjStackTopx, _objStack)))
				 ? fetchPointerofObject(ObjStackNextx, _objStack)
				 : _objStack))));
		}
 else {
			assert(!((_objStack == GIV(markStack)) && (isWeakNonImm(_objOop))));
			assert((_objStack != GIV(weaklingStack)) || (isWeakNonImm(_objOop)));
		}
		noCheckPushonObjStack(_objOop, _objStack);
		/* end push:onObjStack: */
		return 0;
	}
	if ((_format == 5) && (activeAndDeferredScan(_objOop))) {
		return 0;
	}
	return 1;
}
/*	Ensure the class of the argument is marked, pushing it on the markStack if 
	not already marked. 
	And for one-way become, which can create duplicate entries in the class 
	table, make sure 
	objOop's classIndex refers to the classObj's actual classIndex. 
	Note that this is recursive, but the metaclass chain should terminate 
	quickly.  */
/* SpurMemoryManager>>#markAndTraceClassOf: */
static void NoDbgRegParms
markAndTraceClassOf(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classIndex;
	sqInt _classObj;
	sqInt _classTablePage;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;
	sqInt _objStack;
	sqInt _realClassIndex;

	/* begin classIndexOf: */
	_classIndex = (longAt(_objOop)) & (classIndexMask());
	/* end classIndexOf: */
	/* begin classOrNilAtIndex: */
	assert((_classIndex <= (tagMask())) || (_classIndex >= (arrayClassIndexPun())));
	/* begin fetchPointer:ofObject: */
	_fieldIndex = ((usqInt) _classIndex ) >> (classTableMajorIndexShift());
	_classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_classTablePage == GIV(nilObj)) {
		_classObj = GIV(nilObj);
		goto l5;
	}
	/* begin fetchPointer:ofObject: */
	_fieldIndex2 = _classIndex & ((1U << (classTableMajorIndexShift())) - 1);
	_classObj = unsignedLongAt((_classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	l5:
	;
	/* end classOrNilAtIndex: */
	assert(objCouldBeClassObj(_classObj));
	_realClassIndex = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask());
	if ((_classIndex != _realClassIndex) && (_classIndex > (lastClassIndexPun()))) {
		/* begin setClassIndexOf:to: */
		assert((_realClassIndex >= 0) && (_realClassIndex <= (classIndexMask())));
		longAtput(_objOop, ((longAt(_objOop)) & (~((usqIntptr_t) (classIndexMask()) ))) + _realClassIndex);
		/* end setClassIndexOf:to: */
	}
	if (!((((((usqInt) (longAt(_classObj)) ) >> (markedBitFullShift())) & 1) != 0) || (((_classObj & (tagMask())) == 0) && (_classObj >= 0x20000000000LL)))) {
		/* begin setIsMarkedOf:to: */
		assert(!(isFreeObject(_classObj)));
		unsignedLongAtput(_classObj, (unsignedLongAt(_classObj)) | (1ULL << (markedBitFullShift())));
		/* end setIsMarkedOf:to: */
		markAndTraceClassOf(_classObj);
		/* begin push:onObjStack: */
		_objStack = GIV(markStack);
		assert(addressCouldBeOop(_classObj));
		if (_classObj & (tagMask())) {
			assert(_objStack == GIV(markStack));
			assert(addressCouldBeObj(topOfObjStack(((0 == (fetchPointerofObject(ObjStackTopx, _objStack)))
				 ? fetchPointerofObject(ObjStackNextx, _objStack)
				 : _objStack))));
		}
 else {
			assert(!((_objStack == GIV(markStack)) && (isWeakNonImm(_classObj))));
			assert((_objStack != GIV(weaklingStack)) || (isWeakNonImm(_classObj)));
		}
		noCheckPushonObjStack(_classObj, _objStack);
		/* end push:onObjStack: */
	}
}
/*	The hidden roots hold both the class table pages and the obj stacks, 
	and hence need special treatment. The obj stacks must be marked 
	specially; their pages must be marked, but only the contents of the 
	mournQueue should be marked. 
	 
	If a class table page is weak we can mark and trace the hiddenRoots, 
	which will not trace through class table pages because they are weak. 
	But if class table pages are strong, we must mark the pages and *not* 
	trace them so that only classes reachable from the true roots will be 
	marked, and unreachable classes will be left unmarked. */
/* SpurMemoryManager>>#markAndTraceHiddenRoots */
static void
markAndTraceHiddenRoots(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMRememberedSet *_aRememberedSet;
	VMRememberedSet *_aRememberedSet2;
	sqInt _i;
	sqInt _i2;
	sqInt _i3;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _objOop3;
	sqInt _objOop4;
	sqInt _objOop5;
	sqInt _objStackRootIndex;
	sqInt _objStackRootIndex2;
	sqInt _rememberedSetOop;
	sqInt _rememberedSetOop2;

	markAndTraceObjStackandContents(GIV(markStack), 0);
	markAndTraceObjStackandContents(GIV(weaklingStack), 0);
	markAndTraceObjStackandContents(GIV(mournQueue), 1);
	cleanUpPermToOldSpaceRememeberedSet();
	cleanUpPermToNewSpaceRememeberedSet();
	/* begin markAndTraceRememberedSet: */
	/* begin getFromPermToOldSpaceRememberedSet */
	_aRememberedSet = GIV(fromPermToOldSpaceRememberedSet);
	/* end getFromPermToOldSpaceRememberedSet */
	/* begin objStackAt: */
	_objStackRootIndex = (_aRememberedSet->rootIndex);
	/* begin fetchPointer:ofObject: */
	_rememberedSetOop = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _objStackRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end objStackAt: */
	/* begin setIsMarkedOf:to: */
	assert(!(isFreeObject(_rememberedSetOop)));
	unsignedLongAtput(_rememberedSetOop, (unsignedLongAt(_rememberedSetOop)) | (1ULL << (markedBitFullShift())));
	/* end setIsMarkedOf:to: */
	/* begin rememberedSetWithIndexDo: */
	/* begin rememberedSetWithIndexDo:startingAt: */
	for (_i2 = 0; _i2 < ((_aRememberedSet->rememberedSetSize)); _i2 += 1) {
		{
			_objOop4 = (_aRememberedSet->rememberedSetArray)[_i2];
			markAndTrace(_objOop4);
		}
	}
	/* end rememberedSetWithIndexDo:startingAt: */
	/* end rememberedSetWithIndexDo: */
	/* end markAndTraceRememberedSet: */
	/* begin markAndTraceRememberedSet: */
	/* begin getFromPermToNewSpaceRememberedSet */
	_aRememberedSet2 = GIV(fromPermToNewSpaceRememberedSet);
	/* end getFromPermToNewSpaceRememberedSet */
	/* begin objStackAt: */
	_objStackRootIndex2 = (_aRememberedSet2->rootIndex);
	/* begin fetchPointer:ofObject: */
	_rememberedSetOop2 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _objStackRootIndex2 ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end objStackAt: */
	/* begin setIsMarkedOf:to: */
	assert(!(isFreeObject(_rememberedSetOop2)));
	unsignedLongAtput(_rememberedSetOop2, (unsignedLongAt(_rememberedSetOop2)) | (1ULL << (markedBitFullShift())));
	/* end setIsMarkedOf:to: */
	/* begin rememberedSetWithIndexDo: */
	/* begin rememberedSetWithIndexDo:startingAt: */
	for (_i3 = 0; _i3 < ((_aRememberedSet2->rememberedSetSize)); _i3 += 1) {
		{
			_objOop5 = (_aRememberedSet2->rememberedSetArray)[_i3];
			markAndTrace(_objOop5);
		}
	}
	/* end rememberedSetWithIndexDo:startingAt: */
	/* end rememberedSetWithIndexDo: */
	/* end markAndTraceRememberedSet: */
	/* begin setIsMarkedOf:to: */
	assert(!(isFreeObject(GIV(nilObj))));
	unsignedLongAtput(GIV(nilObj), (unsignedLongAt(GIV(nilObj))) | (1ULL << (markedBitFullShift())));
	/* end setIsMarkedOf:to: */
	/* begin setIsMarkedOf:to: */
	assert(!(isFreeObject(GIV(trueObj))));
	unsignedLongAtput(GIV(trueObj), (unsignedLongAt(GIV(trueObj))) | (1ULL << (markedBitFullShift())));
	/* end setIsMarkedOf:to: */
	/* begin setIsMarkedOf:to: */
	assert(!(isFreeObject(GIV(falseObj))));
	unsignedLongAtput(GIV(falseObj), (unsignedLongAt(GIV(falseObj))) | (1ULL << (markedBitFullShift())));
	/* end setIsMarkedOf:to: */
	/* begin setIsMarkedOf:to: */
	_objOop2 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) OldRememberedSetRootIndex ) << (shiftForWord())) ));
	assert(!(isFreeObject(_objOop2)));
	unsignedLongAtput(_objOop2, (unsignedLongAt(_objOop2)) | (1ULL << (markedBitFullShift())));
	/* end setIsMarkedOf:to: */
	/* begin setIsMarkedOf:to: */
	{
		assert((firstIndexableField(oldSpaceObjectAfter(GIV(trueObj)))) == GIV(freeLists));
		_objOop3 = oldSpaceObjectAfter(GIV(trueObj));
	}
	assert(!(isFreeObject(_objOop3)));
	unsignedLongAtput(_objOop3, (unsignedLongAt(_objOop3)) | (1ULL << (markedBitFullShift())));
	/* end setIsMarkedOf:to: */
	if (isWeakFormat((((usqInt) (longAt(GIV(classTableFirstPage))) ) >> (formatShift())) & (formatMask()))) {
		{
			markAndTrace(GIV(hiddenRootsObj));
			return;
		}
	}
	/* begin setIsMarkedOf:to: */
	assert(!(isFreeObject(GIV(hiddenRootsObj))));
	unsignedLongAtput(GIV(hiddenRootsObj), (unsignedLongAt(GIV(hiddenRootsObj))) | (1ULL << (markedBitFullShift())));
	/* end setIsMarkedOf:to: */
	markAndTrace(GIV(classTableFirstPage));
	for (_i = 1; _i < GIV(numClassTablePages); _i += 1) {
		/* begin setIsMarkedOf:to: */
		_objOop = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		assert(!(isFreeObject(_objOop)));
		unsignedLongAtput(_objOop, (unsignedLongAt(_objOop)) | (1ULL << (markedBitFullShift())));
		/* end setIsMarkedOf:to: */
	}
}
/*	An obj stack is a stack of objects stored in a hidden root slot, such 
	as the markStack or the ephemeronQueue. It is a linked list of 
	segments, with the hot end at the head of the list. It is a word object. 
	The stack pointer is in ObjStackTopx and 0 means empty. */
/* SpurMemoryManager>>#markAndTraceObjStack:andContents: */
static void NoDbgRegParms
markAndTraceObjStackandContents(sqInt _stackOrNil, sqInt _markAndTraceContents)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _field;
	sqInt _index;
	sqInt _objOop;

	if (_stackOrNil == GIV(nilObj)) {
		return;
	}
	/* begin setIsMarkedOf:to: */
	assert(!(isFreeObject(_stackOrNil)));
	unsignedLongAtput(_stackOrNil, (unsignedLongAt(_stackOrNil)) | (1ULL << (markedBitFullShift())));
	/* end setIsMarkedOf:to: */
	assert((numSlotsOfAny(_stackOrNil)) == ObjStackPageSlots);
	/* begin fetchPointer:ofObject: */
	_field = unsignedLongAt((_stackOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_field != 0) {
		markAndTraceObjStackandContents(_field, _markAndTraceContents);
	}
	_field = _stackOrNil;
	while (1) {
		/* begin fetchPointer:ofObject: */
		_field = unsignedLongAt((_field + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (!(_field != 0)) 
			break;
		/* begin setIsMarkedOf:to: */
		assert(!(isFreeObject(_field)));
		unsignedLongAtput(_field, (unsignedLongAt(_field)) | (1ULL << (markedBitFullShift())));
		/* end setIsMarkedOf:to: */
	}
	if (!_markAndTraceContents) {
		return;
	}
	_index = (unsignedLongAt((_stackOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ))) + ObjStackNextx;
	while (_index >= ObjStackFixedSlots) {
		/* begin followObjField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop = unsignedLongAt((_stackOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert(isNonImmediate(_objOop));
		if (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
			_objOop = fixFollowedFieldofObjectwithInitialValue(_index, _stackOrNil, _objOop);
		}
		_field = _objOop;
		/* end followObjField:ofObject: */
		if (!(_field & (tagMask()))) {
			markAndTrace(_field);
		}
		_index -= 1;
	}
}
/*	Mark the argument, and all objects reachable from it. 
	Marking works as a breadth-first search using a stack. 
	When an object is visited, its refered objects are put in the stack. 
	 
	Then, objects in the stack are taken one by one and visited as above. 
	Finish when the stack is empty. 
	 
	As a side effect, if the mark stack was not previously empty, it will be 
	emptied. Important: Follow forwarding pointers in the scan. */
/* SpurMemoryManager>>#markAndTrace: */
void NeverInline
markAndTrace(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classFormat;
	sqInt _contextSize;
	sqInt _field;
	sqInt _fmt;
	sqInt _format;
	sqInt _format2;
	sqInt _header;
	sqInt _header2;
	sqInt _index;
	sqInt _key;
	sqInt _key2;
	sqInt _numLiterals;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots3;
	usqInt _numStrongSlots;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _objOop3;
	sqInt _objStack;
	sqInt _objStack2;
	sqInt _objStack3;
	sqInt _objStack4;
	sqInt _objStack5;
	sqInt _objStack6;
	sqInt _objToScan;
	int _scanLargeObject;
	sqInt _sp;

	_numStrongSlots = 0;
	{
		if (_objOop & (tagMask())) {
			{
				return;
			}
		}
		assert(!(isForwarded(_objOop)));
		if (((((usqInt) (longAt(_objOop)) ) >> (markedBitFullShift())) & 1) != 0) {
			assert(!(isPermanentObject(GIV(memoryMap), _objOop)));
			{
				return;
			}
		}
		if (!(_objOop >= 0x20000000000LL)) {
			/* begin setIsMarkedOf:to: */
			assert(!(isFreeObject(_objOop)));
			unsignedLongAtput(_objOop, (unsignedLongAt(_objOop)) | (1ULL << (markedBitFullShift())));
			/* end setIsMarkedOf:to: */
		}
		_format = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
		if ((_format >= (sixtyFourBitIndexableFormat())) && (_format < (firstCompiledMethodFormat()))) {
			if (((longAt(_objOop)) & (classIndexMask())) > (lastClassIndexPun())) {
				markAndTraceClassOf(_objOop);
			}
			{
				return;
			}
		}
		if (_format == (weakArrayFormat())) {
			/* begin push:onObjStack: */
			_objStack = GIV(weaklingStack);
			assert(addressCouldBeOop(_objOop));
			if (_objOop & (tagMask())) {
				assert(_objStack == GIV(markStack));
				assert(addressCouldBeObj(topOfObjStack(((0 == (fetchPointerofObject(ObjStackTopx, _objStack)))
					 ? fetchPointerofObject(ObjStackNextx, _objStack)
					 : _objStack))));
			}
 else {
				assert(!((_objStack == GIV(markStack)) && (isWeakNonImm(_objOop))));
				assert((_objStack != GIV(weaklingStack)) || (isWeakNonImm(_objOop)));
			}
			noCheckPushonObjStack(_objOop, _objStack);
			/* end push:onObjStack: */
			{
				return;
			}
		}
		if ((_format == 5) && (activeAndDeferredScan(_objOop))) {
			{
				return;
			}
		}
	}
	/* begin markLoopFrom: */
	_objToScan = _objOop;
	do {
		if (_objToScan & (tagMask())) {
			_scanLargeObject = 1;
		} else {
			if ((isEphemeron(_objToScan)) && ((isImmediate((_key = keyOfEphemeron(_objToScan)))) || ((((((usqInt) (longAt(_key)) ) >> (markedBitFullShift())) & 1) != 0) || (((_key & (tagMask())) == 0) && (_key >= 0x20000000000LL))))) {
				/* begin numSlotsOf: */
				assert((classIndexOf(_objToScan)) > (isForwardedObjectClassIndexPun()));
				_numSlots = byteAt(_objToScan + 7);
				_numStrongSlots = ((_numSlots == (numSlotsMask()))
					 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objToScan - BaseHeaderSize)) ) << 8) ) ) ) >> 8
					 : _numSlots);
				/* end numSlotsOf: */
			} else {
				/* begin numStrongSlotsOfInephemeral: */
				_fmt = (((usqInt) (longAt(_objToScan)) ) >> (formatShift())) & (formatMask());
				assert((_fmt != (ephemeronFormat())) || ((isImmediate((_key2 = keyOfEphemeron(_objToScan)))) || (isMarkedOrPermanent(_key2))));
				if (_fmt <= 5) {
					/* begin numSlotsOf: */
					assert((classIndexOf(_objToScan)) > (isForwardedObjectClassIndexPun()));
					_numSlots2 = byteAt(_objToScan + 7);
					_numSlots3 = ((_numSlots2 == (numSlotsMask()))
						 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objToScan - BaseHeaderSize)) ) << 8) ) ) ) >> 8
						 : _numSlots2);
					/* end numSlotsOf: */
					if (_fmt <= 2) {
						_numStrongSlots = ((sqInt) _numSlots3 );
						goto l16;
					}
					if (_fmt == (indexablePointersFormat())) {
						if (((longAt(_objToScan)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
							setTraceFlagOnContextsFramesPageIfNeeded(_objToScan);
							/* begin fetchStackPointerOf: */
							/* begin fetchPointer:ofObject: */
							_sp = unsignedLongAt((_objToScan + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							if (!(((_sp & 7) == 1))) {
								_contextSize = 0;
								goto l11;
							}
							assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_objToScan)));
							_contextSize = _sp >> 3;
							l11:
							;
							/* end fetchStackPointerOf: */
							_numStrongSlots = CtxtTempFrameStart + _contextSize;
							goto l16;
						}
						_numStrongSlots = ((sqInt) _numSlots3 );
						goto l16;
					}
					if (_fmt == (weakArrayFormat())) {
						/* begin fixedFieldsOfClass: */
						_objOop22 = fetchClassOfNonImm(_objToScan);
						/* begin fixedFieldsOfClassFormat: */
						_classFormat = (unsignedLongAt((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
						_numStrongSlots = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
						goto l16;
						/* end fixedFieldsOfClassFormat: */
						/* end fixedFieldsOfClass: */
					}
				}
				if (_fmt == 7) {
					_numStrongSlots = 1;
					goto l16;
				}
				if (_fmt < (firstCompiledMethodFormat())) {
					_numStrongSlots = 0;
					goto l16;
				}
				/* begin methodHeaderOf: */
				assert(isCompiledMethod(_objToScan));
				/* begin fetchPointer:ofObject: */
				_header2 = unsignedLongAt((_objToScan + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_header2 & 7) == 1)) {
					_header = _header2;
				} else {
					assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
					assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
					_header = ((((CogMethod *) _header2 ))->methodHeader);
				}
				/* end methodHeaderOf: */
				{
					assert(((_header & 7) == 1));
					_numLiterals = (_header >> 3) & AlternateHeaderNumLiteralsMask;
				}
				_numStrongSlots = _numLiterals + LiteralStart;
				l16:
				;
				/* end numStrongSlotsOfInephemeral: */
			}
			_scanLargeObject = _numStrongSlots > 64;
		}
		if (_scanLargeObject) {
			if (_objToScan & (tagMask())) {
				_index = _objToScan >> 3;
				_objToScan = topOfObjStack(GIV(markStack));
			} else {
				_index = _numStrongSlots;
				markAndTraceClassOf(_objToScan);
			}
			while (_index > 0) {
				_index -= 1;
				/* begin fetchPointer:ofObject: */
				_field = unsignedLongAt((_objToScan + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_field & (tagMask())) == 0) && (!(((_field & (tagMask())) == 0) && (_field >= 0x20000000000LL)))) {
					if (((long64At(_field)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
						_field = fixFollowedFieldofObjectwithInitialValue(_index, _objToScan, _field);
					}
					{
						if (_field & (tagMask())) {
							goto l4;
						}
						assert(!(isForwarded(_field)));
						if (((((usqInt) (longAt(_field)) ) >> (markedBitFullShift())) & 1) != 0) {
							assert(!(isPermanentObject(GIV(memoryMap), _field)));
							goto l4;
						}
						if (!(_field >= 0x20000000000LL)) {
							/* begin setIsMarkedOf:to: */
							assert(!(isFreeObject(_field)));
							unsignedLongAtput(_field, (unsignedLongAt(_field)) | (1ULL << (markedBitFullShift())));
							/* end setIsMarkedOf:to: */
						}
						_format2 = (((usqInt) (longAt(_field)) ) >> (formatShift())) & (formatMask());
						if ((_format2 >= (sixtyFourBitIndexableFormat())) && (_format2 < (firstCompiledMethodFormat()))) {
							if (((longAt(_field)) & (classIndexMask())) > (lastClassIndexPun())) {
								markAndTraceClassOf(_field);
							}
							goto l4;
						}
						if (_format2 == (weakArrayFormat())) {
							/* begin push:onObjStack: */
							_objStack6 = GIV(weaklingStack);
							assert(addressCouldBeOop(_field));
							if (_field & (tagMask())) {
								assert(_objStack6 == GIV(markStack));
								assert(addressCouldBeObj(topOfObjStack(((0 == (fetchPointerofObject(ObjStackTopx, _objStack6)))
									 ? fetchPointerofObject(ObjStackNextx, _objStack6)
									 : _objStack6))));
							}
 else {
								assert(!((_objStack6 == GIV(markStack)) && (isWeakNonImm(_field))));
								assert((_objStack6 != GIV(weaklingStack)) || (isWeakNonImm(_field)));
							}
							noCheckPushonObjStack(_field, _objStack6);
							/* end push:onObjStack: */
							goto l4;
						}
						if ((_format2 == 5) && (activeAndDeferredScan(_field))) {
							goto l4;
						}
						if (_index > 0) {
							if ((topOfObjStack(GIV(markStack))) != _objToScan) {
								/* begin push:onObjStack: */
								_objStack2 = GIV(markStack);
								assert(addressCouldBeOop(_objToScan));
								if (_objToScan & (tagMask())) {
									assert(_objStack2 == GIV(markStack));
									assert(addressCouldBeObj(topOfObjStack(((0 == (fetchPointerofObject(ObjStackTopx, _objStack2)))
										 ? fetchPointerofObject(ObjStackNextx, _objStack2)
										 : _objStack2))));
								}
 else {
									assert(!((_objStack2 == GIV(markStack)) && (isWeakNonImm(_objToScan))));
									assert((_objStack2 != GIV(weaklingStack)) || (isWeakNonImm(_objToScan)));
								}
								noCheckPushonObjStack(_objToScan, _objStack2);
								/* end push:onObjStack: */
							}
							/* begin push:onObjStack: */
							_objOop2 = ((((usqInt) _index ) << 3) | 1);
							_objStack3 = GIV(markStack);
							assert(addressCouldBeOop(_objOop2));
							if (_objOop2 & (tagMask())) {
								assert(_objStack3 == GIV(markStack));
								assert(addressCouldBeObj(topOfObjStack(((0 == (fetchPointerofObject(ObjStackTopx, _objStack3)))
									 ? fetchPointerofObject(ObjStackNextx, _objStack3)
									 : _objStack3))));
							}
 else {
								assert(!((_objStack3 == GIV(markStack)) && (isWeakNonImm(_objOop2))));
								assert((_objStack3 != GIV(weaklingStack)) || (isWeakNonImm(_objOop2)));
							}
							noCheckPushonObjStack(_objOop2, _objStack3);
							/* end push:onObjStack: */
						}
						_objToScan = _field;
						_index = -1;
						l4:
						;
					}
				}
			}
			if (_index >= 0) {
				_objToScan = popObjStack(GIV(markStack));
				if (_objToScan == _objOop) {
					_objToScan = popObjStack(GIV(markStack));
				}
			}
		} else {
			_index = _numStrongSlots;
			markAndTraceClassOf(_objToScan);
			while (_index > 0) {
				_index -= 1;
				/* begin fetchPointer:ofObject: */
				_field = unsignedLongAt((_objToScan + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if ((_field & (tagMask())) == 0) {
					if (((long64At(_field)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
						_field = fixFollowedFieldofObjectwithInitialValue(_index, _objToScan, _field);
					}
					if ((!(((_field & (tagMask())) == 0) && (_field >= 0x20000000000LL))) && (markAndShouldScan(_field))) {
						/* begin push:onObjStack: */
						_objStack5 = GIV(markStack);
						assert(addressCouldBeOop(_field));
						if (_field & (tagMask())) {
							assert(_objStack5 == GIV(markStack));
							assert(addressCouldBeObj(topOfObjStack(((0 == (fetchPointerofObject(ObjStackTopx, _objStack5)))
								 ? fetchPointerofObject(ObjStackNextx, _objStack5)
								 : _objStack5))));
						}
 else {
							assert(!((_objStack5 == GIV(markStack)) && (isWeakNonImm(_field))));
							assert((_objStack5 != GIV(weaklingStack)) || (isWeakNonImm(_field)));
						}
						noCheckPushonObjStack(_field, _objStack5);
						/* end push:onObjStack: */
						if (((byteAt(_field + 7)) > 64) && (((_numStrongSlots = numStrongSlotsOfInephemeral(_field))) > 64)) {
							/* begin push:onObjStack: */
							_objOop3 = ((_numStrongSlots << 3) | 1);
							_objStack4 = GIV(markStack);
							assert(addressCouldBeOop(_objOop3));
							if (_objOop3 & (tagMask())) {
								assert(_objStack4 == GIV(markStack));
								assert(addressCouldBeObj(topOfObjStack(((0 == (fetchPointerofObject(ObjStackTopx, _objStack4)))
									 ? fetchPointerofObject(ObjStackNextx, _objStack4)
									 : _objStack4))));
							}
 else {
								assert(!((_objStack4 == GIV(markStack)) && (isWeakNonImm(_objOop3))));
								assert((_objStack4 != GIV(weaklingStack)) || (isWeakNonImm(_objOop3)));
							}
							noCheckPushonObjStack(_objOop3, _objStack4);
							/* end push:onObjStack: */
						}
					}
				}
			}
			_objToScan = popObjStack(GIV(markStack));
		}
	} while (_objToScan != null);
	/* end markLoopFrom: */
}
/*	Go through the unscanned ephemerons, marking the inactive ones, and 
	removing them from the unscanned ephemerons. 
	Answer true if any inactive ones were found. 
	Answer false if all unscanned ephemerons are active one (that could be 
	fired).  
	We cannot fire the ephemerons until all are found to 
	be active since scan-marking an inactive ephemeron later in the set may 
	render a previously-observed ephemeron (that remains in 
	unscannedEphemerons) as inactive. 
	 
	Note: the current vocabulary *active* and *inactive* is insane, and badly 
	defined because it mixes *possibly* and *certainly*. 
	 */
/* SpurMemoryManager>>#markInactiveEphemerons */
static sqInt
markInactiveEphemerons(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _ephemeron;
	int _foundInactive;
	sqInt _key;
	sqInt _objOop;
	sqInt _oop;
	usqInt _ptr;

	_foundInactive = 0;
	_ptr = (GIV(unscannedEphemerons)->start);
	while (_ptr < ((GIV(unscannedEphemerons)->top))) {
		/* begin followedKeyOfEphemeron: */
		_objOop = (_ephemeron = longAt(_ptr));
		assert((isNonImmediate(_objOop)) && (isEphemeron(_objOop)));
		/* begin followOopField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_oop = unsignedLongAt((_objOop + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofObject: */
		if (((_oop & (tagMask())) == 0) && (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_oop = fixFollowedFieldofObjectwithInitialValue(0, _objOop, _oop);
		}
		_key = _oop;
		/* end followOopField:ofObject: */
		/* end followedKeyOfEphemeron: */
		if ((_key & (tagMask())) || ((((((usqInt) (longAt(_key)) ) >> (markedBitFullShift())) & 1) != 0) || (((_key & (tagMask())) == 0) && (_key >= 0x20000000000LL)))) {
			_foundInactive = 1;
			(GIV(unscannedEphemerons)->top = ((GIV(unscannedEphemerons)->top)) - BytesPerOop);
			if (((GIV(unscannedEphemerons)->top)) > _ptr) {
				longAtput(_ptr, longAt((GIV(unscannedEphemerons)->top)));
			}
			/* begin setIsMarkedOf:to: */
			assert(!(isFreeObject(_ephemeron)));
			unsignedLongAtput(_ephemeron, (unsignedLongAt(_ephemeron)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
			/* end setIsMarkedOf:to: */
			markAndTrace(_ephemeron);
		} else {
			_ptr += BytesPerOop;
		}
	}
	return _foundInactive;
}
/*	for profilingMark all accessible objects. 
	objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged is true if all 
	objects are unmarked and/or if unmarked classes shoud be removed from the 
	class table.If the incremental collector is running mark bits may be set; stop it and 
	clear them if necessary. */
/* SpurMemoryManager>>#markObjects: */
static void NoDbgRegParms NeverInline
markObjects(sqInt _objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _allocation;
	sqInt _allocation2;
	sqInt _anAddress;
	sqInt _anOop;
	sqInt _classIndex;
	sqInt _classOrNil;
	sqInt _classTablePage;
	sqInt _i;
	sqInt _i2;
	sqInt _i3;
	sqInt _i4;
	sqInt _iLimit;
	sqInt _iLimit2;
	sqInt _iLimit3;
	sqInt _j;
	sqInt _oop;
	usqInt _oop2;
	sqInt _referent;
	sqInt _referent2;
	sqInt _referent22;
	sqInt _referent3;
	sqInt _referent4;
	StackPage *_thePage2;
	char *_theSP;

	runLeakCheckerFor(GCModeFull);
	/* begin shutDownIncrementalGC: */
	if (_objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged) {
		assert(allObjectsUnmarked());
	}
	/* end shutDownIncrementalGC: */
	/* begin initializeUnscannedEphemerons */
	if (!GIV(unscannedEphemerons)) {
		GIV(unscannedEphemerons) = ((SpurContiguousObjStack *) (calloc(sizeof(SpurContiguousObjStack), 1)) );
	}
	/* begin initializeWithAtLeast:onError: */
	if ((((GIV(unscannedEphemerons)->initialSize)) == null) || (((GIV(unscannedEphemerons)->initialSize)) == 0)) {
		(GIV(unscannedEphemerons)->initialSize = 10000);
	}
	_allocation = malloc((sizeof(void *)) * ((GIV(unscannedEphemerons)->initialSize)));
	if (!_allocation) {
		{
			error("Cannot allocate space for unscanned ephemerons");
		}
	}
	{
		(GIV(unscannedEphemerons)->start = ((sqInt) _allocation ));
		(GIV(unscannedEphemerons)->limit = ((sqInt) _allocation ) + ((sizeof(void *)) * ((GIV(unscannedEphemerons)->initialSize))));
	}
	(GIV(unscannedEphemerons)->top = (GIV(unscannedEphemerons)->start));
	/* end initializeWithAtLeast:onError: */
	/* end initializeUnscannedEphemerons */
	/* begin initializeMarkStack */
	ensureRoomOnObjStackAt(MarkStackRootIndex);
	/* end initializeMarkStack */
	/* begin initializeWeaklingStack */
	ensureRoomOnObjStackAt(WeaklingStackRootIndex);
	/* end initializeWeaklingStack */
	/* begin initializeMournQueue */
	ensureRoomOnObjStackAt(MournQueueRootIndex);
	/* end initializeMournQueue */
	/* begin initializePermSpaceForwardersToCleanUp */
	if (!GIV(permSpaceForwardersToCleanUp)) {
		GIV(permSpaceForwardersToCleanUp) = ((SpurContiguousObjStack *) (calloc(sizeof(SpurContiguousObjStack), 1)) );
	}
	/* begin initializeWithAtLeast:onError: */
	if ((((GIV(permSpaceForwardersToCleanUp)->initialSize)) == null) || (((GIV(permSpaceForwardersToCleanUp)->initialSize)) == 0)) {
		(GIV(permSpaceForwardersToCleanUp)->initialSize = 512);
	}
	_allocation2 = malloc((sizeof(void *)) * ((GIV(permSpaceForwardersToCleanUp)->initialSize)));
	if (!_allocation2) {
		{
			error("Cannot allocate space for Permanent space Forwarders to clean up");
		}
	}
	{
		(GIV(permSpaceForwardersToCleanUp)->start = ((sqInt) _allocation2 ));
		(GIV(permSpaceForwardersToCleanUp)->limit = ((sqInt) _allocation2 ) + ((sizeof(void *)) * ((GIV(permSpaceForwardersToCleanUp)->initialSize))));
	}
	(GIV(permSpaceForwardersToCleanUp)->top = (GIV(permSpaceForwardersToCleanUp)->start));
	/* end initializeWithAtLeast:onError: */
	/* end initializePermSpaceForwardersToCleanUp */
	GIV(marking) = 1;
	/* begin markAccessibleObjectsAndFireEphemerons */
	assert(GIV(marking));
	assert(validClassTableRootPages());
	assert(allBridgesMarked());
	/* begin initStackPageGC */
	if (GIV(stackPage) != 0) {
		/* begin writeBackHeadFramePointers */
		assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
		assert(GIV(stackPage) == (mostRecentlyUsedPage()));
		assert(!(isFree(GIV(stackPage))));
		/* begin setHeadFP:andSP:inPage: */
		_theSP = GIV(stackPointer);
		assert(_theSP < GIV(framePointer));
		assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
		assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
		{
			(GIV(stackPage)->headFP = GIV(framePointer));
			(GIV(stackPage)->headSP = _theSP);
		}
		/* end setHeadFP:andSP:inPage: */
		assert(pageListIsWellFormed());
		/* end writeBackHeadFramePointers */
	}
	/* begin allStackPagesDo: */
	for (_i2 = 0; _i2 < GIV(numStackPages); _i2 += 1) {
		/* begin stackPageAt: */
		_thePage2 = stackPageAtpages(_i2, GIV(pages));
		/* end stackPageAt: */
		{
			(_thePage2->trace = StackPageUnreached);
		}
	}
	/* end allStackPagesDo: */
	/* end initStackPageGC */
	markAndTraceHiddenRoots();
	/* begin markAndTraceExtraRoots */
	assert(GIV(remapBufferCount) == 0);
	for (_i4 = 1; _i4 <= GIV(extraRootCount); _i4 += 1) {
		_oop = GIV(extraRoots)[_i4][0];
		if (!((_oop & (tagMask())) || (((longAt(_oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())))) {
			markAndTrace(_oop);
		}
	}
	/* end markAndTraceExtraRoots */
	assert(validClassTableRootPages());
	/* begin markAndTraceInterpreterOops: */
	markAndTraceStackPages(1);
	markAndTraceTraceLog();
	markAndTracePrimTraceLog();
	markAndTrace(GIV(specialObjectsOop));
	if (!(GIV(newMethod) & (tagMask()))) {
		markAndTrace(GIV(newMethod));
	}
	/* begin traceProfileState */
	/* begin followForwardingPointersInProfileState */
	if (((long64At(GIV(profileProcess))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(GIV(profileProcess)));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent4 = unsignedLongAt((GIV(profileProcess) + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent4 & (tagMask())) == 0) && (((long64At(_referent4)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent4 = unsignedLongAt((_referent4 + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		GIV(profileProcess) = _referent4;
		/* end followForwarded: */
	}
	if (((long64At(GIV(profileMethod))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(GIV(profileMethod)));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent22 = unsignedLongAt((GIV(profileMethod) + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent22 & (tagMask())) == 0) && (((long64At(_referent22)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent22 = unsignedLongAt((_referent22 + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		GIV(profileMethod) = _referent22;
		/* end followForwarded: */
	}
	if (((long64At(GIV(profileProcess))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(GIV(profileSemaphore)));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent3 = unsignedLongAt((GIV(profileSemaphore) + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent3 & (tagMask())) == 0) && (((long64At(_referent3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent3 = unsignedLongAt((_referent3 + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		GIV(profileSemaphore) = _referent3;
		/* end followForwarded: */
	}
	/* end followForwardingPointersInProfileState */
	markAndTrace(GIV(profileProcess));
	markAndTrace(GIV(profileMethod));
	markAndTrace(GIV(profileSemaphore));
	sqLowLevelMFence();
	if ((GIV(longRunningPrimitiveCheckMethod) != null) && (GIV(longRunningPrimitiveCheckSequenceNumber) != GIV(statCheckForEvents))) {
		if (((long64At(GIV(longRunningPrimitiveCheckMethod))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
			/* begin followForwarded: */
			assert(isUnambiguouslyForwarder(GIV(longRunningPrimitiveCheckMethod)));
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((GIV(longRunningPrimitiveCheckMethod) + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
			while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
			}
			GIV(longRunningPrimitiveCheckMethod) = _referent;
			/* end followForwarded: */
		}
		markAndTrace(GIV(longRunningPrimitiveCheckMethod));
	}
	if (GIV(longRunningPrimitiveCheckSemaphore) != null) {
		if (((long64At(GIV(longRunningPrimitiveCheckSemaphore))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
			/* begin followForwarded: */
			assert(isUnambiguouslyForwarder(GIV(longRunningPrimitiveCheckSemaphore)));
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent2 = unsignedLongAt((GIV(longRunningPrimitiveCheckSemaphore) + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
			while (((_referent2 & (tagMask())) == 0) && (((long64At(_referent2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent2 = unsignedLongAt((_referent2 + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
			}
			GIV(longRunningPrimitiveCheckSemaphore) = _referent2;
			/* end followForwarded: */
		}
		markAndTrace(GIV(longRunningPrimitiveCheckSemaphore));
	}
	/* end traceProfileState */
	if (!(GIV(tempOop) == 0)) {
		markAndTrace(GIV(tempOop));
	}
	if (!(GIV(tempOop2) == 0)) {
		markAndTrace(GIV(tempOop2));
	}
	for (_i3 = 1, _iLimit3 = remapBufferCount(); _i3 <= _iLimit3; _i3 += 1) {
		_oop2 = GIV(remapBuffer)[_i3];
		if (!(_oop2 & (tagMask()))) {
			markAndTrace(_oop2);
		}
	}
	for (_i3 = 1; _i3 <= GIV(jmpDepth); _i3 += 1) {
		_oop2 = GIV(suspendedCallbacks)[_i3];
		if (!(_oop2 & (tagMask()))) {
			markAndTrace(_oop2);
		}
		_oop2 = GIV(suspendedMethods)[_i3];
		if (!(_oop2 & (tagMask()))) {
			markAndTrace(_oop2);
		}
	}
	/* end markAndTraceInterpreterOops: */
	assert(validObjStacks());
	markWeaklingsAndMarkAndFireEphemerons();
	assert(validObjStacks());
	/* end markAccessibleObjectsAndFireEphemerons */
	/* begin expungeDuplicateAndUnmarkedClasses: */
	for (_i = 1; _i < GIV(numClassTablePages); _i += 1) {
		_classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		for (_j = 0, _iLimit2 = (1U << (classTableMajorIndexShift())) - 1; _j <= _iLimit2; _j += 1) {
			_classOrNil = unsignedLongAt((_classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) _j ) << (shiftForWord())) ));
			_classIndex = ((sqInt) (((usqInt) _i ) << (classTableMajorIndexShift())) ) + _j;
			assert((_classOrNil == GIV(nilObj)) || (addressCouldBeClassObj(_classOrNil)));
			if (_classOrNil == GIV(nilObj)) {
				if (_classIndex < GIV(classTableIndex)) {
					GIV(classTableIndex) = _classIndex;
				}
			}
 else {
				if ((_objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged && (!((((((usqInt) (longAt(_classOrNil)) ) >> (markedBitFullShift())) & 1) != 0) || (((_classOrNil & (tagMask())) == 0) && (_classOrNil >= 0x20000000000LL))))) || (((uint32AtPointer(_classOrNil + 4)) & (identityHashHalfWordMask())) != _classIndex)) {
					assert(!(isPermanent(_classOrNil)));
					{
						assert(!(isOopForwarded(_classTablePage)));
						longAtput((_classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) _j ) << (shiftForWord())) ), GIV(nilObj));
					}
					assert((_objectsShouldBeUnmarkedAndUnmarkedClassesShouldBeExpunged && (!(isMarkedOrPermanent(_classOrNil)))) || ((classAtIndex(rawHashBitsOf(_classOrNil))) == _classOrNil));
					if (_classIndex < GIV(classTableIndex)) {
						GIV(classTableIndex) = _classIndex;
					}
				}
			}
		}
	}
	assert(GIV(classTableIndex) >= (1U << (classTableMajorIndexShift())));
	/* end expungeDuplicateAndUnmarkedClasses: */
	nilUnmarkedWeaklingSlots();
	/* begin freeUnscannedEphemerons */
	free((GIV(unscannedEphemerons)->start));
	(GIV(unscannedEphemerons)->start = null);
	/* end freeUnscannedEphemerons */
	/* begin cleanUpPermSpaceForwarders */
	/* begin objectStackDo: */
	for (_anAddress = (GIV(permSpaceForwardersToCleanUp)->start), _iLimit = ((GIV(permSpaceForwardersToCleanUp)->top)) - BytesPerOop; _anAddress <= _iLimit; _anAddress += BytesPerOop) {
		{
			_anOop = longAt(_anAddress);
			freePermObject(_anOop);
		}
	}
	/* end objectStackDo: */
	/* begin freeObjectStack */
	free((GIV(permSpaceForwardersToCleanUp)->start));
	(GIV(permSpaceForwardersToCleanUp)->start = 0);
	(GIV(permSpaceForwardersToCleanUp)->top = 0);
	/* end freeObjectStack */
	/* end cleanUpPermSpaceForwarders */
	GIV(marking) = 0;
}
/*	After the initial scan-mark is complete ephemerons can be processed. 
	Weaklings have accumulated on the weaklingStack, but more may be 
	uncovered during ephemeron processing. So trace the strong slots 
	of the weaklings, and as ephemerons are processed ensure any newly 
	reached weaklings are also traced. 
	 
	Moreover, marking ephemerons from unscannedEphemerons (because we fire 
	them, or because we realize that they are inactive (ie have a marked key)) 
	leads to the discover (and markind) of new objects that are possibly 
	weak objects, ephemerons or keys of unscanned ephemerons, forcing us to 
	continue the work (thus the `repeat` block) */
/* SpurMemoryManager>>#markWeaklingsAndMarkAndFireEphemerons */
static void
markWeaklingsAndMarkAndFireEphemerons(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classFormat;
	sqInt _ephemeron;
	sqInt _ephemeron2;
	sqInt _field;
	sqInt _i;
	sqInt _i2;
	sqInt _iLimit;
	sqInt _key;
	usqInt _lastOffsetToScan;
	sqInt _lastptr;
	usqInt _nextOffsetToScan;
	sqInt _numOnThisPage;
	sqInt _numToEnumerate;
	sqInt _numToEnumerateOnThisPage;
	sqInt _numTracedWeaklings;
	sqInt _objOop;
	sqInt _objStack;
	sqInt _objStackPage;
	sqInt _oop;
	sqInt _oop2;
	sqInt _p;
	sqInt _size;
	sqInt _topIndex;
	sqInt _weakling;

	_numTracedWeaklings = 0;
	while (1) {
		markAndTraceUntracedReachableStackPages();
		markAndTraceMachineCodeOfMarkedMethods();
		do {
			/* begin objStack:from:do: */
			eassert(isValidObjStack(GIV(weaklingStack)));
			/* begin fetchPointer:ofObject: */
			_size = unsignedLongAt((GIV(weaklingStack) + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			/* begin fetchPointer:ofObject: */
			_objStackPage = unsignedLongAt((GIV(weaklingStack) + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			while (_objStackPage != 0) {
				_size += ObjStackLimit;
				assert((fetchPointerofObject(ObjStackTopx, _objStackPage)) == ObjStackLimit);
				/* begin fetchPointer:ofObject: */
				_objStackPage = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
			}
			_numToEnumerate = _size - _numTracedWeaklings;
			_objStackPage = GIV(weaklingStack);
			while (_numToEnumerate > 0) {
				/* begin fetchPointer:ofObject: */
				_numOnThisPage = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				_numToEnumerateOnThisPage = ((_numToEnumerate < _numOnThisPage) ? _numToEnumerate : _numOnThisPage);
				_topIndex = (_numOnThisPage + ObjStackFixedSlots) - 1;
				for (_i2 = _topIndex; _i2 >= ((_topIndex - _numToEnumerateOnThisPage) + 1); _i2 += -1) {
					assert(isWeak(fetchPointerofObject(_i2, _objStackPage)));
					{
						_weakling = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) _i2 ) << (shiftForWord())) ));
						assert(!(isForwarded(_weakling)));
						markAndTraceClassOf(_weakling);
						for (_i = 0, _iLimit = ((assert((formatOf(_weakling)) == (weakArrayFormat())), /* begin fixedFieldsOfClass: */ (_objOop = fetchClassOfNonImm(_weakling)), /* begin fixedFieldsOfClassFormat: */ (_classFormat = (unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3), _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1) /* end fixedFieldsOfClassFormat: */ /* end fixedFieldsOfClass: */)) - 1; _i <= _iLimit; _i += 1) {
							/* begin followOopField:ofObject: */
							/* begin fetchPointer:ofObject: */
							_oop = unsignedLongAt((_weakling + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							if (((_oop & (tagMask())) == 0) && (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
								_oop = fixFollowedFieldofObjectwithInitialValue(_i, _weakling, _oop);
							}
							_field = _oop;
							/* end followOopField:ofObject: */
							if (!((_field & (tagMask())) || ((((((usqInt) (longAt(_field)) ) >> (markedBitFullShift())) & 1) != 0) || (((_field & (tagMask())) == 0) && (_field >= 0x20000000000LL))))) {
								markAndTrace(_field);
							}
						}
					}
				}
				_numToEnumerate -= _numToEnumerateOnThisPage;
				/* begin fetchPointer:ofObject: */
				_objStackPage = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
			}
			_numTracedWeaklings = _size;
			/* end objStack:from:do: */
		} while ((sizeOfObjStack(GIV(weaklingStack))) > _numTracedWeaklings);
		if (((GIV(unscannedEphemerons)->top)) == ((GIV(unscannedEphemerons)->start))) {
			{
				markAndTraceUntracedReachableStackPages();
				markAndTraceMachineCodeOfMarkedMethods();
				freeUntracedStackPages();
				freeUnmarkedMachineCode();
			}
			return;
		}
		if (!(markInactiveEphemerons())) {
			/* begin fireAllUnscannedEphemerons */
			assert(!(noUnscannedEphemerons()));
			assert(allUnscannedEphemeronsAreActive());
			for (_p = (GIV(unscannedEphemerons)->start); _p <= (((GIV(unscannedEphemerons)->top)) - BytesPerOop); _p += BytesPerOop) {
				/* begin fireEphemeron: */
				_ephemeron2 = longAt(_p);
				{
					/* begin queueMourner: */
					assert((isNonImmediate(_ephemeron2)) && (((formatOf(_ephemeron2)) == (ephemeronFormat())) || ((formatOf(_ephemeron2)) == (weakArrayFormat()))));
					assert(!(((formatOf(_ephemeron2)) == (ephemeronFormat())) && (isonObjStack(_ephemeron2, GIV(mournQueue)))));
					/* begin push:onObjStack: */
					_objStack = GIV(mournQueue);
					assert(addressCouldBeOop(_ephemeron2));
					if (_ephemeron2 & (tagMask())) {
						assert(_objStack == GIV(markStack));
						assert(addressCouldBeObj(topOfObjStack(((0 == (fetchPointerofObject(ObjStackTopx, _objStack)))
							 ? fetchPointerofObject(ObjStackNextx, _objStack)
							 : _objStack))));
					}
 else {
						assert(!((_objStack == GIV(markStack)) && (isWeakNonImm(_ephemeron2))));
						assert((_objStack != GIV(weaklingStack)) || (isWeakNonImm(_ephemeron2)));
					}
					noCheckPushonObjStack(_ephemeron2, _objStack);
					/* end push:onObjStack: */
					/* end queueMourner: */
					/* begin setFormatOf:to: */
					assert((1 >= 0) && (1 <= (formatMask())));
					longAtput(_ephemeron2, ((longAt(_ephemeron2)) & (~((usqIntptr_t) ((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) ))) + (1U << (formatShift())));
					/* end setFormatOf:to: */
				}
				/* begin signalFinalization: */
				forceInterruptCheck();
				GIV(pendingFinalizationSignals) += 1;
				/* end signalFinalization: */
				/* end fireEphemeron: */
			}
			/* end fireAllUnscannedEphemerons */
			/* begin markAllUnscannedEphemerons */
			assert(allUnscannedEphemeronsAreActive());
			_nextOffsetToScan = (GIV(unscannedEphemerons)->start);
			_lastOffsetToScan = (GIV(unscannedEphemerons)->top);
			while (_lastOffsetToScan > _nextOffsetToScan) {
				_ephemeron = longAt(_nextOffsetToScan);
				{
					assert((isNonImmediate(_ephemeron)) && (isMaybeFiredEphemeron(_ephemeron)));
					/* begin followOopField:ofObject: */
					/* begin fetchPointer:ofObject: */
					_oop2 = unsignedLongAt((_ephemeron + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofObject: */
					if (((_oop2 & (tagMask())) == 0) && (((long64At(_oop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						_oop2 = fixFollowedFieldofObjectwithInitialValue(0, _ephemeron, _oop2);
					}
					_key = _oop2;
					/* end followOopField:ofObject: */
				}
				/* begin setIsMarkedOf:to: */
				assert(!(isFreeObject(_ephemeron)));
				unsignedLongAtput(_ephemeron, (unsignedLongAt(_ephemeron)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
				/* end setIsMarkedOf:to: */
				{
					markAndTrace(_key);
					markAndTrace(_ephemeron);
				}
				_lastptr = ((GIV(unscannedEphemerons)->top)) - BytesPerOop;
				if (_lastptr > _nextOffsetToScan) {
					longAtput(_nextOffsetToScan, longAt(_lastptr));
				}
				if (((GIV(unscannedEphemerons)->top)) > _lastOffsetToScan) {
					_nextOffsetToScan += BytesPerOop;
				} else {
					_lastOffsetToScan -= BytesPerOop;
				}
				(GIV(unscannedEphemerons)->top = _lastptr);
			}
			/* end markAllUnscannedEphemerons */
		}
	}
}
/*	Answers if the code is installed in a class instantiating objects with the 
	format. Used in primitive  
	generation to make a quick path based on where the method is installed. 
	This method cannot 
	be used as a guarantee as there can be false positive, it's just a 
	heuristic. Tries to interpret the last literal of the method as a behavior 
	(more than 3 fields, 3rd field a Smi). 
	If it can be interpreted as a behavior, answers if instSpec matches the 
	format, else answers false. */
/* SpurMemoryManager>>#maybeMethodClassOf:seemsToBeInstantiating: */
sqInt
maybeMethodClassOfseemsToBeInstantiating(sqInt _methodObj, sqInt _format)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _instSpec;
	sqInt _literal;
	sqInt _maybeClassObj;
	sqInt _maybeFormat;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _offset;

	/* begin methodClassOf: */
	/* begin followLiteral:ofMethod: */
	_offset = (literalCountOfMethodHeader(methodHeaderOf(_methodObj))) - 1;
	/* begin followField:ofObject: */
	/* begin fetchPointer:ofObject: */
	_objOop2 = unsignedLongAt((_methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset + LiteralStart) ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_objOop2 & (tagMask())) == 0) && (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		_objOop2 = fixFollowedFieldofObjectwithInitialValue(_offset + LiteralStart, _methodObj, _objOop2);
	}
	_literal = _objOop2;
	/* end followField:ofObject: */
	/* end followLiteral:ofMethod: */
	if ((_literal != GIV(nilObj)) && (((_literal & (tagMask())) == 0) && (((((usqInt) (longAt(_literal)) ) >> (formatShift())) & (formatMask())) <= 5))) {
		assert((numSlotsOf(_literal)) > ValueIndex);
		/* begin followField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop = unsignedLongAt((_literal + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_objOop = fixFollowedFieldofObjectwithInitialValue(ValueIndex, _literal, _objOop);
		}
		_maybeClassObj = _objOop;
		/* end followField:ofObject: */
	} else {
		/* begin nilObject */
		_maybeClassObj = GIV(nilObj);
		/* end nilObject */
	}
	/* end methodClassOf: */
	if (!(((((usqInt) (longAt(_maybeClassObj)) ) >> (formatShift())) & (formatMask())) <= 5)) {
		return 0;
	}
	if (!((numSlotsOfAny(_maybeClassObj)) > InstanceSpecificationIndex)) {
		return 0;
	}
	/* begin fetchPointer:ofObject: */
	_maybeFormat = unsignedLongAt((_maybeClassObj + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (!(((_maybeFormat & 7) == 1))) {
		return 0;
	}
	/* begin instSpecOfClassFormat: */
	_instSpec = (((usqInt) (_maybeFormat >> 3) ) >> (fixedFieldsFieldWidth())) & (formatMask());
	/* end instSpecOfClassFormat: */
	return _instSpec == _format;
}
/*	Answer one of the objects in the SpecialObjectsArray, if in range, 
	otherwise answer nil. */
/* SpurMemoryManager>>#maybeSplObj: */
sqInt
maybeSplObj(sqInt _index)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((_index < (numSlotsOf(GIV(specialObjectsOop))))
		 ? (/* begin fetchPointer:ofObject: */ unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */)
		 : 0);
}
/* SpurMemoryManager>>#memoryActiveProcess */
static sqInt
memoryActiveProcess(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _objOop;
	sqInt _objOop2;

	/* begin fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	return unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/*	Answer the minimum number of additional slots to allocate in an object to 
	always be able to shorten it. 
	This is enough slots to allocate a minimum-sized object. */
/* SpurMemoryManager>>#minSlotsForShortening */
sqInt
minSlotsForShortening(void)
{
	return (8 * 2) / BytesPerOop;
}
/*	Clearing the flag for all */
/* SpurMemoryManager>>#moveToPermSpaceAllOldObjects */
static void
moveToPermSpaceAllOldObjects(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	sqInt _limit;
	sqInt _objOop2;
	sqInt _prevObj;
	sqInt _prevPrevObj;
	sqInt _referent;
	char *_theSP;

	GIV(becomeEffectsFlags) = 0;
	/* begin allOldSpaceObjectsDo: */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj = (_prevObj = null);
	_objOop2 = GIV(nilObj);
	while (1) {
		assert((_objOop2 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop2, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop2)) != 0);
		{
			if (isEnumerableObject(_objOop2)) {
				{
					if (!(((longAt(_objOop2)) & (classIndexMask())) <= (classIsItselfClassIndexPun()))) {
						if (isValidToMoveToPermSpace(_objOop2)) {
							doMoveToPermSpaceaddToRememberedSet(_objOop2, 1);
						}
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_limit = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, _limit)) {
			_objOop2 = _limit;
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	/* end allOldSpaceObjectsDo: */
	/* begin allPermSpaceNonForwardedObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (!(((long64At(_currentObject)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					{
						followForwardedObjectFieldstoDepth(_currentObject, 0);
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l2;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_currentObject = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l2:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allPermSpaceNonForwardedObjectsDo: */
	recreateFromPermSpaceRememberedSet();
	GIV(becomeEffectsFlags) = (BecamePointerObjectFlag + BecameActiveClassFlag) | BecameCompiledMethodFlag;
	/* begin doAfterMoveToPermSpace */
	/* begin preBecomeAction */
	{
		if (GIV(stackPage) != 0) {
			/* begin writeBackHeadFramePointers */
			assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
			assert(GIV(stackPage) == (mostRecentlyUsedPage()));
			assert(!(isFree(GIV(stackPage))));
			/* begin setHeadFP:andSP:inPage: */
			_theSP = GIV(stackPointer);
			assert(_theSP < GIV(framePointer));
			assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
			assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
			{
				(GIV(stackPage)->headFP = GIV(framePointer));
				(GIV(stackPage)->headSP = _theSP);
			}
			/* end setHeadFP:andSP:inPage: */
			assert(pageListIsWellFormed());
			/* end writeBackHeadFramePointers */
		}
	}
	GIV(gcMode) = GCModeBecome;
	/* end preBecomeAction */
	/* begin followSpecialObjectsOop */
	if (((long64At(GIV(specialObjectsOop))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(GIV(specialObjectsOop)));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		GIV(specialObjectsOop) = _referent;
		/* end followForwarded: */
	}
	followForwardedObjectFieldstoDepth(GIV(specialObjectsOop), 0);
	/* end followSpecialObjectsOop */
	postBecomeAction(GIV(becomeEffectsFlags));
	/* begin followSpecialSelectors */
	followForwardedObjectFieldstoDepth(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) )), 0);
	/* end followSpecialSelectors */
	postBecomeScanClassTable(GIV(becomeEffectsFlags));
	GIV(becomeEffectsFlags) = 0;
	/* end doAfterMoveToPermSpace */
}
/*	Clearing the flag for all */
/* SpurMemoryManager>>#moveToPermSpaceInBulk: */
static sqInt NoDbgRegParms
moveToPermSpaceInBulk(sqInt _anArrayOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _index;
	sqInt _newObj;
	usqInt _numSlots;
	sqInt _objOop;
	sqInt _referent;
	usqInt _size;
	char *_theSP;

	GIV(becomeEffectsFlags) = 0;
	/* begin numSlotsOf: */
	assert((classIndexOf(_anArrayOop)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_anArrayOop + 7);
	_size = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_anArrayOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	for (_index = 0; _index < _size; _index += 1) {
		/* begin fetchPointer:ofObject: */
		_objOop = unsignedLongAt((_anArrayOop + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (!(isValidToMoveToPermSpace(_objOop))) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadReceiver;
			/* end primitiveFailFor: */
			return null;
		}
	}
	for (_index = 0; _index < _size; _index += 1) {
		/* begin fetchPointer:ofObject: */
		_objOop = unsignedLongAt((_anArrayOop + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (!(_objOop >= 0x20000000000LL)) {
			_newObj = doMoveToPermSpaceaddToRememberedSet(_objOop, 0);
			if (!_newObj) {
				return _anArrayOop;
			}
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(_anArrayOop)));
			if (((_anArrayOop & (tagMask())) == 0) && ((_anArrayOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((_newObj & (tagMask())) == 0) && (((_newObj & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_newObj >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(_anArrayOop)) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), _anArrayOop);
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(_anArrayOop)) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l6;
			}
			if (_newObj & (tagMask())) {
				goto l6;
			}
			if (!(_anArrayOop >= 0x20000000000LL)) {
				goto l6;
			}
			if (_newObj >= 0x20000000000LL) {
				goto l6;
			}
			if ((_newObj >= GIV(nilObj)) && (_newObj <= GIV(trueObj))) {
				goto l6;
			}
			if (!(_newObj >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l6;
			}
			remember(getFromPermToNewSpaceRememberedSet(), _anArrayOop);
			l6:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((_anArrayOop + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ), _newObj);
			/* end storePointer:ofObject:withValue: */
		}
	}
	followForwardedObjectFieldstoDepth(_anArrayOop, 1);
	recreateFromPermSpaceRememberedSet();
	GIV(becomeEffectsFlags) = (BecamePointerObjectFlag + BecameActiveClassFlag) | BecameCompiledMethodFlag;
	/* begin doAfterMoveToPermSpace */
	/* begin preBecomeAction */
	{
		if (GIV(stackPage) != 0) {
			/* begin writeBackHeadFramePointers */
			assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
			assert(GIV(stackPage) == (mostRecentlyUsedPage()));
			assert(!(isFree(GIV(stackPage))));
			/* begin setHeadFP:andSP:inPage: */
			_theSP = GIV(stackPointer);
			assert(_theSP < GIV(framePointer));
			assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
			assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
			{
				(GIV(stackPage)->headFP = GIV(framePointer));
				(GIV(stackPage)->headSP = _theSP);
			}
			/* end setHeadFP:andSP:inPage: */
			assert(pageListIsWellFormed());
			/* end writeBackHeadFramePointers */
		}
	}
	GIV(gcMode) = GCModeBecome;
	/* end preBecomeAction */
	/* begin followSpecialObjectsOop */
	if (((long64At(GIV(specialObjectsOop))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(GIV(specialObjectsOop)));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		GIV(specialObjectsOop) = _referent;
		/* end followForwarded: */
	}
	followForwardedObjectFieldstoDepth(GIV(specialObjectsOop), 0);
	/* end followSpecialObjectsOop */
	postBecomeAction(GIV(becomeEffectsFlags));
	/* begin followSpecialSelectors */
	followForwardedObjectFieldstoDepth(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) )), 0);
	/* end followSpecialSelectors */
	postBecomeScanClassTable(GIV(becomeEffectsFlags));
	GIV(becomeEffectsFlags) = 0;
	/* end doAfterMoveToPermSpace */
	return _anArrayOop;
}
/*	Clearing the flag for all */
/* SpurMemoryManager>>#moveToPermSpace: */
static sqInt NoDbgRegParms
moveToPermSpace(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _newObj;
	sqInt _referent;
	char *_theSP;

	GIV(becomeEffectsFlags) = 0;
	if (!(isValidToMoveToPermSpace(_objOop))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadReceiver;
		/* end primitiveFailFor: */
		return null;
	}
	_newObj = doMoveToPermSpaceaddToRememberedSet(_objOop, 1);
	/* begin doAfterMoveToPermSpace */
	/* begin preBecomeAction */
	{
		if (GIV(stackPage) != 0) {
			/* begin writeBackHeadFramePointers */
			assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
			assert(GIV(stackPage) == (mostRecentlyUsedPage()));
			assert(!(isFree(GIV(stackPage))));
			/* begin setHeadFP:andSP:inPage: */
			_theSP = GIV(stackPointer);
			assert(_theSP < GIV(framePointer));
			assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
			assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
			{
				(GIV(stackPage)->headFP = GIV(framePointer));
				(GIV(stackPage)->headSP = _theSP);
			}
			/* end setHeadFP:andSP:inPage: */
			assert(pageListIsWellFormed());
			/* end writeBackHeadFramePointers */
		}
	}
	GIV(gcMode) = GCModeBecome;
	/* end preBecomeAction */
	/* begin followSpecialObjectsOop */
	if (((long64At(GIV(specialObjectsOop))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(GIV(specialObjectsOop)));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		GIV(specialObjectsOop) = _referent;
		/* end followForwarded: */
	}
	followForwardedObjectFieldstoDepth(GIV(specialObjectsOop), 0);
	/* end followSpecialObjectsOop */
	postBecomeAction(GIV(becomeEffectsFlags));
	/* begin followSpecialSelectors */
	followForwardedObjectFieldstoDepth(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) )), 0);
	/* end followSpecialSelectors */
	postBecomeScanClassTable(GIV(becomeEffectsFlags));
	GIV(becomeEffectsFlags) = 0;
	/* end doAfterMoveToPermSpace */
	return _newObj;
}
/* SpurMemoryManager>>#newHashBitsOf: */
static sqInt NoDbgRegParms
newHashBitsOf(sqInt _objOop)
{
	sqInt _hash;

	_hash = (newObjectHash()) & (identityHashHalfWordMask());
	/* begin setHashBitsOf:to: */
	assert((_hash >= 0) && (_hash <= (identityHashHalfWordMask())));
	uint32AtPointerput(_objOop + 4, (((uint32AtPointer(_objOop + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + _hash);
	/* end setHashBitsOf:to: */
	return _hash;
}
/*	Use a slight variation on D.H. Lehmer's linear congruential generator from 
	1951. See e.g. http://en.wikipedia.org/wiki/Linear_congruential_generator. */
/* SpurMemoryManager>>#newObjectHash */
static sqInt
newObjectHash(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _hash;

	do {
		GIV(lastHash) = GIV(lastHash) * 16807;
		_hash = GIV(lastHash) + (((usqInt) GIV(lastHash) ) >> 4);
	} while ((_hash & (identityHashHalfWordMask())) == 0);
	return _hash;
}
/* SpurMemoryManager>>#newSpaceIsEmpty */
static sqInt
newSpaceIsEmpty(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return (GIV(freeStart) == (((eden()).start))) && (GIV(pastSpaceStart) == (((pastSpace()).start)));
}
/* SpurMemoryManager>>#nilObject */
sqInt
nilObject(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(nilObj);
}
/*	Nil the unmarked slots in the weaklings on the 
	weakling stack, finalizing those that lost references. 
	Finally, empty the weaklingStack.for profiling */
/* SpurMemoryManager>>#nilUnmarkedWeaklingSlots */
static void NeverInline
nilUnmarkedWeaklingSlots(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _anyUnmarked;
	int _anyUnmarked2;
	sqInt _i;
	sqInt _i2;
	sqInt _iLimit;
	sqInt _numOnThisPage;
	sqInt _numToEnumerate;
	sqInt _numToEnumerateOnThisPage;
	sqInt _objStackPage;
	sqInt _referent;
	sqInt _size;
	sqInt _topIndex;
	sqInt _weakling;

	eassert(allOldMarkedWeakObjectsOnWeaklingStack());
	if (GIV(weaklingStack) == GIV(nilObj)) {
		return;
	}
	/* begin objStack:from:do: */
	eassert(isValidObjStack(GIV(weaklingStack)));
	/* begin fetchPointer:ofObject: */
	_size = unsignedLongAt((GIV(weaklingStack) + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	_objStackPage = unsignedLongAt((GIV(weaklingStack) + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	while (_objStackPage != 0) {
		_size += ObjStackLimit;
		assert((fetchPointerofObject(ObjStackTopx, _objStackPage)) == ObjStackLimit);
		/* begin fetchPointer:ofObject: */
		_objStackPage = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
	}
	_numToEnumerate = _size;
	_objStackPage = GIV(weaklingStack);
	while (_numToEnumerate > 0) {
		/* begin fetchPointer:ofObject: */
		_numOnThisPage = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		_numToEnumerateOnThisPage = ((_numToEnumerate < _numOnThisPage) ? _numToEnumerate : _numOnThisPage);
		_topIndex = (_numOnThisPage + ObjStackFixedSlots) - 1;
		for (_i = _topIndex; _i >= ((_topIndex - _numToEnumerateOnThisPage) + 1); _i += -1) {
			assert(isWeak(fetchPointerofObject(_i, _objStackPage)));
			{
				_weakling = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
				/* begin nilUnmarkedWeaklingSlotsIn: */
				_anyUnmarked2 = 0;
				assert(allStrongSlotsOfWeaklingAreMarked(_weakling));
				for (_i2 = (assert((formatOf(_weakling)) == (weakArrayFormat())), fixedFieldsOfClass(fetchClassOfNonImm(_weakling))), _iLimit = (numSlotsOf(_weakling)) - 1; _i2 <= _iLimit; _i2 += 1) {
					/* begin fetchPointer:ofObject: */
					_referent = unsignedLongAt((_weakling + BaseHeaderSize) + ((sqInt) (((usqInt) _i2 ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if ((_referent & (tagMask())) == 0) {
						if (((longAt(_referent)) & (classIndexMask())) == (isForwardedObjectClassIndexPun())) {
							_referent = fixFollowedFieldofObjectwithInitialValue(_i2, _weakling, _referent);
						}
						if (!((_referent & (tagMask())) || ((((((usqInt) (longAt(_referent)) ) >> (markedBitFullShift())) & 1) != 0) || (((_referent & (tagMask())) == 0) && (_referent >= 0x20000000000LL))))) {
							{
								assert(!(isOopForwarded(_weakling)));
								longAtput((_weakling + BaseHeaderSize) + ((sqInt) (((usqInt) _i2 ) << (shiftForWord())) ), GIV(nilObj));
							}
							_anyUnmarked2 = 1;
						}
					}
				}
				_anyUnmarked = _anyUnmarked2;
				/* end nilUnmarkedWeaklingSlotsIn: */
				if (_anyUnmarked) {
					assert(GIV(marking));
					/* begin signalFinalization: */
					forceInterruptCheck();
					GIV(pendingFinalizationSignals) += 1;
					/* end signalFinalization: */
				}
			}
		}
		_numToEnumerate -= _numToEnumerateOnThisPage;
		/* begin fetchPointer:ofObject: */
		_objStackPage = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
	}
	/* end objStack:from:do: */
	emptyObjStack(GIV(weaklingStack));
}
/* SpurMemoryManager>>#noCheckClassAtIndex: */
static sqInt NoDbgRegParms
noCheckClassAtIndex(sqInt _classIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classTablePage;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;

	/* begin fetchPointer:ofObject: */
	_fieldIndex = ((usqInt) _classIndex ) >> (classTableMajorIndexShift());
	_classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_classTablePage == GIV(nilObj)) {
		return null;
	}
	/* begin fetchPointer:ofObject: */
	_fieldIndex2 = _classIndex & ((1U << (classTableMajorIndexShift())) - 1);
	return unsignedLongAt((_classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/*	Push an element on an objStack. Split from push:onObjStack: for testing. */
/* SpurMemoryManager>>#noCheckPush:onObjStack: */
static sqInt NoDbgRegParms
noCheckPushonObjStack(sqInt _objOop, sqInt _objStack)
{
	sqInt _topx;

	eassert(isValidObjStack(_objStack));
	/* begin fetchPointer:ofObject: */
	_topx = unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_topx >= ObjStackLimit) {
		noCheckPushonObjStack(_objOop, ensureRoomOnObjStackAt(unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackMyx ) << (shiftForWord())) ))));
	} else {
		/* begin storePointer:ofObjStack:withValue: */
		assert((formatOf(_objStack)) == (wordIndexableFormat()));
		unsignedLongAtput((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) (ObjStackFixedSlots + _topx) ) << (shiftForWord())) ), _objOop);
		/* end storePointer:ofObjStack:withValue: */
		/* begin storePointer:ofObjStack:withValue: */
		assert((formatOf(_objStack)) == (wordIndexableFormat()));
		unsignedLongAtput((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ), _topx + 1);
		/* end storePointer:ofObjStack:withValue: */
	}
	return _objOop;
}
/*	Make sure the oop at fieldIndex in anObject is not forwarded (follow the 
	forwarder there-in if so). Answer the (possibly followed) oop at 
	fieldIndex.  */
/* SpurMemoryManager>>#noFixupFollowField:ofObject: */
static sqInt NoDbgRegParms
noFixupFollowFieldofObject(sqInt _fieldIndex, sqInt _anObject)
{
	sqInt _objOop;
	sqInt _referent;

	/* begin fetchPointer:ofObject: */
	_objOop = unsignedLongAt((_anObject + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(_objOop));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_objOop + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		_objOop = _referent;
		/* end followForwarded: */
	}
	return _objOop;
}
/* SpurMemoryManager>>#noInlineFollowForwarded: */
static sqInt NoDbgRegParms
noInlineFollowForwarded(sqInt _objOop)
{
	sqInt _referent;

	/* begin followForwarded: */
	assert(isUnambiguouslyForwarder(_objOop));
	/* begin fetchPointer:ofMaybeForwardedObject: */
	_referent = unsignedLongAt((_objOop + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofMaybeForwardedObject: */
	while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
	}
	return _referent;
	/* end followForwarded: */
}
/*	Object parsing. 
	1. all objects have at least a word following the header, for a forwarding 
	pointer. 2. objects with an overflow size have a preceeing word with a 
	saturated numSlots. If the word 
	following an object doesn't have a saturated numSlots field it must be a 
	single-header object. 
	If the word following does have a saturated numSlots it must be the 
	overflow size word. */
/* SpurMemoryManager>>#noInlineObjectAfter:limit: */
static sqInt NoDbgRegParms
noInlineObjectAfterlimit(sqInt _objOop, sqInt _limit)
{
	sqInt _followingWord;
	usqInt _followingWordAddress;

	/* begin objectAfter:limit: */
	_followingWordAddress = addressAfter(_objOop);
	if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
		return _limit;
	}
	flag("endianness");
	_followingWord = unsignedLongAt(_followingWordAddress);
	return (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
		 ? _followingWordAddress + BaseHeaderSize
		 : _followingWordAddress);
	/* end objectAfter:limit: */
}
/* SpurMemoryManager>>#nonIndexablePointerFormat */
sqInt
nonIndexablePointerFormat(void)
{
	return 1;
}
/*	The unscannedEphemerons stack top points to the next free position. 
	The stack is empty if top == start */
/* SpurMemoryManager>>#noUnscannedEphemerons */
static sqInt
noUnscannedEphemerons(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((GIV(unscannedEphemerons)->top)) == ((GIV(unscannedEphemerons)->start));
}
/* SpurMemoryManager>>#nullHeaderForMachineCodeMethod */
sqLong
nullHeaderForMachineCodeMethod(void)
{
	return (((sqInt) (((usqInt) (firstLongFormat()) ) << (formatShift())) ) + (1ULL << (markedBitFullShift()))) + ClassBitmapCompactIndex;
}
/*	Answer the number of indexable bytes in the given non-immediate 
	byte-indexable object. */
/* SpurMemoryManager>>#numBytesOfBytes: */
static sqInt NoDbgRegParms
numBytesOfBytes(sqInt _objOop)
{
	sqInt _fmt;

	_fmt = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	assert(_fmt >= (firstByteFormat()));
	return ((numSlotsOf(_objOop)) << (shiftForWord())) - (_fmt & 7);
}
/*	Answer the number of indexable bytes in the given non-immediate object. 
	Does not adjust the size of contexts by stackPointer. */
/* SpurMemoryManager>>#numBytesOf: */
sqInt
numBytesOf(sqInt _objOop)
{
	sqInt _fmt;
	usqInt _numBytes;
	usqInt _numSlots;

	_fmt = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_objOop)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_objOop + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt >= (firstByteFormat())) {
		return _numBytes - (_fmt & 7);
	}
	if (_fmt <= (sixtyFourBitIndexableFormat())) {
		return _numBytes;
	}
	if (_fmt >= (firstShortFormat())) {
		return _numBytes - ((sqInt) (((usqInt) (_fmt & 3) ) << 1) );
	}
	return _numBytes - ((sqInt) (((usqInt) (_fmt & 1) ) << 2) );
}
/*	Answer the number of pointer fields in the given object. 
	Works with CompiledMethods, as well as ordinary objects. */
/* SpurMemoryManager>>#numPointerSlotsOf: */
usqInt
numPointerSlotsOf(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _contextSize;
	sqInt _fmt;
	sqInt _header;
	sqInt _header2;
	sqInt _numLiterals;
	usqInt _numSlots;
	sqInt _sp;

	_fmt = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	if (_fmt <= 5) {
		if ((_fmt == (indexablePointersFormat())) && (((longAt(_objOop)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
			/* begin fetchStackPointerOf: */
			/* begin fetchPointer:ofObject: */
			_sp = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (!(((_sp & 7) == 1))) {
				_contextSize = 0;
				goto l3;
			}
			assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_objOop)));
			_contextSize = _sp >> 3;
			l3:
			;
			/* end fetchStackPointerOf: */
			return CtxtTempFrameStart + _contextSize;
		}
		/* begin numSlotsOf: */
		assert((classIndexOf(_objOop)) > (isForwardedObjectClassIndexPun()));
		_numSlots = byteAt(_objOop + 7);
		return ((_numSlots == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots);
		/* end numSlotsOf: */
	}
	if (_fmt == 7) {
		return 1;
	}
	if (_fmt < (firstCompiledMethodFormat())) {
		return 0;
	}
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_objOop));
	/* begin fetchPointer:ofObject: */
	_header2 = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header2 & 7) == 1)) {
		_header = _header2;
	} else {
		assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_header = ((((CogMethod *) _header2 ))->methodHeader);
	}
	/* end methodHeaderOf: */
	{
		assert(((_header & 7) == 1));
		_numLiterals = (_header >> 3) & AlternateHeaderNumLiteralsMask;
	}
	return _numLiterals + LiteralStart;
}
/*	A private internal version of numSlotsOf: that is happy to be applied to 
	free or forwarded objects. */
/* SpurMemoryManager>>#numSlotsOfAny: */
static usqInt NoDbgRegParms
numSlotsOfAny(sqInt _objOop)
{
	usqInt _numSlots;

	_numSlots = byteAt(_objOop + 7);
	return ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
}
/* SpurMemoryManager>>#numSlotsOf: */
usqInt
numSlotsOf(sqInt _objOop)
{
	usqInt _numSlots;

	flag("endianness");
	assert((classIndexOf(_objOop)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_objOop + 7);
	return ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
}
/*	Answer the number of strong pointer fields in the given object, 
	which is expected not to be an active ephemeron. 
	Works with CompiledMethods, as well as ordinary objects. */
/* SpurMemoryManager>>#numStrongSlotsOfInephemeral: */
static sqInt NoDbgRegParms
numStrongSlotsOfInephemeral(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classFormat;
	sqInt _contextSize;
	sqInt _fmt;
	sqInt _header;
	sqInt _header2;
	sqInt _key;
	sqInt _numLiterals;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _sp;

	_fmt = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	assert((_fmt != (ephemeronFormat())) || ((isImmediate((_key = keyOfEphemeron(_objOop)))) || (isMarkedOrPermanent(_key))));
	if (_fmt <= 5) {
		/* begin numSlotsOf: */
		assert((classIndexOf(_objOop)) > (isForwardedObjectClassIndexPun()));
		_numSlots2 = byteAt(_objOop + 7);
		_numSlots = ((_numSlots2 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots2);
		/* end numSlotsOf: */
		if (_fmt <= 2) {
			return _numSlots;
		}
		if (_fmt == (indexablePointersFormat())) {
			if (((longAt(_objOop)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
				setTraceFlagOnContextsFramesPageIfNeeded(_objOop);
				/* begin fetchStackPointerOf: */
				/* begin fetchPointer:ofObject: */
				_sp = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (!(((_sp & 7) == 1))) {
					_contextSize = 0;
					goto l4;
				}
				assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_objOop)));
				_contextSize = _sp >> 3;
				l4:
				;
				/* end fetchStackPointerOf: */
				return CtxtTempFrameStart + _contextSize;
			}
			return _numSlots;
		}
		if (_fmt == (weakArrayFormat())) {
			/* begin fixedFieldsOfClass: */
			_objOop2 = fetchClassOfNonImm(_objOop);
			/* begin fixedFieldsOfClassFormat: */
			_classFormat = (unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
			return _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
			/* end fixedFieldsOfClassFormat: */
			/* end fixedFieldsOfClass: */
		}
	}
	if (_fmt == 7) {
		return 1;
	}
	if (_fmt < (firstCompiledMethodFormat())) {
		return 0;
	}
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_objOop));
	/* begin fetchPointer:ofObject: */
	_header2 = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header2 & 7) == 1)) {
		_header = _header2;
	} else {
		assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_header = ((((CogMethod *) _header2 ))->methodHeader);
	}
	/* end methodHeaderOf: */
	{
		assert(((_header & 7) == 1));
		_numLiterals = (_header >> 3) & AlternateHeaderNumLiteralsMask;
	}
	return _numLiterals + LiteralStart;
}
/*	Answer the number of strong pointer fields in the given weakling. */
/* SpurMemoryManager>>#numStrongSlotsOfWeakling: */
sqInt
numStrongSlotsOfWeakling(sqInt _objOop)
{
	sqInt _classFormat;
	sqInt _objOop2;

	assert((formatOf(_objOop)) == (weakArrayFormat()));
	/* begin fixedFieldsOfClass: */
	_objOop2 = fetchClassOfNonImm(_objOop);
	/* begin fixedFieldsOfClassFormat: */
	_classFormat = (unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	return _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	/* end fixedFieldsOfClassFormat: */
	/* end fixedFieldsOfClass: */
}
/*	Object parsing. 
	1. all objects have at least a word following the header, for a forwarding 
	pointer. 2. objects with an overflow size have a preceeing word with a 
	saturated slotSize. If the word following 
	an object doesn't have a saturated size field it must be a single-header 
	object. If the word following 
	does have a saturated slotSize it must be the overflow size word. */
/* SpurMemoryManager>>#objectAfter: */
sqInt
objectAfter(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	sqInt _followingWord5;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	usqInt _followingWordAddress5;
	sqInt _limit;
	sqInt _limit2;
	sqInt _limit3;

	if (oopisLessThan(_objOop, (GIV(memoryMap)->newSpaceEnd))) {
		if (oopisGreaterThanOrEqualToandLessThan(_objOop, ((eden()).start), GIV(freeStart))) {
			/* begin objectAfter:limit: */
			_followingWordAddress = addressAfter(_objOop);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress, GIV(freeStart))) {
				return GIV(freeStart);
			}
			flag("endianness");
			_followingWord = unsignedLongAt(_followingWordAddress);
			return (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress + BaseHeaderSize
				 : _followingWordAddress);
			/* end objectAfter:limit: */
		}
		if (oopisGreaterThanOrEqualToandLessThan(_objOop, ((pastSpace()).start), GIV(pastSpaceStart))) {
			/* begin objectAfter:limit: */
			_followingWordAddress2 = addressAfter(_objOop);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(pastSpaceStart))) {
				return GIV(pastSpaceStart);
			}
			flag("endianness");
			_followingWord2 = unsignedLongAt(_followingWordAddress2);
			return (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress2 + BaseHeaderSize
				 : _followingWordAddress2);
			/* end objectAfter:limit: */
		}
		/* begin objectAfter:limit: */
		_limit = futureSurvivorStart();
		_followingWordAddress3 = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, _limit)) {
			return _limit;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		return (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		/* end objectAfter:limit: */
	}
	if (_objOop >= 0x20000000000LL) {
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->permSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			return _limit2;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		return (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		/* end objectAfter:limit: */
	} else {
		/* begin objectAfter:limit: */
		_limit3 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress5 = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress5, _limit3)) {
			return _limit3;
		}
		flag("endianness");
		_followingWord5 = unsignedLongAt(_followingWordAddress5);
		return (((((usqInt) _followingWord5 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress5 + BaseHeaderSize
			 : _followingWordAddress5);
		/* end objectAfter:limit: */
	}
}
/* SpurMemoryManager>>#objectBefore: */
sqInt
objectBefore(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _objOop3;
	sqInt _prev;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	_prev = null;
	if (oopisLessThan(_objOop, (GIV(memoryMap)->newSpaceEnd))) {
		/* begin allNewSpaceEntitiesDo: */
		_prevPrevObj = (_prevObj = null);
		assert((((pastSpace()).start)) < (((eden()).start)));
		/* begin objectStartingAt: */
		_address = ((pastSpace()).start);
		_numSlots = byteAt(_address + 7);
		_objOop2 = ((_numSlots == (numSlotsMask()))
			 ? _address + BaseHeaderSize
			 : _address);
		/* end objectStartingAt: */
		_limit = GIV(pastSpaceStart);
		while (oopisLessThan(_objOop2, _limit)) {
			{
				if (oopisGreaterThanOrEqualTo(_objOop2, _objOop)) {
					return _prev;
				}
				_prev = _objOop2;
			}
			_prevPrevObj = _prevObj;
			_prevObj = _objOop2;
			/* begin objectAfter:limit: */
			_followingWordAddress = addressAfter(_objOop2);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
				_objOop2 = _limit;
				goto l2;
			}
			flag("endianness");
			_followingWord = unsignedLongAt(_followingWordAddress);
			_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress + BaseHeaderSize
				 : _followingWordAddress);
			l2:
			;
			/* end objectAfter:limit: */
		}
		/* begin objectStartingAt: */
		_address2 = ((eden()).start);
		_numSlots2 = byteAt(_address2 + 7);
		_objOop2 = ((_numSlots2 == (numSlotsMask()))
			 ? _address2 + BaseHeaderSize
			 : _address2);
		/* end objectStartingAt: */
		while (oopisLessThan(_objOop2, GIV(freeStart))) {
			{
				if (oopisGreaterThanOrEqualTo(_objOop2, _objOop)) {
					return _prev;
				}
				_prev = _objOop2;
			}
			_prevPrevObj = _prevObj;
			_prevObj = _objOop2;
			/* begin objectAfter:limit: */
			_followingWordAddress2 = addressAfter(_objOop2);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
				_objOop2 = GIV(freeStart);
				goto l3;
			}
			flag("endianness");
			_followingWord2 = unsignedLongAt(_followingWordAddress2);
			_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress2 + BaseHeaderSize
				 : _followingWordAddress2);
			l3:
			;
			/* end objectAfter:limit: */
		}
		/* end allNewSpaceEntitiesDo: */
		return _prev;
	}
	/* begin allOldSpaceEntitiesDo: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop3 = GIV(nilObj);
	while (1) {
		assert((_objOop3 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop3, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop3)) != 0);
		{
			if (oopisGreaterThanOrEqualTo(_objOop3, _objOop)) {
				return _prev;
			}
			_prev = _objOop3;
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop3;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress3 = addressAfter(_objOop3);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, _limit2)) {
			_objOop3 = _limit2;
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_objOop3 = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceEntitiesDo: */
	return _prev;
}
/*	For enumerating objects find the header of the first object in a space. 
	If the object starts with an overflow size field it will start at the next 
	allocationUnit. c.f. numSlotsOf: */
/* SpurMemoryManager>>#objectStartingAt: */
static sqInt NoDbgRegParms
objectStartingAt(sqInt _address)
{
	usqInt _numSlots;

	_numSlots = byteAt(_address + 7);
	return ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
}
/*	This message is deprecated but supported for a while via a tweak to 
	sqVirtualMachine.[ch] Use fetchLong32, fetchLong64 or fetchPointer instead 
	for new code */
/* SpurMemoryManager>>#obsoleteDontUseThisFetchWord:ofObject: */
sqInt
obsoleteDontUseThisFetchWordofObject(sqInt _fieldIndex, sqInt _oop)
{
	/* begin fetchLong32:ofObject: */
	return long32At((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << 2) ));
	/* end fetchLong32:ofObject: */
}
/*	Object parsing. 
	1. all objects have at least a word following the header, for a forwarding 
	pointer. 2. objects with an overflow size have a preceeing word with a 
	saturated slotSize. If the word following 
	an object doesn't have a saturated size field it must be a single-header 
	object. If the word following 
	does have a saturated slotSize it must be the overflow size word. */
/* SpurMemoryManager>>#oldSpaceObjectAfter: */
sqInt
oldSpaceObjectAfter(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _followingWord;
	usqInt _followingWordAddress;
	sqInt _limit;

	/* begin objectAfter:limit: */
	_limit = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
	_followingWordAddress = addressAfter(_objOop);
	if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
		return _limit;
	}
	flag("endianness");
	_followingWord = unsignedLongAt(_followingWordAddress);
	return (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
		 ? _followingWordAddress + BaseHeaderSize
		 : _followingWordAddress);
	/* end objectAfter:limit: */
}
/* SpurMemoryManager>>#oldSpaceSizeToWrite */
static size_t
oldSpaceSizeToWrite(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	size_t _total;

	/* begin totalBytesInNonEmptySegments */
	_total = 0;
	for (_i = 0; _i < GIV(numSegments); _i += 1) {
		if ((((GIV(segments)[_i]).segSize)) > (2 * BaseHeaderSize)) {
			_total += ((GIV(segments)[_i]).segSize);
		}
	}
	return _total;
	/* end totalBytesInNonEmptySegments */
}
/*	in an effort to fix a compiler bug with two-way become post r3427Allocate two new objects, n1 & n2. Copy the contents appropriately. 
	Convert obj1 and obj2 into forwarding objects pointing to n2 and n1 
	respectively  */
/* SpurMemoryManager>>#outOfPlaceBecome:and:copyHashFlag: */
static void NoDbgRegParms NeverInline
outOfPlaceBecomeandcopyHashFlag(sqInt _obj1, sqInt _obj2, sqInt _copyHashFlag)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classIndex;
	sqInt _classIndex2;
	sqInt _clone1;
	sqInt _clone2;
	sqInt _hash;
	sqInt _hash2;
	sqInt _hash3;
	sqInt _hash4;

	_clone1 = ((((longAt(_obj1)) & (classIndexMask())) == ClassMethodContextCompactIndex)
		 ? cloneContext(_obj1)
		 : cloneshouldAllocateInPermSpace(_obj1, _obj1 >= 0x20000000000LL));
	if (!_clone1) {
		error("Not enough space to copy the objects in two-way become. This should have been detected before");
		return;
	}
	_clone2 = ((((longAt(_obj2)) & (classIndexMask())) == ClassMethodContextCompactIndex)
		 ? cloneContext(_obj2)
		 : cloneshouldAllocateInPermSpace(_obj2, _obj2 >= 0x20000000000LL));
	if (!_clone2) {
		error("Not enough space to copy the objects in two-way become. This should have been detected before");
		return;
	}
	if (
#    if IMMUTABILITY
			(/* begin isImmutable: */ ((((usqInt) (longAt(_obj1)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#    else /* IMMUTABILITY */
			0
#    endif /* IMMUTABILITY */
			) {
		/* begin setIsImmutableOf:to: */
		longAtput(_clone1, (longAt(_clone1)) | (1U << (immutableBitShift())));
		/* end setIsImmutableOf:to: */
	}
	if (
#    if IMMUTABILITY
			(/* begin isImmutable: */ ((((usqInt) (longAt(_obj2)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#    else /* IMMUTABILITY */
			0
#    endif /* IMMUTABILITY */
			) {
		/* begin setIsImmutableOf:to: */
		longAtput(_clone2, (longAt(_clone2)) | (1U << (immutableBitShift())));
		/* end setIsImmutableOf:to: */
	}
	if (_copyHashFlag) {
		/* begin setHashBitsOf:to: */
		_hash = (uint32AtPointer(_obj1 + 4)) & (identityHashHalfWordMask());
		assert((_hash >= 0) && (_hash <= (identityHashHalfWordMask())));
		uint32AtPointerput(_clone1 + 4, (((uint32AtPointer(_clone1 + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + _hash);
		/* end setHashBitsOf:to: */
		/* begin setHashBitsOf:to: */
		_hash2 = (uint32AtPointer(_obj2 + 4)) & (identityHashHalfWordMask());
		assert((_hash2 >= 0) && (_hash2 <= (identityHashHalfWordMask())));
		uint32AtPointerput(_clone2 + 4, (((uint32AtPointer(_clone2 + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + _hash2);
		/* end setHashBitsOf:to: */
	} else {
		/* begin setHashBitsOf:to: */
		_hash3 = (uint32AtPointer(_obj2 + 4)) & (identityHashHalfWordMask());
		assert((_hash3 >= 0) && (_hash3 <= (identityHashHalfWordMask())));
		uint32AtPointerput(_clone1 + 4, (((uint32AtPointer(_clone1 + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + _hash3);
		/* end setHashBitsOf:to: */
		/* begin setHashBitsOf:to: */
		_hash4 = (uint32AtPointer(_obj1 + 4)) & (identityHashHalfWordMask());
		assert((_hash4 >= 0) && (_hash4 <= (identityHashHalfWordMask())));
		uint32AtPointerput(_clone2 + 4, (((uint32AtPointer(_clone2 + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + _hash4);
		/* end setHashBitsOf:to: */
	}
	{
		/* begin forward:to: */
		/* begin set:classIndexTo:formatTo: */
		_classIndex = isForwardedObjectClassIndexPun();
		assert((_classIndex >= 0) && (_classIndex <= (classIndexMask())));
		assert((7 >= 0) && (7 <= (formatMask())));
		longAtput(_obj1, ((longAt(_obj1)) & (~((usqIntptr_t) (((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) + (classIndexMask())) ))) + (_classIndex + (7U << (formatShift()))));
		/* end set:classIndexTo:formatTo: */
		
#    if IMMUTABILITY
		{
			/* begin setIsImmutableOf:to: */
			longAtput(_obj1, (longAt(_obj1)) & (~((usqIntptr_t) (1U << (immutableBitShift())) )));
			/* end setIsImmutableOf:to: */
		}
#    endif /* IMMUTABILITY */
		/* begin storePointer:ofForwarder:withValue: */
		assert(isForwarded(_obj1));
		assert(!(isOopForwarded(_clone2)));
		if ((_obj1 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask))) {
			if (((_clone2 & (tagMask())) == 0) && (((_clone2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_clone2 >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_obj1)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _obj1);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_obj1)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l5;
		}
		if (_clone2 & (tagMask())) {
			goto l5;
		}
		if (!(_obj1 >= 0x20000000000LL)) {
			goto l5;
		}
		if (_clone2 >= 0x20000000000LL) {
			goto l5;
		}
		if ((_clone2 >= GIV(nilObj)) && (_clone2 <= GIV(trueObj))) {
			goto l5;
		}
		if (!(_clone2 >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l5;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _obj1);
		l5:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_obj1 + BaseHeaderSize) + (0U << (shiftForWord())), _clone2);
		/* end storePointer:ofForwarder:withValue: */
		if ((byteAt(_obj1 + 7)) == 0) {
			byteAtput(_obj1 + 7, 1);
		}
		/* end forward:to: */
		/* begin forward:to: */
		/* begin set:classIndexTo:formatTo: */
		_classIndex2 = isForwardedObjectClassIndexPun();
		assert((_classIndex2 >= 0) && (_classIndex2 <= (classIndexMask())));
		assert((7 >= 0) && (7 <= (formatMask())));
		longAtput(_obj2, ((longAt(_obj2)) & (~((usqIntptr_t) (((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) + (classIndexMask())) ))) + (_classIndex2 + (7U << (formatShift()))));
		/* end set:classIndexTo:formatTo: */
		
#    if IMMUTABILITY
		{
			/* begin setIsImmutableOf:to: */
			longAtput(_obj2, (longAt(_obj2)) & (~((usqIntptr_t) (1U << (immutableBitShift())) )));
			/* end setIsImmutableOf:to: */
		}
#    endif /* IMMUTABILITY */
		/* begin storePointer:ofForwarder:withValue: */
		assert(isForwarded(_obj2));
		assert(!(isOopForwarded(_clone1)));
		if ((_obj2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask))) {
			if (((_clone1 & (tagMask())) == 0) && (((_clone1 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_clone1 >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_obj2)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _obj2);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_obj2)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l7;
		}
		if (_clone1 & (tagMask())) {
			goto l7;
		}
		if (!(_obj2 >= 0x20000000000LL)) {
			goto l7;
		}
		if (_clone1 >= 0x20000000000LL) {
			goto l7;
		}
		if ((_clone1 >= GIV(nilObj)) && (_clone1 <= GIV(trueObj))) {
			goto l7;
		}
		if (!(_clone1 >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l7;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _obj2);
		l7:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_obj2 + BaseHeaderSize) + (0U << (shiftForWord())), _clone1);
		/* end storePointer:ofForwarder:withValue: */
		if ((byteAt(_obj2 + 7)) == 0) {
			byteAtput(_obj2 + 7, 1);
		}
		/* end forward:to: */
	}
	if (((((_obj1 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_obj1 >= ((GIV(memoryMap)->newSpaceStart)))) != (((_clone2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_clone2 >= ((GIV(memoryMap)->newSpaceStart))))) || ((((_obj2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_obj2 >= ((GIV(memoryMap)->newSpaceStart)))) != (((_clone1 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_clone1 >= ((GIV(memoryMap)->newSpaceStart)))))) {
		GIV(becomeEffectsFlags) = GIV(becomeEffectsFlags) | OldBecameNewFlag;
	}
}
/*	NOTE: shiftForElement is elementSizeInBytes log: 2. 
	This means elementSizeInBytes should be a power of two.Cheap way to do instBytes \\ self wordSize (assumes self wordSize is a 
	power of two) */
/* SpurMemoryManager>>#paddingForFormatInstBytes:shiftForElement: */
static sqInt NoDbgRegParms
paddingForFormatInstBytesshiftForElement(sqInt _instBytes, sqInt _shiftForElement)
{
	sqInt _paddingBytes;
	sqInt _trailingBytes;

	_trailingBytes = _instBytes & (BytesPerWord - 1);
	_paddingBytes = BytesPerWord - _trailingBytes;
	_paddingBytes = _paddingBytes & (BytesPerWord - 1);
	return ((usqInt) _paddingBytes ) >> _shiftForElement;
}
/*	Attempt to pin objOop, which must not be immediate. 
	If the attempt succeeds answer objOop's (possibly moved) oop. 
	If the attempt fails, which can only occur if there is no memory, answer 
	0.  */
/* SpurMemoryManager>>#pinObject: */
sqInt
pinObject(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classIndex;
	sqInt _i;
	sqInt _oldClone;
	sqInt _referent;
	SpurSegmentInfo *_seg;

	assert(isNonImmediate(_objOop));
	flag("policy decision here. if already old, do we clone in a segment containing pinned objects or merely pin?");
	if ((_objOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask))) {
		if ((numBytesOf(_objOop)) > (1024 * 1024)) {
			/* begin setIsPinnedOf:to: */
			longAtput(_objOop, (longAt(_objOop)) | (1U << (pinnedBitShift())));
			/* end setIsPinnedOf:to: */
			return _objOop;
		}
		/* begin segmentContainingObj: */
		for (_i = GIV(numSegments) - 1; _i >= 0; _i += -1) {
			if (_objOop >= (((GIV(segments)[_i]).segStart))) {
				_seg = &(GIV(segments)[_i]);
				goto l2;
			}
		}
		_seg = null;
		l2:
		;
		/* end segmentContainingObj: */
		if ((_seg->containsPinned)) {
			/* begin setIsPinnedOf:to: */
			longAtput(_objOop, (longAt(_objOop)) | (1U << (pinnedBitShift())));
			/* end setIsPinnedOf:to: */
			return _objOop;
		}
		if (!(someSegmentContainsPinned())) {
			/* begin setIsPinnedOf:to: */
			longAtput(_objOop, (longAt(_objOop)) | (1U << (pinnedBitShift())));
			/* end setIsPinnedOf:to: */
			(_seg->containsPinned = 1);
			return _objOop;
		}
	}
	_oldClone = cloneInOldSpaceforPinning(_objOop, 1);
	if (_oldClone != 0) {
		GIV(becomeEffectsFlags) = becomeEffectFlagsFor(_objOop);
		/* begin setIsPinnedOf:to: */
		longAtput(_oldClone, (longAt(_oldClone)) | (1U << (pinnedBitShift())));
		/* end setIsPinnedOf:to: */
		/* begin forward:to: */
		/* begin set:classIndexTo:formatTo: */
		_classIndex = isForwardedObjectClassIndexPun();
		assert((_classIndex >= 0) && (_classIndex <= (classIndexMask())));
		assert((7 >= 0) && (7 <= (formatMask())));
		longAtput(_objOop, ((longAt(_objOop)) & (~((usqIntptr_t) (((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) + (classIndexMask())) ))) + (_classIndex + (7U << (formatShift()))));
		/* end set:classIndexTo:formatTo: */
		
#    if IMMUTABILITY
		{
			/* begin setIsImmutableOf:to: */
			longAtput(_objOop, (longAt(_objOop)) & (~((usqIntptr_t) (1U << (immutableBitShift())) )));
			/* end setIsImmutableOf:to: */
		}
#    endif /* IMMUTABILITY */
		/* begin storePointer:ofForwarder:withValue: */
		assert(isForwarded(_objOop));
		assert(!(isOopForwarded(_oldClone)));
		if ((_objOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask))) {
			if (((_oldClone & (tagMask())) == 0) && (((_oldClone & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_oldClone >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _objOop);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l7;
		}
		if (_oldClone & (tagMask())) {
			goto l7;
		}
		if (!(_objOop >= 0x20000000000LL)) {
			goto l7;
		}
		if (_oldClone >= 0x20000000000LL) {
			goto l7;
		}
		if ((_oldClone >= GIV(nilObj)) && (_oldClone <= GIV(trueObj))) {
			goto l7;
		}
		if (!(_oldClone >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l7;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _objOop);
		l7:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_objOop + BaseHeaderSize) + (0U << (shiftForWord())), _oldClone);
		/* end storePointer:ofForwarder:withValue: */
		if ((byteAt(_objOop + 7)) == 0) {
			byteAtput(_objOop + 7, 1);
		}
		/* end forward:to: */
		/* begin followSpecialObjectsOop */
		if (((long64At(GIV(specialObjectsOop))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
			/* begin followForwarded: */
			assert(isUnambiguouslyForwarder(GIV(specialObjectsOop)));
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
			while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
			}
			GIV(specialObjectsOop) = _referent;
			/* end followForwarded: */
		}
		followForwardedObjectFieldstoDepth(GIV(specialObjectsOop), 0);
		/* end followSpecialObjectsOop */
		postBecomeAction(GIV(becomeEffectsFlags));
		postBecomeScanClassTable(GIV(becomeEffectsFlags));
		GIV(becomeEffectsFlags) = 0;
	}
	return _oldClone;
}
/* SpurMemoryManager>>#popObjStack: */
static sqInt NoDbgRegParms
popObjStack(sqInt _objStack)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _myx;
	sqInt _nextPage;
	sqInt _top;
	sqInt _topx;

	eassert(isValidObjStack(_objStack));
	/* begin fetchPointer:ofObject: */
	_topx = unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_topx == 0) {
		assert((fetchPointerofObject(ObjStackNextx, _objStack)) == 0);
		return null;
	}
	_topx -= 1;
	/* begin fetchPointer:ofObject: */
	_top = unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) (_topx + ObjStackFixedSlots) ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* begin storePointer:ofObject:withValue: */
	assert(!(isForwarded(_objStack)));
	if (((_objStack & (tagMask())) == 0) && ((_objStack & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((195948557 & (tagMask())) == 0) && (((195948557 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (195948557 >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_objStack)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _objStack);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(_objStack)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l11;
	}
	if (195948557 & (tagMask())) {
		goto l11;
	}
	if (!(_objStack >= 0x20000000000LL)) {
		goto l11;
	}
	if ((195948557 >= GIV(nilObj)) && (195948557 <= GIV(trueObj))) {
		goto l11;
	}
	if (!(195948557 >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l11;
	}
	remember(getFromPermToNewSpaceRememberedSet(), _objStack);
	l11:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) (_topx + ObjStackFixedSlots) ) << (shiftForWord())) ), 195948557);
	/* end storePointer:ofObject:withValue: */
	/* begin storePointer:ofObjStack:withValue: */
	assert((formatOf(_objStack)) == (wordIndexableFormat()));
	unsignedLongAtput((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ), _topx);
	/* end storePointer:ofObjStack:withValue: */
	if ((_topx == 0) && (((_nextPage = unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) )))) != 0)) {
		/* begin storePointer:ofObjStack:withValue: */
		assert((formatOf(_nextPage)) == (wordIndexableFormat()));
		unsignedLongAtput((_nextPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) ), _objStack);
		/* end storePointer:ofObjStack:withValue: */
		/* begin storePointer:ofObjStack:withValue: */
		assert((formatOf(_objStack)) == (wordIndexableFormat()));
		unsignedLongAtput((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ), 0);
		/* end storePointer:ofObjStack:withValue: */
		/* begin fetchPointer:ofObject: */
		_myx = unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackMyx ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* begin updateRootOfObjStackAt:with: */
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(GIV(hiddenRootsObj))));
		if (((GIV(hiddenRootsObj) & (tagMask())) == 0) && ((GIV(hiddenRootsObj) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_nextPage & (tagMask())) == 0) && (((_nextPage & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_nextPage >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(GIV(hiddenRootsObj))) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), GIV(hiddenRootsObj));
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(GIV(hiddenRootsObj))) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l9;
		}
		if (_nextPage & (tagMask())) {
			goto l9;
		}
		if (!(GIV(hiddenRootsObj) >= 0x20000000000LL)) {
			goto l9;
		}
		if (_nextPage >= 0x20000000000LL) {
			goto l9;
		}
		if ((_nextPage >= GIV(nilObj)) && (_nextPage <= GIV(trueObj))) {
			goto l9;
		}
		if (!(_nextPage >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l9;
		}
		remember(getFromPermToNewSpaceRememberedSet(), GIV(hiddenRootsObj));
		l9:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _myx ) << (shiftForWord())) ), _nextPage);
		/* end storePointer:ofObject:withValue: */
		switch (_myx) {
			case MarkStackRootIndex:
			{
				GIV(markStack) = _nextPage;
			}
			break;
			case WeaklingStackRootIndex:
			{
				GIV(weaklingStack) = _nextPage;
			}
			break;
			case MournQueueRootIndex:
			{
				GIV(mournQueue) = _nextPage;
			}
			break;
			default:
			error("Case not found and no otherwise clause");
		}
		/* end updateRootOfObjStackAt:with: */
		eassert(isValidObjStack(_nextPage));
	} else {
		eassert(isValidObjStack(_objStack));
	}
	return _top;
}
/*	Pop and return the possibly remapped object from the remap buffer. 
	We support this excessence for compatibility with ObjectMemory. 
	Spur doesn't GC during allocation. */
/* SpurMemoryManager>>#popRemappableOop */
sqInt
popRemappableOop(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _oop;

	_oop = GIV(remapBuffer)[GIV(remapBufferCount)];
	GIV(remapBufferCount) -= 1;
	return _oop;
}
/*	Scan the class table post-become (iff an active class object was becommed) 
	to ensure no 
	forwarding pointers, and no unhashed classes exist in the class table. 
	 
	Note that one-way become can cause duplications in the class table. 
	When can these be eliminated? We use the classTableBitmap to mark 
	classTable entries 
	(not the classes themselves, since marking a class doesn't help in knowing 
	if its index is used). 
	On image load, and during incrememtal scan-mark and full GC, classIndices 
	are marked. 
	We can somehow avoid following classes from the classTable until after 
	this mark phase. */
/* SpurMemoryManager>>#postBecomeScanClassTable: */
static void NoDbgRegParms
postBecomeScanClassTable(sqInt _effectsFlags)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classOrNil;
	sqInt _i;
	sqInt _iLimit;
	sqInt _j;
	sqInt _page;
	sqInt _referent;

	assert(validClassTableRootPages());
	if (!(_effectsFlags & BecameActiveClassFlag)) {
		return;
	}
	for (_i = 0; _i < GIV(numClassTablePages); _i += 1) {
		/* begin fetchPointer:ofObject: */
		_page = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert(!(isForwarded(_page)));
		for (_j = 0, _iLimit = (numSlotsOf(_page)) - 1; _j <= _iLimit; _j += 1) {
			/* begin fetchPointer:ofObject: */
			_classOrNil = unsignedLongAt((_page + BaseHeaderSize) + ((sqInt) (((usqInt) _j ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (_classOrNil != GIV(nilObj)) {
				if (((long64At(_classOrNil)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					/* begin followForwarded: */
					assert(isUnambiguouslyForwarder(_classOrNil));
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent = unsignedLongAt((_classOrNil + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
					while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
					}
					_classOrNil = _referent;
					/* end followForwarded: */
					/* begin storePointer:ofObject:withValue: */
					assert(!(isForwarded(_page)));
					if (((_page & (tagMask())) == 0) && ((_page & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
						if (((_classOrNil & (tagMask())) == 0) && (((_classOrNil & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_classOrNil >= ((GIV(memoryMap)->newSpaceStart))))) {
							/* begin possibleOldObjectStoreInto: */
							if (!(((((usqInt) (long64At(_page)) ) >> (rememberedBitShift())) & 1) != 0)) {
								remember(GIV(fromOldSpaceRememberedSet), _page);
							}
							/* end possibleOldObjectStoreInto: */
						}
					}
					/* begin possiblePermObjectStoreInto:value: */
					if (((((usqInt) (long64At(_page)) ) >> (rememberedBitShift())) & 1) != 0) {
						goto l7;
					}
					if (_classOrNil & (tagMask())) {
						goto l7;
					}
					if (!(_page >= 0x20000000000LL)) {
						goto l7;
					}
					if (_classOrNil >= 0x20000000000LL) {
						goto l7;
					}
					if ((_classOrNil >= GIV(nilObj)) && (_classOrNil <= GIV(trueObj))) {
						goto l7;
					}
					if (!(_classOrNil >= (startOfObjectMemory(GIV(memoryMap))))) {
						goto l7;
					}
					remember(getFromPermToNewSpaceRememberedSet(), _page);
					l7:
					;
					/* end possiblePermObjectStoreInto:value: */
					unsignedLongAtput((_page + BaseHeaderSize) + ((sqInt) (((usqInt) _j ) << (shiftForWord())) ), _classOrNil);
					/* end storePointer:ofObject:withValue: */
				}
				if (((uint32AtPointer(_classOrNil + 4)) & (identityHashHalfWordMask())) == 0) {
					{
						assert(!(isOopForwarded(_page)));
						longAtput((_page + BaseHeaderSize) + ((sqInt) (((usqInt) _j ) << (shiftForWord())) ), GIV(nilObj));
					}
					if ((((sqInt) (((usqInt) _i ) << (classTableMajorIndexShift())) ) + _j) < GIV(classTableIndex)) {
						GIV(classTableIndex) = ((sqInt) (((usqInt) _i ) << (classTableMajorIndexShift())) ) + _j;
					}
				}
			}
		}
	}
	assert(GIV(classTableIndex) >= (1U << (classTableMajorIndexShift())));
}
/* SpurMemoryManager>>#primitiveErrorTable */
sqInt
primitiveErrorTable(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) PrimErrTableIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/*	Scan the heap printing the oops of any and all contexts that refer to 
	anOop  */
/* SpurMemoryManager>>#printActivationsOf: */
void
printActivationsOf(sqInt _aMethodObj)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	/* begin allObjectsDo: */
	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop2 = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop2, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if ((((longAt(_objOop2)) & (classIndexMask())) == ClassMethodContextCompactIndex) && (_aMethodObj == (unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ))))) {
					{
						printHex(_objOop2);
						/* begin space */
						printChar(' ');
						/* end space */
						printOopShort(_objOop2);
						print(" pc ");
						printHex(unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )));
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop2 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if ((((longAt(_objOop2)) & (classIndexMask())) == ClassMethodContextCompactIndex) && (_aMethodObj == (unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ))))) {
					{
						printHex(_objOop2);
						/* begin space */
						printChar(' ');
						/* end space */
						printOopShort(_objOop2);
						print(" pc ");
						printHex(unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )));
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop2 = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	/* begin allOldSpaceObjectsDo: */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop22 = GIV(nilObj);
	while (1) {
		assert((_objOop22 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop22)) != 0);
		{
			if (isEnumerableObject(_objOop22)) {
				{
					if ((((longAt(_objOop22)) & (classIndexMask())) == ClassMethodContextCompactIndex) && (_aMethodObj == (unsignedLongAt((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ))))) {
						{
							printHex(_objOop22);
							/* begin space */
							printChar(' ');
							/* end space */
							printOopShort(_objOop22);
							print(" pc ");
							printHex(unsignedLongAt((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )));
							/* begin cr */
							print("\n");
							/* end cr */
						}
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop22 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	/* end allOldSpaceObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if ((((longAt(_currentObject)) & (classIndexMask())) == ClassMethodContextCompactIndex) && (_aMethodObj == (unsignedLongAt((_currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ))))) {
					{
						printHex(_currentObject);
						/* begin space */
						printChar(' ');
						/* end space */
						printOopShort(_currentObject);
						print(" pc ");
						printHex(unsignedLongAt((_currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )));
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
}
/* SpurMemoryManager>>#printBogons */
void
printBogons(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin printTheBogons: */
	{
		print("bogon ");
		printHexnp(GIV(bogon));
		/* begin cr */
		print("\n");
		/* end cr */
		print("anomaly ");
		printHexnp(GIV(anomaly));
		/* begin cr */
		print("\n");
		/* end cr */
	}
	/* end printTheBogons: */
}
/* SpurMemoryManager>>#printClassTableEntries */
void
printClassTableEntries(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _page;

	{
		print("Class Table Entries");
		/* begin cr */
		print("\n");
		/* end cr */
	}
	{
		print("-----------------");
		/* begin cr */
		print("\n");
		/* end cr */
		/* begin cr */
		print("\n");
		/* end cr */
	}
	for (_i = 0; _i < GIV(numClassTablePages); _i += 1) {
		printNum(_i);
		/* begin fetchPointer:ofObject: */
		_page = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		longPrintOop(_page);
	}
}
/*	Scan the heap printing the oops of any and all contexts that refer to 
	anOop  */
/* SpurMemoryManager>>#printContextReferencesTo: */
void
printContextReferencesTo(sqInt _anOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	sqInt _i;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	/* begin allObjectsDo: */
	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop2 = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop2, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((longAt(_objOop2)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
					_i = CtxtTempFrameStart + (fetchStackPointerOf(_objOop2));
					while (((_i -= 1)) >= 0) {
						if (_anOop == (unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
							{
								printHex(_objOop2);
								print(" @ ");
								printNum(_i);
								/* begin space */
								printChar(' ');
								/* end space */
								printOopShort(_objOop2);
								print(" pc ");
								printHex(unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )));
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_i = 0;
						}
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop2 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((longAt(_objOop2)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
					_i = CtxtTempFrameStart + (fetchStackPointerOf(_objOop2));
					while (((_i -= 1)) >= 0) {
						if (_anOop == (unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
							{
								printHex(_objOop2);
								print(" @ ");
								printNum(_i);
								/* begin space */
								printChar(' ');
								/* end space */
								printOopShort(_objOop2);
								print(" pc ");
								printHex(unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )));
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_i = 0;
						}
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop2 = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	/* begin allOldSpaceObjectsDo: */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop22 = GIV(nilObj);
	while (1) {
		assert((_objOop22 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop22)) != 0);
		{
			if (isEnumerableObject(_objOop22)) {
				{
					if (((longAt(_objOop22)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
						_i = CtxtTempFrameStart + (fetchStackPointerOf(_objOop22));
						while (((_i -= 1)) >= 0) {
							if (_anOop == (unsignedLongAt((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
								{
									printHex(_objOop22);
									print(" @ ");
									printNum(_i);
									/* begin space */
									printChar(' ');
									/* end space */
									printOopShort(_objOop22);
									print(" pc ");
									printHex(unsignedLongAt((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )));
									/* begin cr */
									print("\n");
									/* end cr */
								}
								_i = 0;
							}
						}
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop22 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	/* end allOldSpaceObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (((longAt(_currentObject)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
					_i = CtxtTempFrameStart + (fetchStackPointerOf(_currentObject));
					while (((_i -= 1)) >= 0) {
						if (_anOop == (unsignedLongAt((_currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
							{
								printHex(_currentObject);
								print(" @ ");
								printNum(_i);
								/* begin space */
								printChar(' ');
								/* end space */
								printOopShort(_currentObject);
								print(" pc ");
								printHex(unsignedLongAt((_currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )));
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_i = 0;
						}
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
}
/* SpurMemoryManager>>#printEntity: */
void
printEntity(sqInt _oop)
{
	int _printFlags;

	_printFlags = 0;
	{
		printHex(_oop);
		/* begin space */
		printChar(' ');
		/* end space */
	}
	if (!(addressCouldBeObj(_oop))) {
		{
			print(((_oop & (tagMask()))
				 ? "immediate"
				 : "unknown"));
			return;
		}
	}
	{
		print(((((longAt(_oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))
			 ? "free"
			 : ((((longAt(_oop)) & (classIndexMask())) == (segmentBridgePun()))
				 ? "bridge"
				 : ((((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)
					 ? "forwarder"
					 : ((((longAt(_oop)) & (classIndexMask())) <= (lastClassIndexPun()))
						 ? ((_printFlags = 1), "pun/obj stack")
						 : ((_printFlags = 1), "object"))))));
		/* begin space */
		printChar(' ');
		/* end space */
		printHexnpnp(byteAt(_oop + 7));
		print("/");
		printHexnpnp(bytesInObject(_oop));
		print("/");
		printNum(bytesInObject(_oop));
	}
	if (_printFlags) {
		{
			/* begin space */
			printChar(' ');
			/* end space */
			print(((((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) <= 15)
				 ? "f:0"
				 : "f:"));
			printHexnpnp((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask()));
			print(((((((usqInt) (longAt(_oop)) ) >> (greyBitShift())) & 1) != 0)
				 ? " g"
				 : " ."));
			print(((((((usqInt) (longAt(_oop)) ) >> (immutableBitShift())) & 1) != 0)
				 ? "i"
				 : "."));
			print(((((((usqInt) (longAt(_oop)) ) >> (markedBitFullShift())) & 1) != 0)
				 ? "m"
				 : "."));
			print(((((((usqInt) (longAt(_oop)) ) >> (pinnedBitShift())) & 1) != 0)
				 ? "p"
				 : "."));
			print(((((((usqInt) (long64At(_oop)) ) >> (rememberedBitShift())) & 1) != 0)
				 ? "r"
				 : "."));
		}
	}
	/* begin cr */
	print("\n");
	/* end cr */
}
/* SpurMemoryManager>>#printForwarders */
void
printForwarders(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _objOop3;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	/* begin allHeapEntitiesDo: */
	/* begin allOldSpaceEntitiesDo: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop2 = GIV(nilObj);
	while (1) {
		assert((_objOop2 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop2, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop2)) != 0);
		{
			if (((longAt(_objOop2)) & (classIndexMask())) == (isForwardedObjectClassIndexPun())) {
				{
					printHex(_objOop2);
					/* begin cr */
					print("\n");
					/* end cr */
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop2;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop2 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop2 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceEntitiesDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop3 = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop3, _limit)) {
		{
			if (((longAt(_objOop3)) & (classIndexMask())) == (isForwardedObjectClassIndexPun())) {
				{
					printHex(_objOop3);
					/* begin cr */
					print("\n");
					/* end cr */
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop3;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop3);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop3 = _limit;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop3 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop3 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop3, GIV(freeStart))) {
		{
			if (((longAt(_objOop3)) & (classIndexMask())) == (isForwardedObjectClassIndexPun())) {
				{
					printHex(_objOop3);
					/* begin cr */
					print("\n");
					/* end cr */
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop3;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop3);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop3 = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop3 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (((longAt(_currentObject)) & (classIndexMask())) == (isForwardedObjectClassIndexPun())) {
					{
						printHex(_currentObject);
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allHeapEntitiesDo: */
}
/*	This version goes through memory, printing all free chunks. 
	Other versions go through the free lists. This one will show 
	all free chunks even if the free lists are corrupt. */
/* SpurMemoryManager>>#printFreeChunks */
void
printFreeChunks(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;
	int _seenNewFreeChunk;

	_seenNewFreeChunk = 0;
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop, _limit)) {
		{
			if (((longAt(_objOop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
				if (!_seenNewFreeChunk) {
					{
						print("NewSpace CONTAINS FREE OBJECT(S)!!");
						/* begin cr */
						print("\n");
						/* end cr */
					}
					_seenNewFreeChunk = 1;
				}
				/* begin printFreeChunk: */
				printFreeChunkprintAsTreeNode(_objOop, 1);
				/* end printFreeChunk: */
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop = _limit;
			goto l2;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l2:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop, GIV(freeStart))) {
		{
			if (((longAt(_objOop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
				if (!_seenNewFreeChunk) {
					{
						print("NewSpace CONTAINS FREE OBJECT(S)!!");
						/* begin cr */
						print("\n");
						/* end cr */
					}
					_seenNewFreeChunk = 1;
				}
				/* begin printFreeChunk: */
				printFreeChunkprintAsTreeNode(_objOop, 1);
				/* end printFreeChunk: */
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* begin allOldSpaceEntitiesDo: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop2 = GIV(nilObj);
	while (1) {
		assert((_objOop2 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop2, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop2)) != 0);
		{
			if (((longAt(_objOop2)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
				/* begin printFreeChunk: */
				printFreeChunkprintAsTreeNode(_objOop2, 1);
				/* end printFreeChunk: */
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop2;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress3 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, _limit2)) {
			_objOop2 = _limit2;
			goto l8;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_objOop2 = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceEntitiesDo: */
}
/* SpurMemoryManager>>#printFreeChunk: */
void
printFreeChunk(sqInt _freeChunk)
{
	printFreeChunkprintAsTreeNode(_freeChunk, 1);
}
/* SpurMemoryManager>>#printFreeChunk:printAsTreeNode: */
static void NoDbgRegParms
printFreeChunkprintAsTreeNode(sqInt _freeChunk, sqInt _printAsTreeNode)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _numBytes;
	void *_p;
	void *_p2;
	void *_p3;
	void *_p4;
	void *_p5;
	void *_p6;

	_numBytes = bytesInObject(_freeChunk);
	{
		print("freeChunk ");
		/* begin printHexPtrnp: */
		printHexnp(oopForPointer(((void *) _freeChunk )));
		/* end printHexPtrnp: */
	}
	if (_printAsTreeNode) {
		{
			print(((_freeChunk == (GIV(freeLists)[0]))
				 ? " + "
				 : " - "));
			/* begin printHexPtrnp: */
			_p = ((void *) (addressAfter(_freeChunk)) );
			printHexnp(oopForPointer(_p));
			/* end printHexPtrnp: */
		}
	}
	{
		print(" bytes ");
		printNum(_numBytes);
		print(" next ");
		/* begin printHexPtrnp: */
		_p2 = ((void *) (unsignedLongAt((_freeChunk + BaseHeaderSize) + (0U << (shiftForWord())))) );
		printHexnp(oopForPointer(_p2));
		/* end printHexPtrnp: */
	}
	if (!((assert(_numBytes >= (BaseHeaderSize + (allocationUnit()))), _numBytes == (BaseHeaderSize + 8)))) {
		{
			print(" prev ");
			/* begin printHexPtrnp: */
			_p3 = ((void *) (unsignedLongAt((_freeChunk + BaseHeaderSize) + (1U << (shiftForWord())))) );
			printHexnp(oopForPointer(_p3));
			/* end printHexPtrnp: */
		}
	}
	if ((_numBytes >= (64 * 8)) && _printAsTreeNode) {
		{
			print(" ^ ");
			/* begin printHexPtrnp: */
			_p4 = ((void *) (unsignedLongAt((_freeChunk + BaseHeaderSize) + (2U << (shiftForWord())))) );
			printHexnp(oopForPointer(_p4));
			/* end printHexPtrnp: */
			print(" < ");
			/* begin printHexPtrnp: */
			_p5 = ((void *) (unsignedLongAt((_freeChunk + BaseHeaderSize) + (3U << (shiftForWord())))) );
			printHexnp(oopForPointer(_p5));
			/* end printHexPtrnp: */
			print(" > ");
			/* begin printHexPtrnp: */
			_p6 = ((void *) (unsignedLongAt((_freeChunk + BaseHeaderSize) + (4U << (shiftForWord())))) );
			printHexnp(oopForPointer(_p6));
			/* end printHexPtrnp: */
		}
	}
	/* begin cr */
	print("\n");
	/* end cr */
}
/* SpurMemoryManager>>#printFreeListHeads */
void
printFreeListHeads(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	int _expectedMask;
	sqInt _i;
	sqInt _iLimit;

	_expectedMask = 0;
	for (_i = 0, _iLimit = 64 - 1; _i <= _iLimit; _i += 1) {
		printHex(GIV(freeLists)[_i]);
		if ((GIV(freeLists)[_i]) != 0) {
			_expectedMask += 1ULL << _i;
		}
		if (((_i + 1) % (((usqInt) 32 ) >> 3)) == 0) {
			/* begin cr */
			print("\n");
			/* end cr */
		} else {
			print("  ");
		}
	}
	{
		/* begin cr */
		print("\n");
		/* end cr */
		print("mask: ");
		printHexnp(GIV(freeListsMask));
		print(" expected: ");
		printHexnp(_expectedMask);
		/* begin cr */
		print("\n");
		/* end cr */
	}
}
/* SpurMemoryManager>>#printFreeList: */
sqInt
printFreeList(sqInt _chunkOrIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _fieldIndex;
	sqInt _freeChunk;

	if ((_chunkOrIndex >= 0) && (_chunkOrIndex < 64)) {
		return printFreeList(GIV(freeLists)[_chunkOrIndex]);
	}
	_freeChunk = _chunkOrIndex;
	while (_freeChunk != 0) {
		/* begin printFreeChunk: */
		printFreeChunkprintAsTreeNode(_freeChunk, 1);
		/* end printFreeChunk: */
		/* begin fetchPointer:ofFreeChunk: */
		_fieldIndex = 0;
		_freeChunk = unsignedLongAt((_freeChunk + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofFreeChunk: */
	}
	return 0;
}
/* SpurMemoryManager>>#printFreeTree */
void
printFreeTree(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	printFreeTreeChunk(GIV(freeLists)[0]);
}
/*	Slang is blind-sided by the inlining of printFreeTreeChunk: into 
	printFreeTree.  */
/* SpurMemoryManager>>#printFreeTreeChunk: */
static void NoDbgRegParms
printFreeTreeChunk(sqInt _chunkOrZero)
{
	if (_chunkOrZero > 0) {
		printFreeTreeChunk(unsignedLongAt((_chunkOrZero + BaseHeaderSize) + (3U << (shiftForWord()))));
		/* begin printFreeChunk: */
		printFreeChunkprintAsTreeNode(_chunkOrZero, 1);
		/* end printFreeChunk: */
		printFreeTreeChunk(unsignedLongAt((_chunkOrZero + BaseHeaderSize) + (4U << (shiftForWord()))));
	}
}
/*	N.B. No safety bounds checks!! We need to look e.g. at corpses. */
/* SpurMemoryManager>>#printHeaderOf: */
void
printHeaderOf(sqInt _objOop)
{
	printHexnp(_objOop);
	if ((numSlotsOfAny(_objOop)) >= (numSlotsMask())) {
		{
			print(" hdr16 slotf ");
			printHexnp(numSlotsOfAny(_objOop - 8));
			print(" slotc ");
			printHexnp(((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8);
			/* begin space */
			printChar(' ');
			/* end space */
		}
	} else {
		{
			print(" hdr8 slots ");
			printHexnp(numSlotsOfAny(_objOop));
		}
	}
	{
		/* begin space */
		printChar(' ');
		/* end space */
		printChar(((((((usqInt) (longAt(_objOop)) ) >> (markedBitFullShift())) & 1) != 0)
			 ? 'M'
			 : 'm'));
		printChar(((((((usqInt) (longAt(_objOop)) ) >> (greyBitShift())) & 1) != 0)
			 ? 'G'
			 : 'g'));
		printChar(((((((usqInt) (longAt(_objOop)) ) >> (pinnedBitShift())) & 1) != 0)
			 ? 'P'
			 : 'p'));
		printChar(((((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0)
			 ? 'R'
			 : 'r'));
		printChar(((((((usqInt) (longAt(_objOop)) ) >> (immutableBitShift())) & 1) != 0)
			 ? 'I'
			 : 'i'));
		print(" hash ");
		printHexnp((uint32AtPointer(_objOop + 4)) & (identityHashHalfWordMask()));
		print(" fmt ");
		printHexnp((((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask()));
		print(" cidx ");
		printHexnp((longAt(_objOop)) & (classIndexMask()));
		/* begin cr */
		print("\n");
		/* end cr */
	}
}
/* SpurMemoryManager>>#printHeaderTypeOf: */
static void NoDbgRegParms
printHeaderTypeOf(sqInt _objOop)
{
	{
		print((((numSlotsOfAny(_objOop)) >= (numSlotsMask()))
			 ? " hdr16 "
			 : " hdr8 "));
		printChar(((((((usqInt) (longAt(_objOop)) ) >> (immutableBitShift())) & 1) != 0)
			 ? 'i'
			 : '.'));
		printChar(((((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0)
			 ? 'r'
			 : '.'));
		printChar(((((((usqInt) (longAt(_objOop)) ) >> (pinnedBitShift())) & 1) != 0)
			 ? 'p'
			 : '.'));
		printChar(((((((usqInt) (longAt(_objOop)) ) >> (markedBitFullShift())) & 1) != 0)
			 ? 'm'
			 : '.'));
		printChar(((((((usqInt) (longAt(_objOop)) ) >> (greyBitShift())) & 1) != 0)
			 ? 'g'
			 : '.'));
	}
}
/*	Scan the heap printing the oops of any and all objects that are instances 
	of aClassOop */
/* SpurMemoryManager>>#printInstancesOf: */
void
printInstancesOf(sqInt _aClassOop)
{
	sqInt _classIndex;

	_classIndex = (uint32AtPointer(_aClassOop + 4)) & (identityHashHalfWordMask());
	if (_classIndex != (isFreeObjectClassIndexPun())) {
		printInstancesWithClassIndex(_classIndex);
	}
}
/*	Scan the heap printing the oops of any and all objects whose classIndex 
	equals the argument. */
/* SpurMemoryManager>>#printInstancesWithClassIndex: */
void
printInstancesWithClassIndex(sqInt _classIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	/* begin allHeapEntitiesDo: */
	/* begin allOldSpaceEntitiesDo: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop2 = GIV(nilObj);
	while (1) {
		assert((_objOop2 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop2, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop2)) != 0);
		{
			if (((longAt(_objOop2)) & (classIndexMask())) == _classIndex) {
				{
					printHex(_objOop2);
					/* begin cr */
					print("\n");
					/* end cr */
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop2;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop2 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop2 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceEntitiesDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop, _limit)) {
		{
			if (((longAt(_objOop)) & (classIndexMask())) == _classIndex) {
				{
					printHex(_objOop);
					/* begin cr */
					print("\n");
					/* end cr */
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop = _limit;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop, GIV(freeStart))) {
		{
			if (((longAt(_objOop)) & (classIndexMask())) == _classIndex) {
				{
					printHex(_objOop);
					/* begin cr */
					print("\n");
					/* end cr */
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (((longAt(_currentObject)) & (classIndexMask())) == _classIndex) {
					{
						printHex(_currentObject);
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allHeapEntitiesDo: */
}
/*	Print the objects in the classTable that have bad hashes. */
/* SpurMemoryManager>>#printInvalidClassTableEntries */
void
printInvalidClassTableEntries(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classOrNil2;
	sqInt _hash;
	sqInt _i;
	sqInt _iLimit;
	sqInt _index;
	sqInt _j;
	sqInt _page;

	if (!(validClassTableRootPages())) {
		{
			print("class table invalid; cannot print");
			/* begin cr */
			print("\n");
			/* end cr */
		}
		return;
	}
	/* begin classTableEntriesDo: */
	for (_i = 0; _i < GIV(numClassTablePages); _i += 1) {
		_page = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		for (_j = 0, _iLimit = (1U << (classTableMajorIndexShift())) - 1; _j <= _iLimit; _j += 1) {
			_classOrNil2 = unsignedLongAt((_page + BaseHeaderSize) + ((sqInt) (((usqInt) _j ) << (shiftForWord())) ));
			if (_classOrNil2 != GIV(nilObj)) {
				{
					_index = ((sqInt) (((usqInt) _i ) << (classTableMajorIndexShift())) ) + _j;
					if ((((long64At(_classOrNil2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) || ((((_hash = (uint32AtPointer(_classOrNil2 + 4)) & (identityHashHalfWordMask()))) == 0) || ((noCheckClassAtIndex(_hash)) != _classOrNil2))) {
						{
							print("entry ");
							printHex(_index);
							print(" oop ");
							printHex(_classOrNil2);
							print(" hash ");
							printHex(_hash);
							print(" => ");
							printHex(classAtIndex(_hash));
							/* begin cr */
							print("\n");
							/* end cr */
						}
					}
				}
			}
		}
	}
	/* end classTableEntriesDo: */
}
/* SpurMemoryManager>>#printMarkedOops */

#if LLDB
void
printMarkedOops(void)
{
	printOopsSuchThat(isMarked);
}
#endif /* LLDB */
/*	Scan the heap printing the oops of any and all methods that implement 
	anOop  */
/* SpurMemoryManager>>#printMethodImplementorsOf: */
void
printMethodImplementorsOf(sqInt _anOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	/* begin allObjectsDo: */
	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop2 = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop2, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if ((((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && ((maybeSelectorOfMethod(_objOop2)) == _anOop)) {
					{
						printHex(_objOop2);
						/* begin space */
						printChar(' ');
						/* end space */
						printOopShort(_objOop2);
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop2 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if ((((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && ((maybeSelectorOfMethod(_objOop2)) == _anOop)) {
					{
						printHex(_objOop2);
						/* begin space */
						printChar(' ');
						/* end space */
						printOopShort(_objOop2);
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop2 = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	/* begin allOldSpaceObjectsDo: */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop22 = GIV(nilObj);
	while (1) {
		assert((_objOop22 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop22)) != 0);
		{
			if (isEnumerableObject(_objOop22)) {
				{
					if ((((((usqInt) (longAt(_objOop22)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && ((maybeSelectorOfMethod(_objOop22)) == _anOop)) {
						{
							printHex(_objOop22);
							/* begin space */
							printChar(' ');
							/* end space */
							printOopShort(_objOop22);
							/* begin cr */
							print("\n");
							/* end cr */
						}
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop22 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	/* end allOldSpaceObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if ((((((usqInt) (longAt(_currentObject)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && ((maybeSelectorOfMethod(_currentObject)) == _anOop)) {
					{
						printHex(_currentObject);
						/* begin space */
						printChar(' ');
						/* end space */
						printOopShort(_currentObject);
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
}
/*	Scan the heap printing the oops of any and all methods that refer to anOop */
/* SpurMemoryManager>>#printMethodReferencesTo: */
void
printMethodReferencesTo(sqInt _anOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	sqInt _i;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	/* begin allObjectsDo: */
	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop2 = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop2, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
					_i = ((literalCountOfMethodHeader(methodHeaderOf(_objOop2))) + LiteralStart) - 1;
					while (((_i -= 1)) >= 0) {
						if (_anOop == (unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
							{
								printHex(_objOop2);
								print(" @ ");
								printNum(_i);
								/* begin space */
								printChar(' ');
								/* end space */
								printOopShort(_objOop2);
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_i = 0;
						}
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop2 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
					_i = ((literalCountOfMethodHeader(methodHeaderOf(_objOop2))) + LiteralStart) - 1;
					while (((_i -= 1)) >= 0) {
						if (_anOop == (unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
							{
								printHex(_objOop2);
								print(" @ ");
								printNum(_i);
								/* begin space */
								printChar(' ');
								/* end space */
								printOopShort(_objOop2);
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_i = 0;
						}
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop2 = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	/* begin allOldSpaceObjectsDo: */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop22 = GIV(nilObj);
	while (1) {
		assert((_objOop22 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop22)) != 0);
		{
			if (isEnumerableObject(_objOop22)) {
				{
					if (((((usqInt) (longAt(_objOop22)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
						_i = ((literalCountOfMethodHeader(methodHeaderOf(_objOop22))) + LiteralStart) - 1;
						while (((_i -= 1)) >= 0) {
							if (_anOop == (unsignedLongAt((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
								{
									printHex(_objOop22);
									print(" @ ");
									printNum(_i);
									/* begin space */
									printChar(' ');
									/* end space */
									printOopShort(_objOop22);
									/* begin cr */
									print("\n");
									/* end cr */
								}
								_i = 0;
							}
						}
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop22 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	/* end allOldSpaceObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (((((usqInt) (longAt(_currentObject)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
					_i = ((literalCountOfMethodHeader(methodHeaderOf(_currentObject))) + LiteralStart) - 1;
					while (((_i -= 1)) >= 0) {
						if (_anOop == (unsignedLongAt((_currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
							{
								printHex(_currentObject);
								print(" @ ");
								printNum(_i);
								/* begin space */
								printChar(' ');
								/* end space */
								printOopShort(_currentObject);
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_i = 0;
						}
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
}
/* SpurMemoryManager>>#printObjectsFrom:to: */
void
printObjectsFromto(sqInt _startAddress, sqInt _endAddress)
{
	sqInt _oop;

	_oop = objectBefore(_startAddress);
	if (_oop == null) {
		_oop = _startAddress;
	} else {
		_oop = (((objectAfter(_oop)) == _startAddress)
			 ? _startAddress
			 : _oop);
	}
	while (oopisLessThan(_oop, _endAddress)) {
		if (!((((longAt(_oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) || (((longAt(_oop)) & (classIndexMask())) == (segmentBridgePun())))) {
			printOop(_oop);
		}
		_oop = objectAfter(_oop);
	}
}
/*	Scan the heap printing the oops of any and all objects whose hash equals 
	the argument. */
/* SpurMemoryManager>>#printObjectsWithHash: */
void
printObjectsWithHash(sqInt _hash)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	/* begin allHeapEntitiesDo: */
	/* begin allOldSpaceEntitiesDo: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop2 = GIV(nilObj);
	while (1) {
		assert((_objOop2 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop2, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop2)) != 0);
		{
			if (((uint32AtPointer(_objOop2 + 4)) & (identityHashHalfWordMask())) == _hash) {
				{
					shortPrintOop(_objOop2);
					/* begin cr */
					print("\n");
					/* end cr */
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop2;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop2 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop2 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceEntitiesDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop, _limit)) {
		{
			if (((uint32AtPointer(_objOop + 4)) & (identityHashHalfWordMask())) == _hash) {
				{
					shortPrintOop(_objOop);
					/* begin cr */
					print("\n");
					/* end cr */
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop = _limit;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop, GIV(freeStart))) {
		{
			if (((uint32AtPointer(_objOop + 4)) & (identityHashHalfWordMask())) == _hash) {
				{
					shortPrintOop(_objOop);
					/* begin cr */
					print("\n");
					/* end cr */
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (((uint32AtPointer(_currentObject + 4)) & (identityHashHalfWordMask())) == _hash) {
					{
						shortPrintOop(_currentObject);
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allHeapEntitiesDo: */
}
/* SpurMemoryManager>>#printObjStackPage:myIndex:pageType: */
static void NoDbgRegParms
printObjStackPagemyIndexpageType(sqInt _objStackPage, sqInt _myx, sqInt _pageType)
{
	sqInt _freeOrNextPage;
	int _isFirstPage;
	int _isFreePage;
	int _isNextPage;
	sqInt _page;

	_isFirstPage = _pageType == ObjStackMyx;
	_isNextPage = _pageType == ObjStackNextx;
	_isFreePage = _pageType == ObjStackFreex;
	printObjStackPagemyIndextag(_objStackPage, _myx, ((_isFirstPage)
		 ? "head"
		 : ((_isFreePage)
			 ? "free"
			 : "next")));
	if (_isFirstPage || _isNextPage) {
		{
			/* begin tab */
			printChar('	');
			/* end tab */
			print("topx: ");
			printNum(unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) )));
			print(" next: ");
			printHex(unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) )));
		}
		if (_isFirstPage) {
			{
				print(" free: ");
				printHex(unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) )));
			}
		}
		/* begin cr */
		print("\n");
		/* end cr */
	}
	if (_isFirstPage) {
		/* begin fetchPointer:ofObject: */
		_freeOrNextPage = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		while (_freeOrNextPage != 0) {
			printObjStackPagemyIndexpageType(_freeOrNextPage, _myx, ObjStackFreex);
			/* begin fetchPointer:ofObject: */
			_page = unsignedLongAt((_freeOrNextPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if ((_page == _freeOrNextPage) || (_page == _objStackPage)) {
				{
					print("circularity in free page list!!");
					/* begin cr */
					print("\n");
					/* end cr */
				}
				_page = 0;
			}
			_freeOrNextPage = _page;
		}
	}
	/* begin fetchPointer:ofObject: */
	_freeOrNextPage = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_freeOrNextPage != 0) {
		printObjStackPagemyIndexpageType(_freeOrNextPage, _myx, ObjStackNextx);
	}
}
/* SpurMemoryManager>>#printObjStackPage:myIndex:tag: */
static void NoDbgRegParms
printObjStackPagemyIndextag(sqInt _objStackPage, sqInt _myx, char *_pageType)
{
	{
		print(_pageType);
		/* begin space */
		printChar(' ');
		/* end space */
		printHex(_objStackPage);
		/* begin space */
		printChar(' ');
		/* end space */
		print("cx ");
		printNum((longAt(_objStackPage)) & (classIndexMask()));
		print(" (");
		printNum(sixtyFourBitLongsClassIndexPun());
		print(") fmt ");
		printNum((((usqInt) (longAt(_objStackPage)) ) >> (formatShift())) & (formatMask()));
		print(" (");
		printNum(sixtyFourBitIndexableFormat());
		print(") sz ");
		printNum(numSlotsOfAny(_objStackPage));
		print(" (");
		printNum(ObjStackPageSlots);
		print(") myx: ");
		printNum(unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackMyx ) << (shiftForWord())) )));
		print(" (");
		printNum(_myx);
		print(((((((usqInt) (longAt(_objStackPage)) ) >> (markedBitFullShift())) & 1) != 0)
			 ? ") mkd"
			 : ") unmkd"));
		/* begin cr */
		print("\n");
		/* end cr */
	}
}
/* SpurMemoryManager>>#printObjStack: */
void
printObjStack(sqInt _objStack)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (_objStack == GIV(nilObj)) {
		{
			print("nil");
			/* begin cr */
			print("\n");
			/* end cr */
		}
	} else {
		printObjStackPagemyIndexpageType(_objStack, unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackMyx ) << (shiftForWord())) )), ObjStackMyx);
	}
}
/* SpurMemoryManager>>#printOopsExcept: */
void NeverInline
printOopsExcept(sqInt (*_function)(sqInt))
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	usqInt _limit;
	sqInt _limit2;
	int _n;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	_n = 0;
	/* begin allHeapEntitiesDo: */
	/* begin allOldSpaceEntitiesDo: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop2 = GIV(nilObj);
	while (1) {
		assert((_objOop2 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop2, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop2)) != 0);
		{
			if (!(_function(_objOop2))) {
				_n += 1;
				printEntity(_objOop2);
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop2;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop2 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop2 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceEntitiesDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop, _limit)) {
		{
			if (!(_function(_objOop))) {
				_n += 1;
				printEntity(_objOop);
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop = _limit;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop, GIV(freeStart))) {
		{
			if (!(_function(_objOop))) {
				_n += 1;
				printEntity(_objOop);
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (!(_function(_currentObject))) {
					_n += 1;
					printEntity(_currentObject);
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allHeapEntitiesDo: */
	if (_n > 4) {
		{
			printNum(_n);
			print(" objects");
			/* begin cr */
			print("\n");
			/* end cr */
		}
	}
}
/* SpurMemoryManager>>#printOopsFrom:to: */
void
printOopsFromto(sqInt _startAddress, sqInt _endAddress)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _firstNonEntity;
	int _inEmptySpace;
	sqInt _lastNonEntity;
	sqInt _limit;
	usqInt _numSlots;
	sqInt _oop;

	_firstNonEntity = 0;
	_oop = objectBefore(_startAddress);
	_limit = ((((usqIntptr_t) _endAddress ) < ((GIV(memoryMap)->oldSpaceEnd))) ? ((usqIntptr_t) _endAddress ) : (GIV(memoryMap)->oldSpaceEnd));
	if (_oop == null) {
		_oop = _startAddress;
	} else {
		_oop = (((objectAfter(_oop)) == _startAddress)
			 ? _startAddress
			 : _oop);
	}
	_inEmptySpace = 0;
	while (oopisLessThan(_oop, _limit)) {
		printEntity(_oop);
		while (1) {
			_oop = objectAfter(_oop);
			if (!((long64At(_oop)) == 0)) 
				break;
			if (!_inEmptySpace) {
				_inEmptySpace = 1;
				_firstNonEntity = _oop;
			}
			_lastNonEntity = _oop;
		}
		if (_inEmptySpace) {
			_inEmptySpace = 0;
			{
				print("skipped empty space from ");
				/* begin printHexPtrnp: */
				printHexnp(oopForPointer(((void *) _firstNonEntity )));
				/* end printHexPtrnp: */
				print(" to ");
				/* begin printHexPtrnp: */
				printHexnp(oopForPointer(((void *) _lastNonEntity )));
				/* end printHexPtrnp: */
				/* begin cr */
				print("\n");
				/* end cr */
			}
			/* begin objectStartingAt: */
			_numSlots = byteAt(_oop + 7);
			_oop = ((_numSlots == (numSlotsMask()))
				 ? _oop + BaseHeaderSize
				 : _oop);
			/* end objectStartingAt: */
		}
	}
}
/* SpurMemoryManager>>#printOopsSuchThat: */
void NeverInline
printOopsSuchThat(sqInt (*_function)(sqInt))
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	usqInt _limit;
	sqInt _limit2;
	int _n;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;

	_n = 0;
	/* begin allHeapEntitiesDo: */
	/* begin allOldSpaceEntitiesDo: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop2 = GIV(nilObj);
	while (1) {
		assert((_objOop2 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop2, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop2)) != 0);
		{
			if (_function(_objOop2)) {
				_n += 1;
				printEntity(_objOop2);
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop2;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop2 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop2 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceEntitiesDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop, _limit)) {
		{
			if (_function(_objOop)) {
				_n += 1;
				printEntity(_objOop);
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop = _limit;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop, GIV(freeStart))) {
		{
			if (_function(_objOop)) {
				_n += 1;
				printEntity(_objOop);
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop = GIV(freeStart);
			goto l3;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (_function(_currentObject)) {
					_n += 1;
					printEntity(_currentObject);
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allHeapEntitiesDo: */
	if (_n > 4) {
		{
			printNum(_n);
			print(" objects");
			/* begin cr */
			print("\n");
			/* end cr */
		}
	}
}
/*	Scan the heap printing the oops of any and all objects that refer to anOop */
/* SpurMemoryManager>>#printReferencesTo: */
void
printReferencesTo(sqInt _anOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _contextSize;
	sqInt _currentObject;
	sqInt _fmt;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	sqInt _header;
	sqInt _header2;
	sqInt _i;
	usqInt _limit;
	sqInt _limit2;
	sqInt _numLiterals;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots3;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;
	sqInt _sp;

	/* begin allObjectsDo: */
	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots3 = byteAt(_address + 7);
	_objOop2 = ((_numSlots3 == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop2, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				/* begin numPointerSlotsOf: */
				_fmt = (((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask());
				if (_fmt <= 5) {
					if ((_fmt == (indexablePointersFormat())) && (((longAt(_objOop2)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
						/* begin fetchStackPointerOf: */
						/* begin fetchPointer:ofObject: */
						_sp = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						if (!(((_sp & 7) == 1))) {
							_contextSize = 0;
							goto l17;
						}
						assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_objOop2)));
						_contextSize = _sp >> 3;
						l17:
						;
						/* end fetchStackPointerOf: */
						_i = ((usqInt) (CtxtTempFrameStart + _contextSize) );
						goto l16;
					}
					/* begin numSlotsOf: */
					assert((classIndexOf(_objOop2)) > (isForwardedObjectClassIndexPun()));
					_numSlots = byteAt(_objOop2 + 7);
					_i = ((_numSlots == (numSlotsMask()))
						 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop2 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
						 : _numSlots);
					goto l16;
					/* end numSlotsOf: */
				}
				if (_fmt == 7) {
					_i = 1;
					goto l16;
				}
				if (_fmt < (firstCompiledMethodFormat())) {
					_i = 0;
					goto l16;
				}
				/* begin methodHeaderOf: */
				assert(isCompiledMethod(_objOop2));
				/* begin fetchPointer:ofObject: */
				_header2 = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_header2 & 7) == 1)) {
					_header = _header2;
				} else {
					assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
					assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
					_header = ((((CogMethod *) _header2 ))->methodHeader);
				}
				/* end methodHeaderOf: */
				{
					assert(((_header & 7) == 1));
					_numLiterals = (_header >> 3) & AlternateHeaderNumLiteralsMask;
				}
				_i = ((usqInt) (_numLiterals + LiteralStart) );
				l16:
				;
				/* end numPointerSlotsOf: */
				while (((_i -= 1)) >= 0) {
					if (_anOop == (unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
						{
							printHex(_objOop2);
							print(" @ ");
							printNum(_i);
							/* begin space */
							printChar(' ');
							/* end space */
							printOopShort(_objOop2);
							/* begin cr */
							print("\n");
							/* end cr */
						}
						_i = 0;
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l9;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l9:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop2 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				/* begin numPointerSlotsOf: */
				_fmt = (((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask());
				if (_fmt <= 5) {
					if ((_fmt == (indexablePointersFormat())) && (((longAt(_objOop2)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
						/* begin fetchStackPointerOf: */
						/* begin fetchPointer:ofObject: */
						_sp = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						if (!(((_sp & 7) == 1))) {
							_contextSize = 0;
							goto l21;
						}
						assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_objOop2)));
						_contextSize = _sp >> 3;
						l21:
						;
						/* end fetchStackPointerOf: */
						_i = ((usqInt) (CtxtTempFrameStart + _contextSize) );
						goto l20;
					}
					/* begin numSlotsOf: */
					assert((classIndexOf(_objOop2)) > (isForwardedObjectClassIndexPun()));
					_numSlots = byteAt(_objOop2 + 7);
					_i = ((_numSlots == (numSlotsMask()))
						 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop2 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
						 : _numSlots);
					goto l20;
					/* end numSlotsOf: */
				}
				if (_fmt == 7) {
					_i = 1;
					goto l20;
				}
				if (_fmt < (firstCompiledMethodFormat())) {
					_i = 0;
					goto l20;
				}
				/* begin methodHeaderOf: */
				assert(isCompiledMethod(_objOop2));
				/* begin fetchPointer:ofObject: */
				_header2 = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_header2 & 7) == 1)) {
					_header = _header2;
				} else {
					assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
					assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
					_header = ((((CogMethod *) _header2 ))->methodHeader);
				}
				/* end methodHeaderOf: */
				{
					assert(((_header & 7) == 1));
					_numLiterals = (_header >> 3) & AlternateHeaderNumLiteralsMask;
				}
				_i = ((usqInt) (_numLiterals + LiteralStart) );
				l20:
				;
				/* end numPointerSlotsOf: */
				while (((_i -= 1)) >= 0) {
					if (_anOop == (unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
						{
							printHex(_objOop2);
							print(" @ ");
							printNum(_i);
							/* begin space */
							printChar(' ');
							/* end space */
							printOopShort(_objOop2);
							/* begin cr */
							print("\n");
							/* end cr */
						}
						_i = 0;
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop2 = GIV(freeStart);
			goto l12;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l12:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	/* begin allOldSpaceObjectsDo: */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop22 = GIV(nilObj);
	while (1) {
		assert((_objOop22 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop22)) != 0);
		{
			if (isEnumerableObject(_objOop22)) {
				{
					/* begin numPointerSlotsOf: */
					_fmt = (((usqInt) (longAt(_objOop22)) ) >> (formatShift())) & (formatMask());
					if (_fmt <= 5) {
						if ((_fmt == (indexablePointersFormat())) && (((longAt(_objOop22)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
							/* begin fetchStackPointerOf: */
							/* begin fetchPointer:ofObject: */
							_sp = unsignedLongAt((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							if (!(((_sp & 7) == 1))) {
								_contextSize = 0;
								goto l24;
							}
							assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_objOop22)));
							_contextSize = _sp >> 3;
							l24:
							;
							/* end fetchStackPointerOf: */
							_i = ((usqInt) (CtxtTempFrameStart + _contextSize) );
							goto l25;
						}
						/* begin numSlotsOf: */
						assert((classIndexOf(_objOop22)) > (isForwardedObjectClassIndexPun()));
						_numSlots = byteAt(_objOop22 + 7);
						_i = ((_numSlots == (numSlotsMask()))
							 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop22 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
							 : _numSlots);
						goto l25;
						/* end numSlotsOf: */
					}
					if (_fmt == 7) {
						_i = 1;
						goto l25;
					}
					if (_fmt < (firstCompiledMethodFormat())) {
						_i = 0;
						goto l25;
					}
					/* begin methodHeaderOf: */
					assert(isCompiledMethod(_objOop22));
					/* begin fetchPointer:ofObject: */
					_header2 = unsignedLongAt((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (((_header2 & 7) == 1)) {
						_header = _header2;
					} else {
						assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
						assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
						_header = ((((CogMethod *) _header2 ))->methodHeader);
					}
					/* end methodHeaderOf: */
					{
						assert(((_header & 7) == 1));
						_numLiterals = (_header >> 3) & AlternateHeaderNumLiteralsMask;
					}
					_i = ((usqInt) (_numLiterals + LiteralStart) );
					l25:
					;
					/* end numPointerSlotsOf: */
					while (((_i -= 1)) >= 0) {
						if (_anOop == (unsignedLongAt((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
							{
								printHex(_objOop22);
								print(" @ ");
								printNum(_i);
								/* begin space */
								printChar(' ');
								/* end space */
								printOopShort(_objOop22);
								/* begin cr */
								print("\n");
								/* end cr */
							}
							_i = 0;
						}
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop22 = _limit2;
			goto l10;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l10:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	/* end allOldSpaceObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				/* begin numPointerSlotsOf: */
				_fmt = (((usqInt) (longAt(_currentObject)) ) >> (formatShift())) & (formatMask());
				if (_fmt <= 5) {
					if ((_fmt == (indexablePointersFormat())) && (((longAt(_currentObject)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
						/* begin fetchStackPointerOf: */
						/* begin fetchPointer:ofObject: */
						_sp = unsignedLongAt((_currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						if (!(((_sp & 7) == 1))) {
							_contextSize = 0;
							goto l26;
						}
						assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_currentObject)));
						_contextSize = _sp >> 3;
						l26:
						;
						/* end fetchStackPointerOf: */
						_i = ((usqInt) (CtxtTempFrameStart + _contextSize) );
						goto l27;
					}
					/* begin numSlotsOf: */
					assert((classIndexOf(_currentObject)) > (isForwardedObjectClassIndexPun()));
					_numSlots = byteAt(_currentObject + 7);
					_i = ((_numSlots == (numSlotsMask()))
						 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_currentObject - BaseHeaderSize)) ) << 8) ) ) ) >> 8
						 : _numSlots);
					goto l27;
					/* end numSlotsOf: */
				}
				if (_fmt == 7) {
					_i = 1;
					goto l27;
				}
				if (_fmt < (firstCompiledMethodFormat())) {
					_i = 0;
					goto l27;
				}
				/* begin methodHeaderOf: */
				assert(isCompiledMethod(_currentObject));
				/* begin fetchPointer:ofObject: */
				_header2 = unsignedLongAt((_currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_header2 & 7) == 1)) {
					_header = _header2;
				} else {
					assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
					assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
					_header = ((((CogMethod *) _header2 ))->methodHeader);
				}
				/* end methodHeaderOf: */
				{
					assert(((_header & 7) == 1));
					_numLiterals = (_header >> 3) & AlternateHeaderNumLiteralsMask;
				}
				_i = ((usqInt) (_numLiterals + LiteralStart) );
				l27:
				;
				/* end numPointerSlotsOf: */
				while (((_i -= 1)) >= 0) {
					if (_anOop == (unsignedLongAt((_currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
						{
							printHex(_currentObject);
							print(" @ ");
							printNum(_i);
							/* begin space */
							printChar(' ');
							/* end space */
							printOopShort(_currentObject);
							/* begin cr */
							print("\n");
							/* end cr */
						}
						_i = 0;
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l13;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l13:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
}
/* SpurMemoryManager>>#printUnmarkedOops */

#if LLDB
void
printUnmarkedOops(void)
{
	printOopsExcept(isMarked);
}
#endif /* LLDB */
/*	Attempt to push anEphemeron on the unscanned ephemerons stack 
	and answer if the attempt succeeded. Note that the ephemeron 
	stack overflowing isn't a disaster; it simply means treating the 
	ephemeron as strong in this GC cycle. */
/* SpurMemoryManager>>#pushOnUnscannedEphemeronsStack: */
static sqInt NoDbgRegParms
pushOnUnscannedEphemeronsStack(sqInt _anEphemeron)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _desiredSize;
	sqInt _reallocated;

	assert(isEphemeron(_anEphemeron));
	if (((GIV(unscannedEphemerons)->top)) >= ((GIV(unscannedEphemerons)->limit))) {
		_desiredSize = (((GIV(unscannedEphemerons)->limit)) - ((GIV(unscannedEphemerons)->start))) * 2;
		_reallocated = realloc((GIV(unscannedEphemerons)->start), _desiredSize);
		if (!_reallocated) {
			error("Not enough room to grow unscannedEphemerons queue");
		}
		(GIV(unscannedEphemerons)->limit = _reallocated + _desiredSize);
		(GIV(unscannedEphemerons)->top = _reallocated + (((GIV(unscannedEphemerons)->top)) - ((GIV(unscannedEphemerons)->start))));
		(GIV(unscannedEphemerons)->start = _reallocated);
	}
	longAtput((GIV(unscannedEphemerons)->top), _anEphemeron);
	(GIV(unscannedEphemerons)->top = ((GIV(unscannedEphemerons)->top)) + BytesPerOop);
	return 1;
}
/*	Record the given object in a the remap buffer. Objects in this buffer are 
	remapped when a compaction occurs. This facility is used by the 
	interpreter to ensure that 
	objects in temporary variables are properly remapped. 
	We support this excessence for compatibility with ObjectMemory. 
	Spur doesn't GC during allocation. */
/* SpurMemoryManager>>#pushRemappableOop: */
void
pushRemappableOop(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	assert(addressCouldBeOop(_oop));
	GIV(remapBuffer)[(GIV(remapBufferCount) += 1)] = _oop;
	if (!(GIV(remapBufferCount) <= RemapBufferSize)) {
		error("remapBuffer overflow");
	}
}
/* SpurMemoryManager>>#rawHashBitsOf: */
sqInt
rawHashBitsOf(sqInt _objOop)
{
	flag("endianness");
	return (uint32AtPointer(_objOop + 4)) & (identityHashHalfWordMask());
}
/* SpurMemoryManager>>#rawHeaderOf: */
sqInt
rawHeaderOf(sqInt _methodPointer)
{
	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((_methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/* SpurMemoryManager>>#readPointerAtPointer: */
static void * NoDbgRegParms
readPointerAtPointer(sqInt _aCArrayAccessor)
{
	void ** _ptrPtr;

	_ptrPtr = ((void **) _aCArrayAccessor );
	return _ptrPtr[0];
}
/* SpurMemoryManager>>#readSINT16AtPointer: */
static int16_t NoDbgRegParms
readSINT16AtPointer(sqInt _aCArrayAccessor)
{
	int16_t * _intPtr;

	_intPtr = ((int16_t *) _aCArrayAccessor );
	return _intPtr[0];
}
/* SpurMemoryManager>>#readSINT32AtPointer: */
static int32_t NoDbgRegParms
readSINT32AtPointer(sqInt _aCArrayAccessor)
{
	int32_t * _intPtr;

	_intPtr = ((int32_t *) _aCArrayAccessor );
	return _intPtr[0];
}
/* SpurMemoryManager>>#readSINT64AtPointer: */
static int64_t NoDbgRegParms
readSINT64AtPointer(sqInt _aCArrayAccessor)
{
	int64_t * _intPtr;

	_intPtr = ((int64_t *) _aCArrayAccessor );
	return _intPtr[0];
}
/* SpurMemoryManager>>#readSINT8AtPointer: */
static int8_t NoDbgRegParms
readSINT8AtPointer(sqInt _aCArrayAccessor)
{
	int8_t * _intPtr;

	_intPtr = ((int8_t *) _aCArrayAccessor );
	return _intPtr[0];
}
/* SpurMemoryManager>>#readUINT16AtPointer: */
static uint16_t NoDbgRegParms
readUINT16AtPointer(sqInt _aCArrayAccessor)
{
	uint16_t * _intPtr;

	_intPtr = ((uint16_t *) _aCArrayAccessor );
	return _intPtr[0];
}
/* SpurMemoryManager>>#readUINT32AtPointer: */
static uint32_t NoDbgRegParms
readUINT32AtPointer(sqInt _aCArrayAccessor)
{
	uint32_t * _intPtr;

	_intPtr = ((uint32_t *) _aCArrayAccessor );
	return _intPtr[0];
}
/* SpurMemoryManager>>#readUINT64AtPointer: */
static uint64_t NoDbgRegParms
readUINT64AtPointer(sqInt _aCArrayAccessor)
{
	uint64_t * _intPtr;

	_intPtr = ((uint64_t *) _aCArrayAccessor );
	return _intPtr[0];
}
/* SpurMemoryManager>>#readUINT8AtPointer: */
static uint8_t NoDbgRegParms
readUINT8AtPointer(sqInt _aCArrayAccessor)
{
	uint8_t * _intPtr;

	_intPtr = ((uint8_t *) _aCArrayAccessor );
	return _intPtr[0];
}
/* SpurMemoryManager>>#recreateFromPermSpaceRememberedSet */
static void
recreateFromPermSpaceRememberedSet(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMRememberedSet * self_in_emptyRememberedSet;
	VMRememberedSet * self_in_emptyRememberedSet2;
	sqInt _anOop;
	sqInt _anOop2;
	sqInt _aValue;
	sqInt _contextSize;
	sqInt _currentObject;
	sqInt _fmt;
	sqInt _followingWord;
	usqInt _followingWordAddress;
	sqInt _header;
	sqInt _header2;
	sqInt _numLiterals;
	usqInt _numPointerSlots;
	usqInt _numSlots;
	sqInt _objStackRootIndex;
	sqInt _objStackRootIndex2;
	sqInt _oldObj;
	sqInt _oldObj2;
	sqInt _referenced;
	sqInt _referent;
	sqInt _referent2;
	int _refersNewSpace;
	int _refersOldSpace;
	sqInt _rootIndex;
	sqInt _rootIndex2;
	int _slotIndex;
	sqInt _sp;

	/* begin emptyRememberedSet */
	/* begin getFromPermToOldSpaceRememberedSet */
	self_in_emptyRememberedSet = GIV(fromPermToOldSpaceRememberedSet);
	/* end getFromPermToOldSpaceRememberedSet */
	/* begin objStackAt: */
	_objStackRootIndex = (self_in_emptyRememberedSet->rootIndex);
	/* begin fetchPointer:ofObject: */
	_oldObj = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _objStackRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end objStackAt: */
	if (!(_oldObj == GIV(nilObj))) {
		/* begin rememberedSet:oop: */
		_rootIndex = (self_in_emptyRememberedSet->rootIndex);
		_anOop = GIV(nilObj);
		assert(isOldObject(GIV(memoryMap), _anOop));
		{
			assert(!(isOopForwarded(GIV(hiddenRootsObj))));
			longAtput((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _rootIndex ) << (shiftForWord())) ), _anOop);
		}
		/* end rememberedSet:oop: */
		freeObject(_oldObj);
	}
	initializeRememberedSetShouldStartEmpty(self_in_emptyRememberedSet, 1);
	/* end emptyRememberedSet */
	/* begin emptyRememberedSet */
	/* begin getFromPermToNewSpaceRememberedSet */
	self_in_emptyRememberedSet2 = GIV(fromPermToNewSpaceRememberedSet);
	/* end getFromPermToNewSpaceRememberedSet */
	/* begin objStackAt: */
	_objStackRootIndex2 = (self_in_emptyRememberedSet2->rootIndex);
	/* begin fetchPointer:ofObject: */
	_oldObj2 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _objStackRootIndex2 ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end objStackAt: */
	if (!(_oldObj2 == GIV(nilObj))) {
		/* begin rememberedSet:oop: */
		_rootIndex2 = (self_in_emptyRememberedSet2->rootIndex);
		_anOop2 = GIV(nilObj);
		assert(isOldObject(GIV(memoryMap), _anOop2));
		{
			assert(!(isOopForwarded(GIV(hiddenRootsObj))));
			longAtput((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _rootIndex2 ) << (shiftForWord())) ), _anOop2);
		}
		/* end rememberedSet:oop: */
		freeObject(_oldObj2);
	}
	initializeRememberedSetShouldStartEmpty(self_in_emptyRememberedSet2, 1);
	/* end emptyRememberedSet */
	/* begin allPermSpaceForwarded:ObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (((long64At(_currentObject)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					{
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referenced = unsignedLongAt((_currentObject + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
						if (((long64At(_referenced)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
							/* begin followForwarded: */
							assert(isUnambiguouslyForwarder(_referenced));
							/* begin fetchPointer:ofMaybeForwardedObject: */
							_referent = unsignedLongAt((_referenced + BaseHeaderSize) + (0U << (shiftForWord())));
							/* end fetchPointer:ofMaybeForwardedObject: */
							while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
								/* begin fetchPointer:ofMaybeForwardedObject: */
								_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
								/* end fetchPointer:ofMaybeForwardedObject: */
							}
							_referenced = _referent;
							/* end followForwarded: */
							unsignedLongAtput((_currentObject + BaseHeaderSize) + (0U << (shiftForWord())), _referenced);
						}
						if (((_referenced & (((getMemoryMap())->spaceMaskToUse))) == (((getMemoryMap())->newSpaceMask))) && (_referenced >= (((getMemoryMap())->newSpaceStart)))) {
							remember(getFromPermToNewSpaceRememberedSet(), _currentObject);
						} else {
							if ((_referenced & (((getMemoryMap())->spaceMaskToUse))) == (((getMemoryMap())->oldSpaceMask))) {
								rememberWithoutMarkingAsRemembered(getFromPermToOldSpaceRememberedSet(), _currentObject);
							}
						}
					}
				} else {
					{
						/* begin setIsRememberedOf:to: */
						/* begin unsignedLong64At:put: */
						_aValue = (uint64AtPointer(_currentObject)) & (~((usqIntptr_t) (1U << (rememberedBitShift())) ));
						uint64AtPointerput(_currentObject, _aValue);
						/* end unsignedLong64At:put: */
						/* end setIsRememberedOf:to: */
						/* begin numPointerSlotsOf: */
						_fmt = (((usqInt) (longAt(_currentObject)) ) >> (formatShift())) & (formatMask());
						if (_fmt <= 5) {
							if ((_fmt == (indexablePointersFormat())) && (((longAt(_currentObject)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
								/* begin fetchStackPointerOf: */
								/* begin fetchPointer:ofObject: */
								_sp = unsignedLongAt((_currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								if (!(((_sp & 7) == 1))) {
									_contextSize = 0;
									goto l26;
								}
								assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_currentObject)));
								_contextSize = _sp >> 3;
								l26:
								;
								/* end fetchStackPointerOf: */
								_numPointerSlots = CtxtTempFrameStart + _contextSize;
								goto l25;
							}
							/* begin numSlotsOf: */
							assert((classIndexOf(_currentObject)) > (isForwardedObjectClassIndexPun()));
							_numSlots = byteAt(_currentObject + 7);
							_numPointerSlots = ((_numSlots == (numSlotsMask()))
								 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_currentObject - BaseHeaderSize)) ) << 8) ) ) ) >> 8
								 : _numSlots);
							goto l25;
							/* end numSlotsOf: */
						}
						if (_fmt == 7) {
							_numPointerSlots = 1;
							goto l25;
						}
						if (_fmt < (firstCompiledMethodFormat())) {
							_numPointerSlots = 0;
							goto l25;
						}
						/* begin methodHeaderOf: */
						assert(isCompiledMethod(_currentObject));
						/* begin fetchPointer:ofObject: */
						_header2 = unsignedLongAt((_currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						if (((_header2 & 7) == 1)) {
							_header = _header2;
						} else {
							assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
							assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
							_header = ((((CogMethod *) _header2 ))->methodHeader);
						}
						/* end methodHeaderOf: */
						{
							assert(((_header & 7) == 1));
							_numLiterals = (_header >> 3) & AlternateHeaderNumLiteralsMask;
						}
						_numPointerSlots = _numLiterals + LiteralStart;
						l25:
						;
						/* end numPointerSlotsOf: */
						_refersNewSpace = 0;
						_refersOldSpace = 0;
						_slotIndex = 0;
						while (!_refersNewSpace && (_slotIndex < _numPointerSlots)) {
							/* begin fetchPointer:ofObject: */
							_referenced = unsignedLongAt((_currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) _slotIndex ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							if (((_referenced & (tagMask())) == 0) && (_referenced >= (startOfObjectMemory(GIV(memoryMap))))) {
								if (((long64At(_referenced)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
									/* begin followForwarded: */
									assert(isUnambiguouslyForwarder(_referenced));
									/* begin fetchPointer:ofMaybeForwardedObject: */
									_referent2 = unsignedLongAt((_referenced + BaseHeaderSize) + (0U << (shiftForWord())));
									/* end fetchPointer:ofMaybeForwardedObject: */
									while (((_referent2 & (tagMask())) == 0) && (((long64At(_referent2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
										/* begin fetchPointer:ofMaybeForwardedObject: */
										_referent2 = unsignedLongAt((_referent2 + BaseHeaderSize) + (0U << (shiftForWord())));
										/* end fetchPointer:ofMaybeForwardedObject: */
									}
									_referenced = _referent2;
									/* end followForwarded: */
								}
								if (!((_referenced >= GIV(nilObj)) && (_referenced <= GIV(trueObj)))) {
									if (((_referenced & (((getMemoryMap())->spaceMaskToUse))) == (((getMemoryMap())->newSpaceMask))) && (_referenced >= (((getMemoryMap())->newSpaceStart)))) {
										_refersNewSpace = 1;
									} else {
										if ((_referenced & (((getMemoryMap())->spaceMaskToUse))) == (((getMemoryMap())->oldSpaceMask))) {
											_refersOldSpace = 1;
										}
									}
								}
							}
							_slotIndex += 1;
						}
						if (_refersNewSpace) {
							remember(getFromPermToNewSpaceRememberedSet(), _currentObject);
						} else {
							if (_refersOldSpace) {
								rememberWithoutMarkingAsRemembered(getFromPermToOldSpaceRememberedSet(), _currentObject);
							}
						}
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l16;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_currentObject = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l16:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allPermSpaceForwarded:ObjectsDo: */
}
/*	Relocate all objStack pages that comprise objStack. */
/* SpurMemoryManager>>#relocateObjStackForPlanningCompactor: */
static sqInt NoDbgRegParms
relocateObjStackForPlanningCompactor(sqInt _objStack)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _finishIndex;
	sqInt _freeList;
	sqInt _fwd;
	sqInt _fwd2;
	sqInt _i;
	sqInt _i2;
	sqInt _next;
	sqInt _oop;
	sqInt _oop2;
	sqInt _relocated;
	sqInt _result;
	sqInt _stackOrNil;

	_result = 0;
	if (_objStack == GIV(nilObj)) {
		return _objStack;
	}
	_stackOrNil = _objStack;
	/* begin fetchPointer:ofObject: */
	_freeList = unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	while (1) {
		assert((numSlotsOfAny(_stackOrNil)) == ObjStackPageSlots);
		/* begin fetchPointer:ofObject: */
		_next = unsignedLongAt((_stackOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* begin relocateObjectsInHeapEntity:from:to: */
		_finishIndex = ObjStackNextx + ((uint32AtPointer(_stackOrNil + 4)) & (identityHashHalfWordMask()));
		for (_i = ObjStackFreex; _i <= _finishIndex; _i += 1) {
			/* begin fetchPointer:ofObject: */
			_oop = unsignedLongAt((_stackOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_oop & (tagMask())) == 0) && ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(_oop, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_oop)) ) >> (pinnedBitShift())) & 1) != 0)))) {
				assert(isMarked(_oop));
				/* begin fetchPointer:ofObject: */
				_fwd = unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofObject: */
				assert(isPostMobile(_fwd));
				/* begin storePointerUnchecked:ofObject:withValue: */
				assert(!(isOopForwarded(_stackOrNil)));
				longAtput((_stackOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _fwd);
				/* end storePointerUnchecked:ofObject:withValue: */
			}
		}
		if ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(_stackOrNil, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_stackOrNil)) ) >> (pinnedBitShift())) & 1) != 0))) {
			/* begin fetchPointer:ofObject: */
			_relocated = unsignedLongAt((_stackOrNil + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofObject: */
		} else {
			_relocated = _stackOrNil;
		}
		/* end relocateObjectsInHeapEntity:from:to: */
		if (_stackOrNil == _objStack) {
			_result = _relocated;
		}
		if (!(_next != 0)) 
			break;
		_stackOrNil = _next;
	}
	while (_freeList != 0) {
		assert((numSlotsOfAny(_freeList)) == ObjStackPageSlots);
		/* begin fetchPointer:ofObject: */
		_next = unsignedLongAt((_freeList + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* begin relocateObjectsInHeapEntity:from:to: */
		for (_i2 = ObjStackFreex; _i2 <= ObjStackFreex; _i2 += 1) {
			/* begin fetchPointer:ofObject: */
			_oop2 = unsignedLongAt((_freeList + BaseHeaderSize) + ((sqInt) (((usqInt) _i2 ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_oop2 & (tagMask())) == 0) && ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(_oop2, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_oop2)) ) >> (pinnedBitShift())) & 1) != 0)))) {
				assert(isMarked(_oop2));
				/* begin fetchPointer:ofObject: */
				_fwd2 = unsignedLongAt((_oop2 + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofObject: */
				assert(isPostMobile(_fwd2));
				/* begin storePointerUnchecked:ofObject:withValue: */
				assert(!(isOopForwarded(_freeList)));
				longAtput((_freeList + BaseHeaderSize) + ((sqInt) (((usqInt) _i2 ) << (shiftForWord())) ), _fwd2);
				/* end storePointerUnchecked:ofObject:withValue: */
			}
		}
		if ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(_freeList, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_freeList)) ) >> (pinnedBitShift())) & 1) != 0))) {
			/* begin fetchPointer:ofObject: */
			unsignedLongAt((_freeList + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofObject: */
		}
		/* end relocateObjectsInHeapEntity:from:to: */
		_freeList = _next;
	}
	return _result;
}
/* SpurMemoryManager>>#rememberObjInCorrectRememberedSet: */
sqInt
rememberObjInCorrectRememberedSet(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (((_objOop & (tagMask())) == 0) && ((_objOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		return remember(GIV(fromOldSpaceRememberedSet), _objOop);
	}
	if (((_objOop & (tagMask())) == 0) && (_objOop >= 0x20000000000LL)) {
		return remember(GIV(fromPermToNewSpaceRememberedSet), _objOop);
	}
	return _objOop;
}
/*	Remove the given variable location to the extra roots table. */
/* SpurMemoryManager>>#removeGCRoot: */
sqInt
removeGCRoot(sqInt *_varLoc)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;

	for (_i = 1; _i <= GIV(extraRootCount); _i += 1) {
		if (_varLoc == (GIV(extraRoots)[_i])) {
			GIV(extraRoots)[_i] = GIV(extraRoots)[GIV(extraRootCount)];
			GIV(extraRootCount) -= 1;
			return 1;
		}
	}
	return 0;
}
/* SpurMemoryManager>>#runLeakCheckerForFreeSpace: */
static void NoDbgRegParms
runLeakCheckerForFreeSpace(sqInt _gcModes)
{
	if (_gcModes & GCModeFreeSpace) {
		clearLeakMapAndMapAccessibleFreeSpace();
		assert(checkHeapFreeSpaceIntegrity());
	}
}
/* SpurMemoryManager>>#runLeakCheckerFor: */
static void NoDbgRegParms
runLeakCheckerFor(sqInt _gcModes)
{
	{
		/* begin inLineRunLeakCheckerFor:excludeUnmarkedObjs:classIndicesShouldBeValid: */
		if (_gcModes & checkForLeaks) {
			clearLeakMapAndMapAccessibleObjects();
			assert(checkHeapIntegrityclassIndicesShouldBeValid(0, 1));
			assert((checkInterpreterIntegrity()) == 0);
			assert(checkStackIntegrity());
			assert(checkCodeIntegrity(_gcModes));
		}
		/* end inLineRunLeakCheckerFor:excludeUnmarkedObjs:classIndicesShouldBeValid: */
		return;
	}
}
/* SpurMemoryManager>>#runLeakCheckerFor:excludeUnmarkedObjs:classIndicesShouldBeValid: */
static void NoDbgRegParms
runLeakCheckerForexcludeUnmarkedObjsclassIndicesShouldBeValid(sqInt _gcModes, sqInt _excludeUnmarkedObjs, sqInt _classIndicesShouldBeValid)
{
	/* begin inLineRunLeakCheckerFor:excludeUnmarkedObjs:classIndicesShouldBeValid: */
	if (_gcModes & checkForLeaks) {
		clearLeakMapAndMapAccessibleObjects();
		assert(checkHeapIntegrityclassIndicesShouldBeValid(_excludeUnmarkedObjs, _classIndicesShouldBeValid));
		assert((checkInterpreterIntegrity()) == 0);
		assert(checkStackIntegrity());
		assert(checkCodeIntegrity(_gcModes));
	}
	/* end inLineRunLeakCheckerFor:excludeUnmarkedObjs:classIndicesShouldBeValid: */
}
/*	Run the scavenger. */
/* SpurMemoryManager>>#scavengingGCTenuringIf: */
static void NoDbgRegParms
scavengingGCTenuringIf(sqInt _tenuringCriterion)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMMemoryMap * self_in_doCheckMemoryMap;
	sqInt _i;
	sqInt _memEnd;
	sqInt _memStart;
	int _probe;

	assert(GIV(remapBufferCount) == 0);
	if (!(asserta(((((eden()).limit)) - GIV(freeStart)) >= (interpreterAllocationReserveBytes())))) {
		{
			/* begin tab */
			printChar('	');
			/* end tab */
			printNum((((eden()).limit)) - GIV(freeStart));
			/* begin space */
			printChar(' ');
			/* end space */
			printNum(interpreterAllocationReserveBytes());
			/* begin space */
			printChar(' ');
			/* end space */
			printNum((interpreterAllocationReserveBytes()) - ((((eden()).limit)) - GIV(freeStart)));
			/* begin cr */
			print("\n");
			/* end cr */
		}
	}
	/* begin checkMemoryMap */
	{
		/* begin doCheckMemoryMap */
		/* begin getMemoryMap */
		self_in_doCheckMemoryMap = GIV(memoryMap);
		/* end getMemoryMap */
		assert(isYoungObject(self_in_doCheckMemoryMap, (self_in_doCheckMemoryMap->newSpaceStart)));
		assert(isYoungObject(self_in_doCheckMemoryMap, ((self_in_doCheckMemoryMap->newSpaceEnd)) - BytesPerWord));
		assert(!(isOldObject(self_in_doCheckMemoryMap, (self_in_doCheckMemoryMap->newSpaceStart))));
		assert(!(isOldObject(self_in_doCheckMemoryMap, ((self_in_doCheckMemoryMap->newSpaceEnd)) - BytesPerWord)));
		assert(isYoungObject(self_in_doCheckMemoryMap, (self_in_doCheckMemoryMap->newSpaceEnd)));
		assert(!(isYoungObject(self_in_doCheckMemoryMap, (self_in_doCheckMemoryMap->oldSpaceStart))));
		assert(!(isYoungObject(self_in_doCheckMemoryMap, (self_in_doCheckMemoryMap->oldSpaceEnd))));
		assert(isOldObject(self_in_doCheckMemoryMap, (self_in_doCheckMemoryMap->oldSpaceStart)));
		assert(isOldObject(self_in_doCheckMemoryMap, ((self_in_doCheckMemoryMap->oldSpaceEnd)) - BytesPerWord));
		assert(isOldObject(self_in_doCheckMemoryMap, (self_in_doCheckMemoryMap->oldSpaceEnd)));
		/* end doCheckMemoryMap */
	}
	assert(!(isOldObject(GIV(memoryMap), minCogMethodAddress())));
	assert(!(isOldObject(GIV(memoryMap), maxCogMethodAddress())));
	/* end checkMemoryMap */
	/* begin checkFreeSpace: */
	assert(bitsSetInFreeSpaceMaskForAllFreeLists());
	assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
	if ((checkForLeaks & (GCModeFreeSpace | GCModeNewSpace)) == (GCModeFreeSpace | GCModeNewSpace)) {
		runLeakCheckerForFreeSpace(GCModeFreeSpace);
	}
	/* end checkFreeSpace: */
	runLeakCheckerFor(GCModeNewSpace);
	{
		preGCAction(GCModeNewSpace);
		/* begin flushMethodCacheFrom:to: */
		_memStart = ((sqInt) ((GIV(memoryMap)->newSpaceStart)) );
		_memEnd = ((sqInt) ((GIV(memoryMap)->newSpaceEnd)) );
		_probe = 0;
		for (_i = 1; _i <= MethodCacheEntries; _i += 1) {
			if (!((GIV(methodCache)[_probe + MethodCacheSelector]) == 0)) {
				if ((((oopisGreaterThanOrEqualTo(GIV(methodCache)[_probe + MethodCacheSelector], _memStart)) && (oopisLessThan(GIV(methodCache)[_probe + MethodCacheSelector], _memEnd))) || ((oopisGreaterThanOrEqualTo(GIV(methodCache)[_probe + MethodCacheClass], _memStart)) && (oopisLessThan(GIV(methodCache)[_probe + MethodCacheClass], _memEnd)))) || ((oopisGreaterThanOrEqualTo(GIV(methodCache)[_probe + MethodCacheMethod], _memStart)) && (oopisLessThan(GIV(methodCache)[_probe + MethodCacheMethod], _memEnd)))) {
					GIV(methodCache)[_probe + MethodCacheSelector] = 0;
				}
			}
			_probe += MethodCacheEntrySize;
		}
		/* end flushMethodCacheFrom:to: */
	}
	GIV(needGCFlag) = 0;
	GIV(gcStartUsecs) = ioUTCMicrosecondsNow();
	doScavenge(_tenuringCriterion);
	GIV(statScavenges) += 1;
	GIV(statGCEndUsecs) = ioUTCMicrosecondsNow();
	GIV(statSGCDeltaUsecs) = GIV(statGCEndUsecs) - GIV(gcStartUsecs);
	GIV(statScavengeGCUsecs) += GIV(statSGCDeltaUsecs);
	GIV(statRootTableCount) = (GIV(fromOldSpaceRememberedSet)->rememberedSetSize);
	/* begin logScavenge */
	if (GIV(scavengeLog)) {
		writeScavengeLog();
	}
	/* end logScavenge */
	postGCAction(GCModeNewSpace);
	runLeakCheckerFor(GCModeNewSpace);
	/* begin checkFreeSpace: */
	assert(bitsSetInFreeSpaceMaskForAllFreeLists());
	assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
	if ((checkForLeaks & (GCModeFreeSpace | GCModeNewSpace)) == (GCModeFreeSpace | GCModeNewSpace)) {
		runLeakCheckerForFreeSpace(GCModeFreeSpace);
	}
	/* end checkFreeSpace: */
}
/* SpurMemoryManager>>#setAvoidSearchingSegmentsWithPinnedObjects: */
void
setAvoidSearchingSegmentsWithPinnedObjects(sqInt _aValue)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	GIV(avoidSearchingSegmentsWithPinnedObjects) = _aValue;
}
/* SpurMemoryManager>>#setMaxOldSpaceSize: */
sqInt
setMaxOldSpaceSize(usqInt _limit)
{
	maxOldSpaceSize = _limit;
	return 0;
}
/* SpurMemoryManager>>#setMaxSlotsForNewSpaceAlloc: */
void
setMaxSlotsForNewSpaceAlloc(sqInt _aValue)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	GIV(maxSlotsForNewSpaceAlloc) = _aValue;
}
/* SpurMemoryManager>>#setMinimalPermSpaceSize: */
void
setMinimalPermSpaceSize(sqInt _min)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin ensureMemoryMap */
	if (GIV(memoryMap)) {
		goto l3;
	}
	GIV(memoryMap) = ((VMMemoryMap *) (malloc(sizeof(VMMemoryMap))) );
	/* begin initializeMemoryMap */
	(GIV(memoryMap)->initialCodeZoneSize) = 0;
	(GIV(memoryMap)->initialPermSpaceSize) = 0;
	(GIV(memoryMap)->minPermSpaceSize) = 0;
	(GIV(memoryMap)->permSpaceStart) = 0;
	(GIV(memoryMap)->permSpaceEnd) = 0;
	(GIV(memoryMap)->permSpaceMask) = -1;
	/* begin simulationOnly: */
	/* end simulationOnly: */
	calculateMaskToUse(GIV(memoryMap));
	/* end initializeMemoryMap */
	l3:
	;
	/* end ensureMemoryMap */
	((getMemoryMap())->minPermSpaceSize = _min);
}
/* SpurMemoryManager>>#shortPrintObjectsFrom:to: */
void
shortPrintObjectsFromto(sqInt _startAddress, sqInt _endAddress)
{
	sqInt _oop;

	_oop = objectBefore(_startAddress);
	if (_oop == null) {
		_oop = _startAddress;
	} else {
		_oop = (((objectAfter(_oop)) == _startAddress)
			 ? _startAddress
			 : _oop);
	}
	while (oopisLessThan(_oop, _endAddress)) {
		if (!(((longAt(_oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			shortPrintOop(_oop);
		}
		_oop = objectAfter(_oop);
	}
}
/*	Answer if the oop should be scavenged.. The method is called 
	shouldRemapOop: for compatibility with ObjectMemory. */
/* SpurMemoryManager>>#shouldRemapOop: */
sqInt
shouldRemapOop(sqInt _oop)
{
	return ((_oop & (tagMask())) == 0) && (shouldRemapObj(_oop));
}
/*	Answer the size of largest free chunk in oldSpace. Looking in freetree and 
	freelists  */
/* SpurMemoryManager>>#sizeOfLargestFreeChunk */
static usqInt
sizeOfLargestFreeChunk(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _freeChunk;
	sqInt _i;

	_freeChunk = findLargestFreeChunk();
	if (!_freeChunk) {
		for (_i = 0x3F; _i >= 1; _i += -1) {
			_freeChunk = GIV(freeLists)[_i];
			if (_freeChunk != 0) {
				return bytesInObject(_freeChunk);
			}
		}
		return 0;
	}
	return bytesInObject(_freeChunk);
}
/* SpurMemoryManager>>#sizeOfObjStack: */
static sqInt NoDbgRegParms
sizeOfObjStack(sqInt _objStack)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _objStackPage;
	sqInt _total;

	if (_objStack == GIV(nilObj)) {
		return 0;
	}
	/* begin fetchPointer:ofObject: */
	_total = unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	_objStackPage = _objStack;
	while (1) {
		/* begin fetchPointer:ofObject: */
		_objStackPage = unsignedLongAt((_objStackPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (!(_objStackPage != 0)) 
			break;
		_total += ObjStackLimit;
		assert((fetchPointerofObject(ObjStackTopx, _objStackPage)) == ObjStackLimit);
	}
	return _total;
}
/* SpurMemoryManager>>#slidingCompactionInProgress */
static sqInt
slidingCompactionInProgress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(gcPhaseInProgress) == SlidingCompactionInProgress;
}
/*	*DO NOT CONFUSE THIS WITH numSlotsOf:. 
	This is an ObjectMemory compatibility method with questionable semantics. 
	Answers the number of slots in the receiver. 
	If the receiver is a byte object, return the number of bytes. 
	Otherwise return the number of words. */
/* SpurMemoryManager>>#slotSizeOf: */
sqInt
slotSizeOf(sqInt _oop)
{
	sqInt _fmt;
	usqInt _numSlots;
	usqInt _numSlots2;

	if (_oop & (tagMask())) {
		return 0;
	}
	/* begin lengthOf:format: */
	_fmt = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOfAny: */
	_numSlots2 = byteAt(_oop + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_oop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOfAny: */
	if (_fmt <= 5) {
		return _numSlots;
	}
	if (_fmt >= (firstByteFormat())) {
		return (_numSlots << (shiftForWord())) - (_fmt & 7);
	}
	if (_fmt >= (firstShortFormat())) {
		return (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
	}
	if (_fmt >= (firstLongFormat())) {
		return (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		return _numSlots;
	}
	return 0;
	/* end lengthOf:format: */
}
/*	Return one of the objects in the specialObjectsArray */
/* SpurMemoryManager>>#splObj: */
sqInt
splObj(sqInt _index)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/*	Answer the start of objOop, which is either the address of the overflow 
	size word, or objOop itself, depending on the size of the object. This may 
	be applied to any kind of object, normal, forwarders or free chunks. */
/* SpurMemoryManager>>#startOfObject: */
static usqInt NoDbgRegParms
startOfObject(sqInt _objOop)
{
	return (((byteAt(_objOop + 7)) == (numSlotsMask()))
		 ? _objOop - BaseHeaderSize
		 : _objOop);
}
/* SpurMemoryManager>>#statNumGCs */
EXPORT(sqInt)
statNumGCs(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(statScavenges) + GIV(statFullGCs);
}
/*	A renaming for the Cogit, which couldn't make sense of GIV(newSpaceLimit) */
/* SpurMemoryManager>>#storeCheckBoundary */
uint64_t
storeCheckBoundary(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return (GIV(memoryMap)->oldSpaceStart);
}
/* SpurMemoryManager>>#storePointerUnchecked:ofObject:withValue: */
sqInt
storePointerUncheckedofObjectwithValue(sqInt _fieldIndex, sqInt _objOop, sqInt _valuePointer)
{
	assert(!(isOopForwarded(_objOop)));
	return longAtput((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ), _valuePointer);
}
/*	Note must check here for stores of young objects into old ones. */
/* SpurMemoryManager>>#storePointer:ofObject:withValue: */
sqInt
storePointerofObjectwithValue(sqInt _fieldIndex, sqInt _objOop, sqInt _valuePointer)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	assert(!(isForwarded(_objOop)));
	if (((_objOop & (tagMask())) == 0) && ((_objOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((_valuePointer & (tagMask())) == 0) && (((_valuePointer & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_valuePointer >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _objOop);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(_objOop)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l2;
	}
	if (_valuePointer & (tagMask())) {
		goto l2;
	}
	if (!(_objOop >= 0x20000000000LL)) {
		goto l2;
	}
	if (_valuePointer >= 0x20000000000LL) {
		goto l2;
	}
	if ((_valuePointer >= GIV(nilObj)) && (_valuePointer <= GIV(trueObj))) {
		goto l2;
	}
	if (!(_valuePointer >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l2;
	}
	remember(getFromPermToNewSpaceRememberedSet(), _objOop);
	l2:
	;
	/* end possiblePermObjectStoreInto:value: */
	return unsignedLongAtput((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ), _valuePointer);
}
/*	Answer a new String copied from a null-terminated C string, 
	or nil if out of memory. */
/* SpurMemoryManager>>#stringForCString: */
sqInt
stringForCString(const char *_aCString)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _formatField;
	int _hasToScheduleScavenge;
	sqInt _len;
	sqInt _newObj;
	sqInt _newString;
	usqInt _numBytes;
	sqInt _numSlots;

	_len = strlen(_aCString);
	/* begin allocateSlots:format:classIndex: */
	_numSlots = (_len + (BytesPerWord - 1)) / BytesPerWord;
	_formatField = (firstByteFormat()) + ((8 - _len) & (BytesPerWord - 1));
	/* begin allocateSlots:format:classIndex:isPinned:isOldSpace: */
	if (_numSlots >= (numSlotsMask())) {
		if ((((usqInt) _numSlots ) >> 56) > 0) {
			_newString = null;
			goto l2;
		}
		_numBytes = (BaseHeaderSize + BaseHeaderSize) + (_numSlots * BytesPerOop);
	} else {
		_numBytes = BaseHeaderSize + (((_numSlots < 1)
			 ? 8
			 : _numSlots * BytesPerOop));
	}
	_hasToScheduleScavenge = (GIV(freeStart) + _numBytes) > GIV(scavengeThreshold);
	if (_hasToScheduleScavenge || 0) {
		if (_hasToScheduleScavenge) {
			if (!GIV(needGCFlag)) {
				/* begin scheduleScavenge */
				GIV(needGCFlag) = 1;
				forceInterruptCheck();
				/* end scheduleScavenge */
			}
		}
		{
			_newString = allocateSlotsInOldSpacebytesformatclassIndex(_numSlots, _numBytes, _formatField, ClassByteStringCompactIndex);
			goto l2;
		}
	}
	_newObj = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(GIV(freeStart), _numSlots, _formatField, ClassByteStringCompactIndex, 0);
	assert((_numBytes % (allocationUnit())) == 0);
	assert((_newObj % (allocationUnit())) == 0);
	GIV(freeStart) += _numBytes;
	_newString = _newObj;
	/* end allocateSlots:format:classIndex:isPinned:isOldSpace: */
	l2:
	;
	/* end allocateSlots:format:classIndex: */
	if (_newString) {
		strncpy(((char *) (_newString + BaseHeaderSize) ), _aCString, _len);
	}
	return _newString;
}
/*	This is ObjectMemory's funky entry-point into its incremental GC, 
	which is a stop-the-world a young generation reclaimer. In Spur 
	we run the scavenger. Answer if space is not low. */
/* SpurMemoryManager>>#sufficientSpaceAfterGC: */
static sqInt NoDbgRegParms
sufficientSpaceAfterGC(sqInt _numBytes)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _heapSizePostGC;

	assert(_numBytes == 0);
	scavengingGCTenuringIf(TenureByAge);
	_heapSizePostGC = (GIV(totalHeapSizeIncludingBridges) - (GIV(numSegments) * (2 * BaseHeaderSize))) - GIV(totalFreeOldSpace);
	if ((((double) (_heapSizePostGC - GIV(heapSizeAtPreviousGC)) ) / GIV(heapSizeAtPreviousGC)) >= GIV(heapGrowthToSizeGCRatio)) {
		fullGC();
	}
	while ((GIV(totalFreeOldSpace) < GIV(growHeadroom)) && ((growOldSpaceByAtLeastcallingOperation(0, "ensuring sufficient space after GC")) != null)) {
		if (GIV(totalFreeOldSpace) >= GIV(growHeadroom)) {
			return 1;
		}
	}
	if (GIV(lowSpaceThreshold) > GIV(totalFreeOldSpace)) {
		GIV(lowSpaceThreshold) = 0;
		return 0;
	}
	return 1;
}
/*	On load, swizzle the pointers in an obj stack. Answer the obj stack's oop. */
/* SpurMemoryManager>>#swizzleObjStackAt: */
static sqInt NoDbgRegParms
swizzleObjStackAt(sqInt _objStackRootIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _field;
	sqInt _firstPage;
	sqInt _index;
	sqInt _page;
	sqInt _stackOrNil;

	_firstPage = (_stackOrNil = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _objStackRootIndex ) << (shiftForWord())) )));
	if (_stackOrNil == GIV(nilObj)) {
		return _stackOrNil;
	}
	do {
		assert((numSlotsOfAny(_stackOrNil)) == ObjStackPageSlots);
		assert((fetchPointerofObject(ObjStackMyx, _stackOrNil)) == _objStackRootIndex);
		_index = (unsignedLongAt((_stackOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ))) + ObjStackNextx;
		do {
			/* begin fetchPointer:ofObject: */
			_field = unsignedLongAt((_stackOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (!((_field == 0) || (_field & (tagMask())))) {
				_field = swizzleObj(_field);
				/* begin storePointer:ofObjStack:withValue: */
				assert((formatOf(_stackOrNil)) == (wordIndexableFormat()));
				unsignedLongAtput((_stackOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ), _field);
				/* end storePointer:ofObjStack:withValue: */
			}
		} while (((_index -= 1)) >= ObjStackNextx);
	} while (((_stackOrNil = _field)) != 0);
	if (((_stackOrNil = unsignedLongAt((_firstPage + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) )))) != 0) {
		_page = _firstPage;
		do {
			_stackOrNil = swizzleObj(_stackOrNil);
			/* begin storePointer:ofObjStack:withValue: */
			assert((formatOf(_page)) == (wordIndexableFormat()));
			unsignedLongAtput((_page + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) ), _stackOrNil);
			/* end storePointer:ofObjStack:withValue: */
			_page = _stackOrNil;
		} while (((_stackOrNil = unsignedLongAt((_page + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackFreex ) << (shiftForWord())) )))) != 0);
	}
	assert(isValidObjStackAt(_objStackRootIndex));
	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _objStackRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/*	Do an incremental GC that tenures all surviving young objects to old 
	space.  */
/* SpurMemoryManager>>#tenuringIncrementalGC */
void
tenuringIncrementalGC(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _savedTenuringThreshold;
	sqInt _threshold;

	/* begin flushNewSpace */
	/* begin getRawTenuringThreshold */
	_savedTenuringThreshold = GIV(tenureThreshold);
	/* end getRawTenuringThreshold */
	/* begin setRawTenuringThreshold: */
	_threshold = ((sqInt) ((GIV(memoryMap)->newSpaceEnd)) );
	GIV(tenureThreshold) = _threshold;
	/* end setRawTenuringThreshold: */
	scavengingGCTenuringIf(TenureByAge);
	/* begin setRawTenuringThreshold: */
	GIV(tenureThreshold) = _savedTenuringThreshold;
	/* end setRawTenuringThreshold: */
	assert(((GIV(fromOldSpaceRememberedSet)->rememberedSetSize)) == 0);
	assert(GIV(pastSpaceStart) == (((pastSpace()).start)));
	assert(GIV(freeStart) == (((eden()).start)));
	/* end flushNewSpace */
}
/*	This assert is tricky. push:onObjStack: may call topOfObjStack: just after 
	pushing an 
	empty page on the stack, and will ask if the second page is valid. */
/* SpurMemoryManager>>#topOfObjStack: */
static sqInt NoDbgRegParms
topOfObjStack(sqInt _objStack)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _topx;

	eassert(isValidObjStackPagemyIndexfirstPage(_objStack, fetchPointerofObject(ObjStackMyx, _objStack), _objStack == (fetchPointerofObject(fetchPointerofObject(ObjStackMyx, _objStack), GIV(hiddenRootsObj)))));
	/* begin fetchPointer:ofObject: */
	_topx = unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_topx == 0) {
		assert((fetchPointerofObject(ObjStackNextx, _objStack)) == 0);
		return null;
	}
	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((_objStack + BaseHeaderSize) + ((sqInt) (((usqInt) ((_topx + ObjStackFixedSlots) - 1) ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/*	Answers the top of the remappable oop stack. Useful when writing loops. 
	We support this excessence for compatibility with ObjectMemory. 
	Spur doesn't GC during allocation. */
/* SpurMemoryManager>>#topRemappableOop */
sqInt
topRemappableOop(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(remapBuffer)[GIV(remapBufferCount)];
}
/* SpurMemoryManager>>#totalBytesInPermanentSpace */
static size_t
totalBytesInPermanentSpace(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(permSpaceFreeStart) - ((GIV(memoryMap)->permSpaceStart));
}
/*	This method both computes the actual number of free bytes by traversing 
	all free objects 
	on the free lists/tree, and checks that the tree is valid. It is used 
	mainly by checkFreeSpace. */
/* SpurMemoryManager>>#totalFreeListBytes */
static sqInt
totalFreeListBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _bytesInChunk;
	sqInt _cameFrom;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;
	sqInt _fieldIndex22;
	sqInt _fieldIndex3;
	sqInt _fieldIndex4;
	sqInt _i;
	sqInt _iLimit;
	sqInt _largeChild;
	sqInt _listNode;
	sqInt _nextNode;
	sqInt _smallChild;
	sqInt _totalFreeBytes;
	sqInt _treeNode2;

	_totalFreeBytes = 0;
	for (_i = 1, _iLimit = 64 - 1; _i <= _iLimit; _i += 1) {
		_bytesInChunk = _i * 8;
		_listNode = GIV(freeLists)[_i];
		while (_listNode != 0) {
			_totalFreeBytes += _bytesInChunk;
			/* begin assertValidFreeObject: */
			assert(assertInnerValidFreeObject(_listNode));
			/* end assertValidFreeObject: */
			assert(_bytesInChunk == (bytesInObject(_listNode)));
			/* begin fetchPointer:ofFreeChunk: */
			_fieldIndex = 0;
			_nextNode = unsignedLongAt((_listNode + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofFreeChunk: */
			assert(_nextNode != _listNode);
			_listNode = _nextNode;
		}
	}
	/* begin freeTreeNodesDo: */
	_treeNode2 = GIV(freeLists)[0];
	if (_treeNode2 == 0) {
		goto l7;
	}
	_cameFrom = -1;
	do {
		assert((bytesInObject(_treeNode2)) >= ((numFreeLists()) * (allocationUnit())));
		/* begin fetchPointer:ofFreeChunk: */
		_fieldIndex22 = 3;
		_smallChild = unsignedLongAt((_treeNode2 + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex22 ) << (shiftForWord())) ));
		/* end fetchPointer:ofFreeChunk: */
		/* begin fetchPointer:ofFreeChunk: */
		_fieldIndex3 = 4;
		_largeChild = unsignedLongAt((_treeNode2 + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex3 ) << (shiftForWord())) ));
		/* end fetchPointer:ofFreeChunk: */
		assert((_smallChild == 0) || (_treeNode2 == (fetchPointerofFreeChunk(freeChunkParentIndex(), _smallChild))));
		assert((_largeChild == 0) || (_treeNode2 == (fetchPointerofFreeChunk(freeChunkParentIndex(), _largeChild))));
		if (((_smallChild == 0) && (_largeChild == 0)) || (((_largeChild == 0)
			 ? _cameFrom == _smallChild
			 : _cameFrom == _largeChild))) {
			{
				_bytesInChunk = bytesInObject(_treeNode2);
				assert((_bytesInChunk / (allocationUnit())) >= (numFreeLists()));
				_listNode = _treeNode2;
				while (_listNode != 0) {
					/* begin assertValidFreeObject: */
					assert(assertInnerValidFreeObject(_listNode));
					/* end assertValidFreeObject: */
					assert((_listNode == _treeNode2) || ((fetchPointerofFreeChunk(freeChunkParentIndex(), _listNode)) == 0));
					_totalFreeBytes += _bytesInChunk;
					assert(_bytesInChunk == (bytesInObject(_listNode)));
					/* begin fetchPointer:ofFreeChunk: */
					_fieldIndex2 = 0;
					_nextNode = unsignedLongAt((_listNode + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
					/* end fetchPointer:ofFreeChunk: */
					assert(_nextNode != _listNode);
					_listNode = _nextNode;
				}
			}
			_cameFrom = _treeNode2;
			/* begin fetchPointer:ofFreeChunk: */
			_fieldIndex4 = 2;
			_treeNode2 = unsignedLongAt((_treeNode2 + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex4 ) << (shiftForWord())) ));
			/* end fetchPointer:ofFreeChunk: */
		} else {
			if ((_smallChild != 0) && (_cameFrom != _smallChild)) {
				_treeNode2 = _smallChild;
			} else {
				assert(_largeChild != 0);
				_treeNode2 = _largeChild;
			}
			_cameFrom = -1;
		}
	} while (_treeNode2 != 0);
	l7:
	;
	/* end freeTreeNodesDo: */
	return _totalFreeBytes;
}
/* SpurMemoryManager>>#trueObject */
sqInt
trueObject(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(trueObj);
}
/*	Unlink a free object from the free lists. Do not alter totalFreeOldSpace. 
	Used for coalescing. */
/* SpurMemoryManager>>#unlinkFreeChunk:chunkBytes: */
static sqInt NoDbgRegParms
unlinkFreeChunkchunkBytes(sqInt _freeChunk, sqInt _chunkBytes)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;
	sqInt _fieldIndex3;
	sqInt _index;
	sqInt _next;
	sqInt _next2;
	sqInt _nextFreeChunk;
	sqInt _prev;

	_index = _chunkBytes / 8;
	if ((assert(_chunkBytes >= (BaseHeaderSize + (allocationUnit()))), _chunkBytes == (BaseHeaderSize + 8))) {
		return unlinkLilliputianChunkindex(_freeChunk, _index);
	}
	/* begin fetchPointer:ofFreeChunk: */
	_fieldIndex = 1;
	_prev = unsignedLongAt((_freeChunk + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofFreeChunk: */
	if (_prev != 0) {
		/* begin setNextFreeChunkOf:withValue:chunkBytes: */
		_nextFreeChunk = unsignedLongAt((_freeChunk + BaseHeaderSize) + (0U << (shiftForWord())));
		/* begin setNextFreeChunkOf:withValue:isLilliputianSize: */
		/* begin storePointer:ofFreeChunk:withValue: */
		assert(isFreeObject(_prev));
		assert((_nextFreeChunk == 0) || (isFreeObject(_nextFreeChunk)));
		unsignedLongAtput((_prev + BaseHeaderSize) + (0U << (shiftForWord())), _nextFreeChunk);
		/* end storePointer:ofFreeChunk:withValue: */
		if ((_nextFreeChunk != 0) && (!((assert(_chunkBytes >= (BaseHeaderSize + (allocationUnit()))), _chunkBytes == (BaseHeaderSize + 8))))) {
			/* begin storePointer:ofFreeChunk:withValue: */
			assert(isFreeObject(_nextFreeChunk));
			assert((_prev == 0) || (isFreeObject(_prev)));
			unsignedLongAtput((_nextFreeChunk + BaseHeaderSize) + (1U << (shiftForWord())), _prev);
			/* end storePointer:ofFreeChunk:withValue: */
		}
		/* end setNextFreeChunkOf:withValue:isLilliputianSize: */
		/* end setNextFreeChunkOf:withValue:chunkBytes: */
		return _freeChunk;
	}
	if ((_index < 64) && ((1ULL << _index) <= GIV(freeListsMask))) {
		/* begin unlinkFreeChunk:atIndex:isLilliputianSize: */
		assert(((bytesInObject(_freeChunk)) == (_index * (allocationUnit()))) && ((_index > 1) && ((startOfObject(_freeChunk)) == _freeChunk)));
		GIV(freeLists)[_index] = (_next2 = unsignedLongAt((_freeChunk + BaseHeaderSize) + (0U << (shiftForWord()))));
		if (_next2 != 0) {
			/* begin storePointer:ofFreeChunk:withValue: */
			_fieldIndex3 = 1;
			assert(isFreeObject(_next2));
			assert(1);
			unsignedLongAtput((_next2 + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex3 ) << (shiftForWord())) ), 0);
			/* end storePointer:ofFreeChunk:withValue: */
		}
		/* end unlinkFreeChunk:atIndex:isLilliputianSize: */
		return _freeChunk;
	}
	/* begin fetchPointer:ofFreeChunk: */
	_fieldIndex2 = 0;
	_next = unsignedLongAt((_freeChunk + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
	/* end fetchPointer:ofFreeChunk: */
	if (_next == 0) {
		unlinkSolitaryFreeTreeNode(_freeChunk);
	}
 else {
		inFreeTreeReplacewith(_freeChunk, _next);
	}
	return _freeChunk;
}
/* SpurMemoryManager>>#unlinkLilliputianChunk:index: */
static sqInt NoDbgRegParms NeverInline
unlinkLilliputianChunkindex(sqInt _freeChunk, sqInt _index)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _fieldIndex;
	sqInt _next;
	sqInt _next2;
	sqInt _node;
	sqInt _prev;

	_node = GIV(freeLists)[_index];
	_prev = 0;
	while (_node != 0) {
		assert(_node == (startOfObject(_node)));
		/* begin assertValidFreeObject: */
		assert(assertInnerValidFreeObject(_node));
		/* end assertValidFreeObject: */
		/* begin fetchPointer:ofFreeChunk: */
		_fieldIndex = 0;
		_next = unsignedLongAt((_node + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofFreeChunk: */
		if (_node == _freeChunk) {
			if (_prev == 0) {
				/* begin unlinkFreeChunk:atIndex:isLilliputianSize: */
				assert(((bytesInObject(_freeChunk)) == (_index * (allocationUnit()))) && ((_index > 1) && ((startOfObject(_freeChunk)) == _freeChunk)));
				GIV(freeLists)[_index] = (_next2 = unsignedLongAt((_freeChunk + BaseHeaderSize) + (0U << (shiftForWord()))));
				/* end unlinkFreeChunk:atIndex:isLilliputianSize: */
			} else {
				/* begin setNextFreeChunkOf:withValue:isLilliputianSize: */
				/* begin storePointer:ofFreeChunk:withValue: */
				assert(isFreeObject(_prev));
				assert((_next == 0) || (isFreeObject(_next)));
				unsignedLongAtput((_prev + BaseHeaderSize) + (0U << (shiftForWord())), _next);
				/* end storePointer:ofFreeChunk:withValue: */
				/* end setNextFreeChunkOf:withValue:isLilliputianSize: */
			}
			return _freeChunk;
		}
		_prev = _node;
		_node = _next;
	}
	error("freeChunk not found in lilliputian chunk free list");
	return 0;
}
/*	Unlink a freeTreeNode. Assumes the node has no list (null next link). */
/* SpurMemoryManager>>#unlinkSolitaryFreeTreeNode: */
static void NoDbgRegParms
unlinkSolitaryFreeTreeNode(sqInt _freeTreeNode)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;
	sqInt _fieldIndex3;
	sqInt _fieldIndex4;
	sqInt _fieldIndex5;
	sqInt _fieldIndex6;
	sqInt _fieldIndex7;
	sqInt _fieldIndex8;
	sqInt _fieldIndex9;
	sqInt _larger;
	sqInt _parent;
	sqInt _smaller;

	assert((fetchPointerofFreeChunk(freeChunkNextIndex(), _freeTreeNode)) == 0);
	/* begin fetchPointer:ofFreeChunk: */
	_fieldIndex7 = 3;
	_smaller = unsignedLongAt((_freeTreeNode + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex7 ) << (shiftForWord())) ));
	/* end fetchPointer:ofFreeChunk: */
	/* begin fetchPointer:ofFreeChunk: */
	_fieldIndex8 = 4;
	_larger = unsignedLongAt((_freeTreeNode + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex8 ) << (shiftForWord())) ));
	/* end fetchPointer:ofFreeChunk: */
	/* begin fetchPointer:ofFreeChunk: */
	_fieldIndex9 = 2;
	_parent = unsignedLongAt((_freeTreeNode + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex9 ) << (shiftForWord())) ));
	/* end fetchPointer:ofFreeChunk: */
	if (_parent == 0) {
		if (_smaller == 0) {
			if (_larger != 0) {
				/* begin storePointer:ofFreeChunk:withValue: */
				_fieldIndex = 2;
				assert(isFreeObject(_larger));
				assert(1);
				unsignedLongAtput((_larger + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ), 0);
				/* end storePointer:ofFreeChunk:withValue: */
			}
			GIV(freeLists)[0] = _larger;
		} else {
			/* begin storePointer:ofFreeChunk:withValue: */
			_fieldIndex2 = 2;
			assert(isFreeObject(_smaller));
			assert(1);
			unsignedLongAtput((_smaller + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ), 0);
			/* end storePointer:ofFreeChunk:withValue: */
			GIV(freeLists)[0] = _smaller;
			if (_larger != 0) {
				addFreeSubTree(_larger);
			}
		}
	}
 else {
		if (_smaller == 0) {
			/* begin storePointer:ofFreeChunk:withValue: */
			if (_freeTreeNode == (unsignedLongAt((_parent + BaseHeaderSize) + (3U << (shiftForWord()))))) {
				/* begin freeChunkSmallerIndex */
				_fieldIndex4 = 3;
				/* end freeChunkSmallerIndex */
			} else {
				/* begin freeChunkLargerIndex */
				_fieldIndex4 = 4;
				/* end freeChunkLargerIndex */
			}
			assert(isFreeObject(_parent));
			assert((_larger == 0) || (isFreeObject(_larger)));
			unsignedLongAtput((_parent + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex4 ) << (shiftForWord())) ), _larger);
			/* end storePointer:ofFreeChunk:withValue: */
			if (_larger != 0) {
				/* begin storePointer:ofFreeChunk:withValue: */
				_fieldIndex3 = 2;
				assert(isFreeObject(_larger));
				assert((_parent == 0) || (isFreeObject(_parent)));
				unsignedLongAtput((_larger + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex3 ) << (shiftForWord())) ), _parent);
				/* end storePointer:ofFreeChunk:withValue: */
			}
		} else {
			/* begin storePointer:ofFreeChunk:withValue: */
			if (_freeTreeNode == (unsignedLongAt((_parent + BaseHeaderSize) + (3U << (shiftForWord()))))) {
				/* begin freeChunkSmallerIndex */
				_fieldIndex5 = 3;
				/* end freeChunkSmallerIndex */
			} else {
				/* begin freeChunkLargerIndex */
				_fieldIndex5 = 4;
				/* end freeChunkLargerIndex */
			}
			assert(isFreeObject(_parent));
			assert((_smaller == 0) || (isFreeObject(_smaller)));
			unsignedLongAtput((_parent + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex5 ) << (shiftForWord())) ), _smaller);
			/* end storePointer:ofFreeChunk:withValue: */
			/* begin storePointer:ofFreeChunk:withValue: */
			_fieldIndex6 = 2;
			assert(isFreeObject(_smaller));
			assert((_parent == 0) || (isFreeObject(_parent)));
			unsignedLongAtput((_smaller + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex6 ) << (shiftForWord())) ), _parent);
			/* end storePointer:ofFreeChunk:withValue: */
			if (_larger != 0) {
				addFreeSubTree(_larger);
			}
		}
	}
}
/* SpurMemoryManager>>#unpinObject: */
sqInt
unpinObject(sqInt _objOop)
{
	assert(isNonImmediate(_objOop));
	/* begin setIsPinnedOf:to: */
	longAtput(_objOop, (longAt(_objOop)) & (~((usqIntptr_t) (1U << (pinnedBitShift())) )));
	/* end setIsPinnedOf:to: */
	return 0;
}
/* SpurMemoryManager>>#updateListStartingAt: */
static void NoDbgRegParms
updateListStartingAt(sqInt _freeNode)
{
	sqInt _fieldIndex;
	sqInt _fieldIndex2;
	sqInt _fieldIndex3;
	sqInt _obj;
	sqInt _prev;

	if (_freeNode == 0) {
		return;
	}
	assert(!(isLilliputianSize(bytesInObject(_freeNode))));
	_prev = _freeNode;
	/* begin storePointer:ofFreeChunk:withValue: */
	_fieldIndex3 = 1;
	assert(isFreeObject(_prev));
	assert(1);
	unsignedLongAtput((_prev + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex3 ) << (shiftForWord())) ), 0);
	/* end storePointer:ofFreeChunk:withValue: */
	while (1) {
		/* begin fetchPointer:ofFreeChunk: */
		_fieldIndex = 0;
		_obj = unsignedLongAt((_prev + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofFreeChunk: */
		if (!(_obj != 0)) 
			break;
		/* begin storePointer:ofFreeChunk:withValue: */
		_fieldIndex2 = 1;
		assert(isFreeObject(_obj));
		assert((_prev == 0) || (isFreeObject(_prev)));
		unsignedLongAtput((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ), _prev);
		/* end storePointer:ofFreeChunk:withValue: */
		_prev = _obj;
	}
}
/* SpurMemoryManager>>#validateObjectMemory */
void
validateObjectMemory(void)
{
	if (!(doValidateObjectMemory())) {
		logError("Error in validating object memory");
	}
}
/*	Check the hashes of classes in the table. The tricky thing here is that 
	classes may be duplicated 
	in the table. So each entry must be in the table at its hash, even if it 
	is elsewhere in the table. */
/* SpurMemoryManager>>#validClassTableHashes */
static sqInt
validClassTableHashes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt ignored;
	sqInt _classOrNil2;
	sqInt _hash;
	sqInt _i;
	sqInt _iLimit;
	sqInt _j;
	sqInt _page;

	if (!(validClassTableRootPages())) {
		return 0;
	}
	/* begin classTableEntriesDo: */
	for (_i = 0; _i < GIV(numClassTablePages); _i += 1) {
		_page = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		for (_j = 0, _iLimit = (1U << (classTableMajorIndexShift())) - 1; _j <= _iLimit; _j += 1) {
			_classOrNil2 = unsignedLongAt((_page + BaseHeaderSize) + ((sqInt) (((usqInt) _j ) << (shiftForWord())) ));
			if (_classOrNil2 != GIV(nilObj)) {
				{
					ignored = ((sqInt) (((usqInt) _i ) << (classTableMajorIndexShift())) ) + _j;
					if (((long64At(_classOrNil2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
						return 0;
					}
					/* begin rawHashBitsOf: */
					_hash = (uint32AtPointer(_classOrNil2 + 4)) & (identityHashHalfWordMask());
					/* end rawHashBitsOf: */
					if (_hash == 0) {
						return 0;
					}
					if ((noCheckClassAtIndex(_hash)) != _classOrNil2) {
						return 0;
					}
				}
			}
		}
	}
	/* end classTableEntriesDo: */
	return 1;
}
/*	Answer if hiddenRootsObj is of the right size with the 
	expected contents, and if numClassTablePages is correct. */
/* SpurMemoryManager>>#validClassTableRootPages */
static sqInt
validClassTableRootPages(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _iLimit;
	sqInt _obj;

	if (!((numSlotsOf(GIV(hiddenRootsObj))) == ((1U << (22 - (classTableMajorIndexShift()))) + 8))) {
		return 0;
	}
	if (!((GIV(numClassTablePages) > 1) && (GIV(numClassTablePages) <= (1U << (22 - (classTableMajorIndexShift())))))) {
		return 0;
	}
	for (_i = 0; _i < GIV(numClassTablePages); _i += 1) {
		/* begin fetchPointer:ofObject: */
		_obj = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (!((addressCouldBeObj(_obj)) && ((numSlotsOf(_obj)) == (1U << (classTableMajorIndexShift()))))) {
			return 0;
		}
	}
	for (_i = GIV(numClassTablePages), _iLimit = (1U << (22 - (classTableMajorIndexShift()))) - 1; _i <= _iLimit; _i += 1) {
		if ((unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ))) != GIV(nilObj)) {
			return 0;
		}
	}
	return 1;
}
/* SpurMemoryManager>>#validFreeTree */
sqInt
validFreeTree(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return (validFreeTreeChunkparent(GIV(freeLists)[0], 0)) == null;
}
/* SpurMemoryManager>>#validFreeTreeChunk: */
static sqInt NoDbgRegParms
validFreeTreeChunk(sqInt _chunk)
{
	if (!(segmentContainingObj(_chunk))) {
		return 0;
	}
	return (validFreeTreeChunkparent(_chunk, unsignedLongAt((_chunk + BaseHeaderSize) + (2U << (shiftForWord()))))) == null;
}
/* SpurMemoryManager>>#validFreeTreeChunk:parent: */
static const char * NoDbgRegParms
validFreeTreeChunkparent(sqInt _chunk, sqInt _parent)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	const char *_reason;

	if (_chunk == 0) {
		return null;
	}
	if (!(((_chunk & (BaseHeaderSize - 1)) == 0) && (oopisGreaterThanOrEqualToandLessThan(_chunk, (GIV(memoryMap)->oldSpaceStart), (GIV(memoryMap)->oldSpaceEnd))))) {
		return "not in old space";
	}
	if (((bytesInObject(_chunk)) / 8) < 64) {
		return "too small";
	}
	if (_parent != (unsignedLongAt((_chunk + BaseHeaderSize) + (2U << (shiftForWord()))))) {
		return "bad parent";
	}
	if ((segmentContainingObj(_chunk)) != (segmentContainingObj(addressAfter(_chunk)))) {
		return "not in one segment";
	}
	{
		_reason = validFreeTreeChunkparent(unsignedLongAt((_chunk + BaseHeaderSize) + (3U << (shiftForWord()))), _chunk);
		if (!(_reason == null)) {
			return _reason;
		}
	}
	{
		_reason = validFreeTreeChunkparent(unsignedLongAt((_chunk + BaseHeaderSize) + (4U << (shiftForWord()))), _chunk);
		if (!(_reason == null)) {
			return _reason;
		}
	}
	return null;
}
/* SpurMemoryManager>>#validObjStacks */
static sqInt
validObjStacks(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((GIV(markStack) == GIV(nilObj)) || (isValidObjStack(GIV(markStack)))) && (((GIV(weaklingStack) == GIV(nilObj)) || (isValidObjStack(GIV(weaklingStack)))) && ((GIV(mournQueue) == GIV(nilObj)) || (isValidObjStack(GIV(mournQueue)))));
}
/*	1 = big, 0 = little */
/* SpurMemoryManager>>#vmEndianness */
sqInt
vmEndianness(void)
{
	return VMBIGENDIAN;
}
/* SpurMemoryManager>>#zeroSlotsNonIndexablePointerFormat */
sqInt
zeroSlotsNonIndexablePointerFormat(void)
{
	return 0;
}
/*	Sweep all of old space, sliding unpinned marked objects down over free and 
	unmarked objects. 
	Let the segmentManager mark which segments contain pinned objects via 
	notePinned:.  */
/* SpurPlanningCompactor>>#compact */
static void NeverInline
compact(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMRememberedSet * self_in_relocateRememberedSet;
	VMRememberedSet * self_in_relocateRememberedSet2;
	VMRememberedSet * self_in_relocateRememberedSet22;
	VMRememberedSet * self_in_relocateRememberedSet3;
	VMRememberedSet * self_in_relocateRememberedSet32;
	VMRememberedSet * self_in_relocateRememberedSet4;
	sqInt _address;
	sqInt _address2;
	sqInt _address3;
	sqInt _finalPass;
	int _firstPass;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	sqInt _hash;
	sqInt _hash2;
	sqInt _hash3;
	sqInt _highestSuitableFreeBlock;
	sqInt _i;
	sqInt _iLimit;
	sqInt _largestFreeChunk;
	sqInt _largestFreeChunk2;
	sqInt _largestFreeChunk3;
	sqInt _limit;
	sqInt _limit2;
	sqInt _limit22;
	sqInt _limit3;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots3;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _objOop222;
	sqInt _objOop223;
	sqInt _objOop23;
	sqInt _objOop24;
	sqInt _objOop32;
	sqInt _objOop322;
	sqInt _objOop323;
	sqInt _objOop4;
	sqInt _objOop42;
	sqInt _objOop43;
	sqInt _objOop5;
	sqInt _objOop52;
	sqInt _objOop53;
	sqInt _objOop6;
	sqInt _objOop62;
	sqInt _objOop63;
	sqInt _objOop7;
	sqInt _objOop72;
	sqInt _objOop73;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevObj3;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;
	sqInt _prevPrevObj3;
	sqInt _sizeOfEden;
	sqInt _spaceEstimate;
	sqInt _spaceEstimate2;
	sqInt _stackOrNil;
	sqInt _stackOrNil2;
	sqInt _stackOrNil3;
	sqInt _theLimit;
	sqInt _theLimit2;
	sqInt _theLimit22;
	sqInt _theLimit3;
	sqInt _theStart;
	sqInt _theStart2;
	sqInt _theStart22;
	sqInt _theStart3;

	if (initializeScanCheckingForFullyCompactedHeap()) {
		{
			/* begin unmarkObjectsInFullyCompactedHeap */
			unmarkInitialImmobileObjectsFreeUnmarked(1);
			/* begin unmarkSurvivingObjectsForCompact */
			/* begin allPastSpaceObjectsDo: */
			/* begin allPastSpaceEntitiesDo: */
			_prevPrevObj = (_prevObj = null);
			/* begin objectStartingAt: */
			_address = ((pastSpace()).start);
			_numSlots = byteAt(_address + 7);
			_objOop2 = ((_numSlots == (numSlotsMask()))
				 ? _address + BaseHeaderSize
				 : _address);
			/* end objectStartingAt: */
			while (oopisLessThan(_objOop2, GIV(pastSpaceStart))) {
				{
					assert(isEnumerableObjectNoAssert(_objOop2));
					{
						if (((((usqInt) (longAt(_objOop2)) ) >> (markedBitFullShift())) & 1) != 0) {
							/* begin setIsMarkedOf:to: */
							assert(!(isFreeObject(_objOop2)));
							unsignedLongAtput(_objOop2, (unsignedLongAt(_objOop2)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
							/* end setIsMarkedOf:to: */
						}
					}
				}
				_prevPrevObj = _prevObj;
				_prevObj = _objOop2;
				/* begin objectAfter:limit: */
				_followingWordAddress = addressAfter(_objOop2);
				if (oopisGreaterThanOrEqualTo(_followingWordAddress, GIV(pastSpaceStart))) {
					_objOop2 = GIV(pastSpaceStart);
					goto l2;
				}
				flag("endianness");
				_followingWord = unsignedLongAt(_followingWordAddress);
				_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
					 ? _followingWordAddress + BaseHeaderSize
					 : _followingWordAddress);
				l2:
				;
				/* end objectAfter:limit: */
			}
			/* end allPastSpaceEntitiesDo: */
			/* end allPastSpaceObjectsDo: */
			/* end unmarkSurvivingObjectsForCompact */
			/* end unmarkObjectsInFullyCompactedHeap */
			return;
		}
	}
	/* begin initializeCompaction */
	/* begin checkFreeSpace: */
	assert(bitsSetInFreeSpaceMaskForAllFreeLists());
	assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
	if ((checkForLeaks & (GCModeFreeSpace | GCModeFull)) == (GCModeFreeSpace | GCModeFull)) {
		runLeakCheckerForFreeSpace(GCModeFreeSpace);
	}
	/* end checkFreeSpace: */
	/* begin selectSavedFirstFieldsSpace */
	_spaceEstimate2 = ((((getMemoryMap())->oldSpaceEnd)) - GIV(nilObj)) / 40;
	_sizeOfEden = (((eden()).limit)) - (((eden()).start));
	if (_spaceEstimate2 > _sizeOfEden) {
		{
			/* begin findHighestSuitableFreeBlock: */
			{
				_largestFreeChunk3 = findLargestFreeChunk();
				if (!(_largestFreeChunk3 == null)) {
					if (((bytesInObject(_largestFreeChunk3)) >= _spaceEstimate2) && (((usqInt) _largestFreeChunk3 ) > ((usqInt) ((((getMemoryMap())->oldSpaceEnd)) - GIV(totalFreeOldSpace)) ))) {
						_highestSuitableFreeBlock = _largestFreeChunk3;
						goto l14;
					}
				}
			}
			_highestSuitableFreeBlock = null;
			l14:
			;
			/* end findHighestSuitableFreeBlock: */
			if (!(_highestSuitableFreeBlock == null)) {
				if ((_spaceEstimate2 > ((assert(isFreeObject(_highestSuitableFreeBlock)), bytesInObject(_highestSuitableFreeBlock)))) && (useSegmentForSavedFirstFieldsSpace(_spaceEstimate2))) {
					goto l15;
				}
				if (((assert(isFreeObject(_highestSuitableFreeBlock)), bytesInObject(_highestSuitableFreeBlock))) > _sizeOfEden) {
					/* begin useFreeChunkForSavedFirstFieldsSpace: */
					assert(validFreeTreeChunk(_highestSuitableFreeBlock));
					/* begin configureSavedFirstFieldsSpaceStart:limit:isOldSpace: */
					_theStart22 = _highestSuitableFreeBlock + (4 * BytesPerOop);
					_theLimit22 = addressAfter(_highestSuitableFreeBlock);
					_limit22 = _theLimit22;
					if (GIV(savedFirstFieldSpaceMaxSlots)) {
						_limit22 = ((_limit22 < (_theStart22 + (GIV(savedFirstFieldSpaceMaxSlots) * BytesPerOop))) ? _limit22 : _theStart22 + (GIV(savedFirstFieldSpaceMaxSlots) * BytesPerOop));
					}
					{
						(GIV(savedFirstFieldsSpace).start = _theStart22);
						(GIV(savedFirstFieldsSpace).limit = _limit22);
					}
					GIV(savedFirstFieldsSpaceNotInOldSpace) = !1;
					/* end configureSavedFirstFieldsSpaceStart:limit:isOldSpace: */
					assert(!(savedFirstFieldsSpaceWasAllocated()));
					/* end useFreeChunkForSavedFirstFieldsSpace: */
					goto l15;
				}
			}
		}
		if (useSegmentForSavedFirstFieldsSpace(_spaceEstimate2)) {
			goto l15;
		}
	}
	/* begin useEdenForSavedFirstFieldsSpace */
	/* begin configureSavedFirstFieldsSpaceStart:limit:isOldSpace: */
	_theStart3 = ((eden()).start);
	_theLimit3 = ((eden()).limit);
	_limit3 = _theLimit3;
	if (GIV(savedFirstFieldSpaceMaxSlots)) {
		_limit3 = ((_limit3 < (_theStart3 + (GIV(savedFirstFieldSpaceMaxSlots) * BytesPerOop))) ? _limit3 : _theStart3 + (GIV(savedFirstFieldSpaceMaxSlots) * BytesPerOop));
	}
	{
		(GIV(savedFirstFieldsSpace).start = _theStart3);
		(GIV(savedFirstFieldsSpace).limit = _limit3);
	}
	GIV(savedFirstFieldsSpaceNotInOldSpace) = !0;
	/* end configureSavedFirstFieldsSpaceStart:limit:isOldSpace: */
	assert(!(savedFirstFieldsSpaceWasAllocated()));
	/* end useEdenForSavedFirstFieldsSpace */
	l15:
	;
	/* end selectSavedFirstFieldsSpace */
	/* begin unpinRememberedSet */
	/* begin fetchPointer:ofObject: */
	/* begin oldRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	_objOop7 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) OldRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end oldRememberedSetObj */
	GIV(firstFieldOfRememberedSet) = unsignedLongAt((_objOop7 + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	/* begin setIsPinnedOf:to: */
	/* begin oldRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	_objOop4 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) OldRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end oldRememberedSetObj */
	longAtput(_objOop4, (longAt(_objOop4)) & (~((usqIntptr_t) (1U << (pinnedBitShift())) )));
	/* end setIsPinnedOf:to: */
	/* begin fetchPointer:ofObject: */
	/* begin permToOldRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	_objOop22 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToOldRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end permToOldRememberedSetObj */
	GIV(firstFieldOfPermToOldRememberedSet) = unsignedLongAt((_objOop22 + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	/* begin setIsPinnedOf:to: */
	/* begin permToOldRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	_objOop5 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToOldRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end permToOldRememberedSetObj */
	longAtput(_objOop5, (longAt(_objOop5)) & (~((usqIntptr_t) (1U << (pinnedBitShift())) )));
	/* end setIsPinnedOf:to: */
	/* begin fetchPointer:ofObject: */
	/* begin permToNewRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	_objOop32 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToNewRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end permToNewRememberedSetObj */
	GIV(firstFieldOfPermToNewRememberedSet) = unsignedLongAt((_objOop32 + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	/* begin setIsPinnedOf:to: */
	/* begin permToNewRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	_objOop6 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToNewRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end permToNewRememberedSetObj */
	longAtput(_objOop6, (longAt(_objOop6)) & (~((usqIntptr_t) (1U << (pinnedBitShift())) )));
	/* end setIsPinnedOf:to: */
	/* end unpinRememberedSet */
	{
		/* begin prepareObjStacksForPlanningCompactor */
		{
			/* begin prepareObjStackForPlanningCompactor: */
			if (GIV(markStack) == GIV(nilObj)) {
				goto l17;
			}
			_stackOrNil = GIV(markStack);
			do {
				assert((numSlotsOfAny(_stackOrNil)) == ObjStackPageSlots);
				/* begin setHashBitsOf:to: */
				_hash = unsignedLongAt((_stackOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ));
				assert((_hash >= 0) && (_hash <= (identityHashHalfWordMask())));
				uint32AtPointerput(_stackOrNil + 4, (((uint32AtPointer(_stackOrNil + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + _hash);
				/* end setHashBitsOf:to: */
			} while (((_stackOrNil = unsignedLongAt((_stackOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) )))) != 0);
			l17:
			;
			/* end prepareObjStackForPlanningCompactor: */
			/* begin prepareObjStackForPlanningCompactor: */
			if (GIV(weaklingStack) == GIV(nilObj)) {
				goto l16;
			}
			_stackOrNil2 = GIV(weaklingStack);
			do {
				assert((numSlotsOfAny(_stackOrNil2)) == ObjStackPageSlots);
				/* begin setHashBitsOf:to: */
				_hash2 = unsignedLongAt((_stackOrNil2 + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ));
				assert((_hash2 >= 0) && (_hash2 <= (identityHashHalfWordMask())));
				uint32AtPointerput(_stackOrNil2 + 4, (((uint32AtPointer(_stackOrNil2 + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + _hash2);
				/* end setHashBitsOf:to: */
			} while (((_stackOrNil2 = unsignedLongAt((_stackOrNil2 + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) )))) != 0);
			l16:
			;
			/* end prepareObjStackForPlanningCompactor: */
			/* begin prepareObjStackForPlanningCompactor: */
			if (GIV(mournQueue) == GIV(nilObj)) {
				goto l18;
			}
			_stackOrNil3 = GIV(mournQueue);
			do {
				assert((numSlotsOfAny(_stackOrNil3)) == ObjStackPageSlots);
				/* begin setHashBitsOf:to: */
				_hash3 = unsignedLongAt((_stackOrNil3 + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ));
				assert((_hash3 >= 0) && (_hash3 <= (identityHashHalfWordMask())));
				uint32AtPointerput(_stackOrNil3 + 4, (((uint32AtPointer(_stackOrNil3 + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + _hash3);
				/* end setHashBitsOf:to: */
			} while (((_stackOrNil3 = unsignedLongAt((_stackOrNil3 + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) )))) != 0);
			l18:
			;
			/* end prepareObjStackForPlanningCompactor: */
		}
		/* end prepareObjStacksForPlanningCompactor */
		/* begin resetFreeListHeads */
		GIV(freeListsMask) = 0;
		for (_i = 0, _iLimit = 64 - 1; _i <= _iLimit; _i += 1) {
			GIV(freeLists)[_i] = 0;
		}
		/* end resetFreeListHeads */
		/* begin totalFreeOldSpace: */
		GIV(totalFreeOldSpace) = 0;
		/* end totalFreeOldSpace: */
		/* begin beginSlidingCompaction */
		GIV(gcPhaseInProgress) = SlidingCompactionInProgress;
		/* end beginSlidingCompaction */
	}
	(GIV(savedFirstFieldsSpace).top = ((GIV(savedFirstFieldsSpace).start)) - BytesPerOop);
	/* end initializeCompaction */
	_firstPass = 1;
	while (1) {
		_finalPass = planCompactSavingForwarders();
		assert((validRelocationPlanInPass(_finalPass)) == 0);
		updatePointers();
		copyAndUnmark(_firstPass);
		if (_finalPass || GIV(biasForGC)) 
			break;
		_firstPass = 0;
		reinitializeScanFrom(GIV(firstFreeObject));
		if (!(GIV(firstMobileObject) > GIV(firstFreeObject))) {
			GIV(firstFreeObject) = GIV(firstMobileObject);
			unmarkObjectsFromFirstFreeObject();
			/* begin checkFreeSpace: */
			assert(bitsSetInFreeSpaceMaskForAllFreeLists());
			assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
			if ((checkForLeaks & (GCModeFreeSpace | GCModeFull)) == (GCModeFreeSpace | GCModeFull)) {
				runLeakCheckerForFreeSpace(GCModeFreeSpace);
			}
			/* end checkFreeSpace: */
			{
				/* begin endCompaction */
				{
					/* begin unmarkSurvivingObjectsForCompact */
					/* begin allPastSpaceObjectsDo: */
					/* begin allPastSpaceEntitiesDo: */
					_prevPrevObj2 = (_prevObj2 = null);
					/* begin objectStartingAt: */
					_address2 = ((pastSpace()).start);
					_numSlots2 = byteAt(_address2 + 7);
					_objOop23 = ((_numSlots2 == (numSlotsMask()))
						 ? _address2 + BaseHeaderSize
						 : _address2);
					/* end objectStartingAt: */
					while (oopisLessThan(_objOop23, GIV(pastSpaceStart))) {
						{
							assert(isEnumerableObjectNoAssert(_objOop23));
							{
								if (((((usqInt) (longAt(_objOop23)) ) >> (markedBitFullShift())) & 1) != 0) {
									/* begin setIsMarkedOf:to: */
									assert(!(isFreeObject(_objOop23)));
									unsignedLongAtput(_objOop23, (unsignedLongAt(_objOop23)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
									/* end setIsMarkedOf:to: */
								}
							}
						}
						_prevPrevObj2 = _prevObj2;
						_prevObj2 = _objOop23;
						/* begin objectAfter:limit: */
						_followingWordAddress2 = addressAfter(_objOop23);
						if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(pastSpaceStart))) {
							_objOop23 = GIV(pastSpaceStart);
							goto l25;
						}
						flag("endianness");
						_followingWord2 = unsignedLongAt(_followingWordAddress2);
						_objOop23 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
							 ? _followingWordAddress2 + BaseHeaderSize
							 : _followingWordAddress2);
						l25:
						;
						/* end objectAfter:limit: */
					}
					/* end allPastSpaceEntitiesDo: */
					/* end allPastSpaceObjectsDo: */
					/* end unmarkSurvivingObjectsForCompact */
					/* begin endSlidingCompaction */
					GIV(gcPhaseInProgress) = 0;
					/* end endSlidingCompaction */
				}
				/* begin repinRememberedSet */
				if ((((getFromOldSpaceRememberedSet())->rememberedSetSize)) > 0) {
					/* begin storePointerUnchecked:ofObject:withValue: */
					/* begin oldRememberedSetObj */
					/* begin fetchPointer:ofObject: */
					_objOop72 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) OldRememberedSetRootIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					/* end oldRememberedSetObj */
					assert(!(isOopForwarded(_objOop72)));
					longAtput((_objOop72 + BaseHeaderSize) + (0U << (shiftForWord())), GIV(firstFieldOfRememberedSet));
					/* end storePointerUnchecked:ofObject:withValue: */
				}
				/* begin setIsPinnedOf:to: */
				/* begin oldRememberedSetObj */
				/* begin fetchPointer:ofObject: */
				_objOop42 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) OldRememberedSetRootIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				/* end oldRememberedSetObj */
				longAtput(_objOop42, (longAt(_objOop42)) | (1U << (pinnedBitShift())));
				/* end setIsPinnedOf:to: */
				/* begin relocateRememberedSet */
				/* begin getFromOldSpaceRememberedSet */
				self_in_relocateRememberedSet = GIV(fromOldSpaceRememberedSet);
				/* end getFromOldSpaceRememberedSet */
				(self_in_relocateRememberedSet->rememberedSetArray = rememberedSetArrayPointerFromObject(self_in_relocateRememberedSet, objectOop(self_in_relocateRememberedSet)));
				/* end relocateRememberedSet */
				if ((((getFromPermToOldSpaceRememberedSet())->rememberedSetSize)) > 0) {
					/* begin storePointerUnchecked:ofObject:withValue: */
					/* begin permToOldRememberedSetObj */
					/* begin fetchPointer:ofObject: */
					_objOop222 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToOldRememberedSetRootIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					/* end permToOldRememberedSetObj */
					assert(!(isOopForwarded(_objOop222)));
					longAtput((_objOop222 + BaseHeaderSize) + (0U << (shiftForWord())), GIV(firstFieldOfPermToOldRememberedSet));
					/* end storePointerUnchecked:ofObject:withValue: */
				}
				/* begin setIsPinnedOf:to: */
				/* begin permToOldRememberedSetObj */
				/* begin fetchPointer:ofObject: */
				_objOop52 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToOldRememberedSetRootIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				/* end permToOldRememberedSetObj */
				longAtput(_objOop52, (longAt(_objOop52)) | (1U << (pinnedBitShift())));
				/* end setIsPinnedOf:to: */
				/* begin relocateRememberedSet */
				/* begin getFromPermToOldSpaceRememberedSet */
				self_in_relocateRememberedSet2 = GIV(fromPermToOldSpaceRememberedSet);
				/* end getFromPermToOldSpaceRememberedSet */
				(self_in_relocateRememberedSet2->rememberedSetArray = rememberedSetArrayPointerFromObject(self_in_relocateRememberedSet2, objectOop(self_in_relocateRememberedSet2)));
				/* end relocateRememberedSet */
				if ((((getFromPermToNewSpaceRememberedSet())->rememberedSetSize)) > 0) {
					/* begin storePointerUnchecked:ofObject:withValue: */
					/* begin permToNewRememberedSetObj */
					/* begin fetchPointer:ofObject: */
					_objOop322 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToNewRememberedSetRootIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					/* end permToNewRememberedSetObj */
					assert(!(isOopForwarded(_objOop322)));
					longAtput((_objOop322 + BaseHeaderSize) + (0U << (shiftForWord())), GIV(firstFieldOfPermToNewRememberedSet));
					/* end storePointerUnchecked:ofObject:withValue: */
				}
				/* begin setIsPinnedOf:to: */
				/* begin permToNewRememberedSetObj */
				/* begin fetchPointer:ofObject: */
				_objOop62 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToNewRememberedSetRootIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				/* end permToNewRememberedSetObj */
				longAtput(_objOop62, (longAt(_objOop62)) | (1U << (pinnedBitShift())));
				/* end setIsPinnedOf:to: */
				/* begin relocateRememberedSet */
				/* begin getFromPermToNewSpaceRememberedSet */
				self_in_relocateRememberedSet3 = GIV(fromPermToNewSpaceRememberedSet);
				/* end getFromPermToNewSpaceRememberedSet */
				(self_in_relocateRememberedSet3->rememberedSetArray = rememberedSetArrayPointerFromObject(self_in_relocateRememberedSet3, objectOop(self_in_relocateRememberedSet3)));
				/* end relocateRememberedSet */
				/* end repinRememberedSet */
				/* begin releaseSavedFirstFieldsSpace */
				if (GIV(savedFirstFieldsSpaceNotInOldSpace) && (oopisGreaterThan((GIV(savedFirstFieldsSpace).start), GIV(nilObj)))) {
					sqDeallocateMemorySegmentAtOfSize(((void *) ((GIV(savedFirstFieldsSpace).start)) ), ((GIV(savedFirstFieldsSpace).limit)) - ((GIV(savedFirstFieldsSpace).start)));
				}
				/* end releaseSavedFirstFieldsSpace */
				/* end endCompaction */
				return;
			}
		}
		/* begin updateSavedFirstFieldsSpaceIfNecessary */
		if ((!GIV(savedFirstFieldsSpaceNotInOldSpace) && (oopisGreaterThan((GIV(savedFirstFieldsSpace).start), GIV(nilObj)))) && (((GIV(savedFirstFieldsSpace).start)) < GIV(lastMobileObject))) {
			{
				/* begin findHighestSuitableFreeBlock: */
				_spaceEstimate = ((GIV(savedFirstFieldsSpace).limit)) - ((GIV(savedFirstFieldsSpace).start));
				{
					_largestFreeChunk2 = findLargestFreeChunk();
					if (!(_largestFreeChunk2 == null)) {
						if (((bytesInObject(_largestFreeChunk2)) >= _spaceEstimate) && (((usqInt) _largestFreeChunk2 ) > ((usqInt) ((((getMemoryMap())->oldSpaceEnd)) - GIV(totalFreeOldSpace)) ))) {
							_largestFreeChunk = _largestFreeChunk2;
							goto l4;
						}
					}
				}
				_largestFreeChunk = null;
				l4:
				;
				/* end findHighestSuitableFreeBlock: */
				if (_largestFreeChunk == null) {
					/* begin useEdenForSavedFirstFieldsSpace */
					/* begin configureSavedFirstFieldsSpaceStart:limit:isOldSpace: */
					_theStart = ((eden()).start);
					_theLimit = ((eden()).limit);
					_limit = _theLimit;
					if (GIV(savedFirstFieldSpaceMaxSlots)) {
						_limit = ((_limit < (_theStart + (GIV(savedFirstFieldSpaceMaxSlots) * BytesPerOop))) ? _limit : _theStart + (GIV(savedFirstFieldSpaceMaxSlots) * BytesPerOop));
					}
					{
						(GIV(savedFirstFieldsSpace).start = _theStart);
						(GIV(savedFirstFieldsSpace).limit = _limit);
					}
					GIV(savedFirstFieldsSpaceNotInOldSpace) = !0;
					/* end configureSavedFirstFieldsSpaceStart:limit:isOldSpace: */
					assert(!(savedFirstFieldsSpaceWasAllocated()));
					/* end useEdenForSavedFirstFieldsSpace */
				} else {
					/* begin useFreeChunkForSavedFirstFieldsSpace: */
					assert(validFreeTreeChunk(_largestFreeChunk));
					/* begin configureSavedFirstFieldsSpaceStart:limit:isOldSpace: */
					_theStart2 = _largestFreeChunk + (4 * BytesPerOop);
					_theLimit2 = addressAfter(_largestFreeChunk);
					_limit2 = _theLimit2;
					if (GIV(savedFirstFieldSpaceMaxSlots)) {
						_limit2 = ((_limit2 < (_theStart2 + (GIV(savedFirstFieldSpaceMaxSlots) * BytesPerOop))) ? _limit2 : _theStart2 + (GIV(savedFirstFieldSpaceMaxSlots) * BytesPerOop));
					}
					{
						(GIV(savedFirstFieldsSpace).start = _theStart2);
						(GIV(savedFirstFieldsSpace).limit = _limit2);
					}
					GIV(savedFirstFieldsSpaceNotInOldSpace) = !1;
					/* end configureSavedFirstFieldsSpaceStart:limit:isOldSpace: */
					assert(!(savedFirstFieldsSpaceWasAllocated()));
					/* end useFreeChunkForSavedFirstFieldsSpace: */
				}
			}
		}
		(GIV(savedFirstFieldsSpace).top = ((GIV(savedFirstFieldsSpace).start)) - BytesPerOop);
		/* end updateSavedFirstFieldsSpaceIfNecessary */
	}
	/* begin checkFreeSpace: */
	assert(bitsSetInFreeSpaceMaskForAllFreeLists());
	assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
	if ((checkForLeaks & (GCModeFreeSpace | GCModeFull)) == (GCModeFreeSpace | GCModeFull)) {
		runLeakCheckerForFreeSpace(GCModeFreeSpace);
	}
	/* end checkFreeSpace: */
	/* begin endCompaction */
	{
		/* begin unmarkSurvivingObjectsForCompact */
		/* begin allPastSpaceObjectsDo: */
		/* begin allPastSpaceEntitiesDo: */
		_prevPrevObj3 = (_prevObj3 = null);
		/* begin objectStartingAt: */
		_address3 = ((pastSpace()).start);
		_numSlots3 = byteAt(_address3 + 7);
		_objOop24 = ((_numSlots3 == (numSlotsMask()))
			 ? _address3 + BaseHeaderSize
			 : _address3);
		/* end objectStartingAt: */
		while (oopisLessThan(_objOop24, GIV(pastSpaceStart))) {
			{
				assert(isEnumerableObjectNoAssert(_objOop24));
				{
					if (((((usqInt) (longAt(_objOop24)) ) >> (markedBitFullShift())) & 1) != 0) {
						/* begin setIsMarkedOf:to: */
						assert(!(isFreeObject(_objOop24)));
						unsignedLongAtput(_objOop24, (unsignedLongAt(_objOop24)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
						/* end setIsMarkedOf:to: */
					}
				}
			}
			_prevPrevObj3 = _prevObj3;
			_prevObj3 = _objOop24;
			/* begin objectAfter:limit: */
			_followingWordAddress3 = addressAfter(_objOop24);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(pastSpaceStart))) {
				_objOop24 = GIV(pastSpaceStart);
				goto l39;
			}
			flag("endianness");
			_followingWord3 = unsignedLongAt(_followingWordAddress3);
			_objOop24 = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress3 + BaseHeaderSize
				 : _followingWordAddress3);
			l39:
			;
			/* end objectAfter:limit: */
		}
		/* end allPastSpaceEntitiesDo: */
		/* end allPastSpaceObjectsDo: */
		/* end unmarkSurvivingObjectsForCompact */
		/* begin endSlidingCompaction */
		GIV(gcPhaseInProgress) = 0;
		/* end endSlidingCompaction */
	}
	/* begin repinRememberedSet */
	if ((((getFromOldSpaceRememberedSet())->rememberedSetSize)) > 0) {
		/* begin storePointerUnchecked:ofObject:withValue: */
		/* begin oldRememberedSetObj */
		/* begin fetchPointer:ofObject: */
		_objOop73 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) OldRememberedSetRootIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end oldRememberedSetObj */
		assert(!(isOopForwarded(_objOop73)));
		longAtput((_objOop73 + BaseHeaderSize) + (0U << (shiftForWord())), GIV(firstFieldOfRememberedSet));
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	/* begin setIsPinnedOf:to: */
	/* begin oldRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	_objOop43 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) OldRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end oldRememberedSetObj */
	longAtput(_objOop43, (longAt(_objOop43)) | (1U << (pinnedBitShift())));
	/* end setIsPinnedOf:to: */
	/* begin relocateRememberedSet */
	/* begin getFromOldSpaceRememberedSet */
	self_in_relocateRememberedSet4 = GIV(fromOldSpaceRememberedSet);
	/* end getFromOldSpaceRememberedSet */
	(self_in_relocateRememberedSet4->rememberedSetArray = rememberedSetArrayPointerFromObject(self_in_relocateRememberedSet4, objectOop(self_in_relocateRememberedSet4)));
	/* end relocateRememberedSet */
	if ((((getFromPermToOldSpaceRememberedSet())->rememberedSetSize)) > 0) {
		/* begin storePointerUnchecked:ofObject:withValue: */
		/* begin permToOldRememberedSetObj */
		/* begin fetchPointer:ofObject: */
		_objOop223 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToOldRememberedSetRootIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end permToOldRememberedSetObj */
		assert(!(isOopForwarded(_objOop223)));
		longAtput((_objOop223 + BaseHeaderSize) + (0U << (shiftForWord())), GIV(firstFieldOfPermToOldRememberedSet));
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	/* begin setIsPinnedOf:to: */
	/* begin permToOldRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	_objOop53 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToOldRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end permToOldRememberedSetObj */
	longAtput(_objOop53, (longAt(_objOop53)) | (1U << (pinnedBitShift())));
	/* end setIsPinnedOf:to: */
	/* begin relocateRememberedSet */
	/* begin getFromPermToOldSpaceRememberedSet */
	self_in_relocateRememberedSet22 = GIV(fromPermToOldSpaceRememberedSet);
	/* end getFromPermToOldSpaceRememberedSet */
	(self_in_relocateRememberedSet22->rememberedSetArray = rememberedSetArrayPointerFromObject(self_in_relocateRememberedSet22, objectOop(self_in_relocateRememberedSet22)));
	/* end relocateRememberedSet */
	if ((((getFromPermToNewSpaceRememberedSet())->rememberedSetSize)) > 0) {
		/* begin storePointerUnchecked:ofObject:withValue: */
		/* begin permToNewRememberedSetObj */
		/* begin fetchPointer:ofObject: */
		_objOop323 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToNewRememberedSetRootIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end permToNewRememberedSetObj */
		assert(!(isOopForwarded(_objOop323)));
		longAtput((_objOop323 + BaseHeaderSize) + (0U << (shiftForWord())), GIV(firstFieldOfPermToNewRememberedSet));
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	/* begin setIsPinnedOf:to: */
	/* begin permToNewRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	_objOop63 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToNewRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end permToNewRememberedSetObj */
	longAtput(_objOop63, (longAt(_objOop63)) | (1U << (pinnedBitShift())));
	/* end setIsPinnedOf:to: */
	/* begin relocateRememberedSet */
	/* begin getFromPermToNewSpaceRememberedSet */
	self_in_relocateRememberedSet32 = GIV(fromPermToNewSpaceRememberedSet);
	/* end getFromPermToNewSpaceRememberedSet */
	(self_in_relocateRememberedSet32->rememberedSetArray = rememberedSetArrayPointerFromObject(self_in_relocateRememberedSet32, objectOop(self_in_relocateRememberedSet32)));
	/* end relocateRememberedSet */
	/* end repinRememberedSet */
	/* begin releaseSavedFirstFieldsSpace */
	if (GIV(savedFirstFieldsSpaceNotInOldSpace) && (oopisGreaterThan((GIV(savedFirstFieldsSpace).start), GIV(nilObj)))) {
		sqDeallocateMemorySegmentAtOfSize(((void *) ((GIV(savedFirstFieldsSpace).start)) ), ((GIV(savedFirstFieldsSpace).limit)) - ((GIV(savedFirstFieldsSpace).start)));
	}
	/* end releaseSavedFirstFieldsSpace */
	/* end endCompaction */
}
/*	Sweep the mobile portion of the heap, moving objects to their eventual 
	locations, and clearing their marked bits. 
	Remember to update the savedFirstFields of pointer objects, as these have 
	been forwarded. 
	Answer if the end of the heap was reached (savedFirstFieldsSpace has not 
	overflowed).  
	The enumerations in planCompactSavingForwarders, 
	updatePointersInMobileObjects and copyAndUnmarkMobileObjects 
	match. We could implement them as a single enumeration method taking 
	several block arguments, but arguably that 
	would make understanding an already tricky algorithm more difficult. 
	Instead we tolerate the duplication and encourage 
	the reader to diff the three methods to see where they diverge (e.g. via 
	Cmd-shift-C).  */
/* SpurPlanningCompactor>>#copyAndUnmarkMobileObjects */
static sqInt NeverInline
copyAndUnmarkMobileObjects(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _availableSpace;
	usqInt _bytes;
	sqInt _destObj;
	sqInt _finalObject;
	sqInt _firstField;
	sqInt _followingWord;
	usqInt _followingWordAddress;
	usqInt _limit;
	sqInt _limit2;
	usqInt _next;
	usqInt _nextBytes;
	sqInt _nextObj;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots3;
	usqInt _obj;
	usqInt _objBytes;
	sqInt _objOop;
	usqInt _previousPin;
	sqInt _prevObj;
	sqInt _prevPrevObj;
	usqInt _start;
	usqInt _startOfPreviousPin;
	usqInt _toFinger;
	usqInt _top;

	_previousPin = 0;
	assert(!(isMarked(GIV(firstFreeObject))));
	/* begin startOfObject: */
	_toFinger = (((byteAt(GIV(firstFreeObject) + 7)) == (numSlotsMask()))
		 ? GIV(firstFreeObject) - BaseHeaderSize
		 : GIV(firstFreeObject));
	/* end startOfObject: */
	_top = (GIV(savedFirstFieldsSpace).start);
	_startOfPreviousPin = 0;
	/* begin allOldSpaceEntitiesForCompactingFrom:to:do: */
	_finalObject = ((!GIV(lastMobileObject))
		 ? GIV(nilObj)
		 : GIV(lastMobileObject));
	assert(isOldObject(GIV(memoryMap), GIV(firstFreeObject)));
	assert(oopisLessThanOrEqualTo(_finalObject, (GIV(memoryMap)->oldSpaceEnd)));
	_prevPrevObj = (_prevObj = null);
	_objOop = GIV(firstFreeObject);
	_limit = ((oopisLessThan(_finalObject, (GIV(memoryMap)->oldSpaceEnd)))
		 ? addressAfter(_finalObject)
		 : (GIV(memoryMap)->oldSpaceEnd));
	while (1) {
		assert((_objOop % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop, _limit))) 
			break;
		assert((long64At(_objOop)) != 0);
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit2)) {
			_nextObj = _limit2;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_nextObj = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
		{
			assert(((_previousPin == null)
				 ? _toFinger <= (startOfObject(_objOop))
				 : (isMarked(_previousPin)) && (_toFinger <= _startOfPreviousPin)));
			assert(GIV(savedFirstFieldsSpaceNotInOldSpace) || (_toFinger < _top));
			if (((((usqInt) (longAt(_objOop)) ) >> (markedBitFullShift())) & 1) != 0) {
				if (((((usqInt) (longAt(_objOop)) ) >> (pinnedBitShift())) & 1) != 0) {
					if (!_previousPin) {
						_previousPin = _objOop;
						/* begin startOfObject: */
						_startOfPreviousPin = (((byteAt(_objOop + 7)) == (numSlotsMask()))
							 ? _objOop - BaseHeaderSize
							 : _objOop);
						/* end startOfObject: */
					}
				} else {
					_bytes = bytesInObject(_objOop);
					while ((_toFinger <= _startOfPreviousPin) && ((_bytes != ((_availableSpace = _startOfPreviousPin - _toFinger))) && ((_bytes + (2 * 8)) > _availableSpace))) {
						if (_availableSpace > 0) {
							/* begin addFreeChunkWithBytes:at: */
							GIV(totalFreeOldSpace) += _availableSpace;
							freeChunkWithBytesat(_availableSpace, _toFinger);
							/* end addFreeChunkWithBytes:at: */
						}
						do {
							assert((isMarked(_previousPin)) && (isPinned(_previousPin)));
							/* begin unmarkPinned: */
							if (!(((longAt(_previousPin)) & (classIndexMask())) == (segmentBridgePun()))) {
								/* begin setIsMarkedOf:to: */
								assert(!(isFreeObject(_previousPin)));
								unsignedLongAtput(_previousPin, (unsignedLongAt(_previousPin)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
								/* end setIsMarkedOf:to: */
								/* begin notePinned: */
								assert(isPinned(_previousPin));
								if (((longAt(_previousPin)) & (classIndexMask())) == (segmentBridgePun())) {
									/* begin setIsMarkedOf:to: */
									assert(!(isFreeObject(_previousPin)));
									unsignedLongAtput(_previousPin, (unsignedLongAt(_previousPin)) | (1ULL << (markedBitFullShift())));
									/* end setIsMarkedOf:to: */
								} else {
									while (oopisLessThan((((GIV(segments)[GIV(sweepIndex)]).segSize)) + (((GIV(segments)[GIV(sweepIndex)]).segStart)), _previousPin)) {
										GIV(sweepIndex) += 1;
									}
									((GIV(segments)[GIV(sweepIndex)]).containsPinned = 1);
								}
								/* end notePinned: */
							}
							/* end unmarkPinned: */
							_toFinger = addressAfter(_previousPin);
							/* begin objectStartingAt: */
							_numSlots = byteAt(_toFinger + 7);
							_previousPin = ((_numSlots == (numSlotsMask()))
								 ? _toFinger + BaseHeaderSize
								 : _toFinger);
							/* end objectStartingAt: */
						} while ((((((usqInt) (longAt(_previousPin)) ) >> (markedBitFullShift())) & 1) != 0) && ((((((usqInt) (longAt(_previousPin)) ) >> (pinnedBitShift())) & 1) != 0) && (_previousPin < _objOop)));
						while (!((_previousPin >= _objOop) || ((((((usqInt) (longAt(_previousPin)) ) >> (markedBitFullShift())) & 1) != 0) && (((((usqInt) (longAt(_previousPin)) ) >> (pinnedBitShift())) & 1) != 0)))) {
							_previousPin = oldSpaceObjectAfter(_previousPin);
						}
						if (_previousPin >= _objOop) {
							_previousPin = null;
							_startOfPreviousPin = 0;
						} else {
							/* begin startOfObject: */
							_startOfPreviousPin = (((byteAt(_previousPin + 7)) == (numSlotsMask()))
								 ? _previousPin - BaseHeaderSize
								 : _previousPin);
							/* end startOfObject: */
						}
					}
					/* begin copyAndUnmarkObject:to:bytes:firstField: */
					_firstField = unsignedLongAt(_top);
					/* begin setIsMarkedOf:to: */
					assert(!(isFreeObject(_objOop)));
					unsignedLongAtput(_objOop, (unsignedLongAt(_objOop)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
					/* end setIsMarkedOf:to: */
					/* begin rawNumSlotsOf: */
					_numSlots2 = byteAt(_objOop + 7);
					/* end rawNumSlotsOf: */
					_destObj = ((_numSlots2 == (numSlotsMask()))
						 ? _toFinger + BaseHeaderSize
						 : _toFinger);
					/* begin startOfObject:given: */
					_start = ((_numSlots2 == (numSlotsMask()))
						 ? _objOop - BaseHeaderSize
						 : _objOop);
					/* end startOfObject:given: */
					{
						memmove(((void *) _toFinger ), ((void *) _start ), _bytes);
						/* begin storePointerUnchecked:ofObject:withValue: */
						assert(!(isOopForwarded(_destObj)));
						longAtput((_destObj + BaseHeaderSize) + (0U << (shiftForWord())), _firstField);
						/* end storePointerUnchecked:ofObject:withValue: */
					}
					/* end copyAndUnmarkObject:to:bytes:firstField: */
					_toFinger += _bytes;
					if (((_top += BytesPerOop)) >= ((GIV(savedFirstFieldsSpace).limit))) {
						assert(((GIV(savedFirstFieldsSpace).top)) == (_top - BytesPerOop));
						assert(_nextObj == GIV(objectAfterLastMobileObject));
						if (!_previousPin) {
							_previousPin = _nextObj;
							/* begin startOfObject: */
							_startOfPreviousPin = (((byteAt(_nextObj + 7)) == (numSlotsMask()))
								 ? _nextObj - BaseHeaderSize
								 : _nextObj);
							/* end startOfObject: */
						}
						if (_toFinger < _startOfPreviousPin) {
							GIV(firstFreeObject) = initFreeChunkWithBytesat(_startOfPreviousPin - _toFinger, _toFinger);
						} else {
							GIV(firstFreeObject) = _previousPin;
						}
						return 0;
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		_objOop = _nextObj;
	}
	/* end allOldSpaceEntitiesForCompactingFrom:to:do: */
	freeFromupTonextObject(_toFinger, ((getMemoryMap())->oldSpaceEnd), ((!_previousPin)
		 ? ((!GIV(objectAfterLastMobileObject))
			 ? objectAfter(GIV(firstFreeObject))
			 : GIV(objectAfterLastMobileObject))
		 : _previousPin));
	/* begin coalesceFrom: */
	if (_toFinger >= (((getMemoryMap())->oldSpaceEnd))) {
		goto l13;
	}
	/* begin objectStartingAt: */
	_numSlots3 = byteAt(_toFinger + 7);
	_obj = ((_numSlots3 == (numSlotsMask()))
		 ? _toFinger + BaseHeaderSize
		 : _toFinger);
	/* end objectStartingAt: */
	while (1) {
		_next = oldSpaceObjectAfter(_obj);
		if (!(_next < (((getMemoryMap())->oldSpaceEnd)))) 
			break;
		if ((((longAt(_obj)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) && (((longAt(_next)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			_objBytes = bytesInObject(_obj);
			_nextBytes = bytesInObject(_next);
			unlinkFreeChunkchunkBytes(_obj, _objBytes);
			unlinkFreeChunkchunkBytes(_next, _nextBytes);
			_obj = freeChunkWithBytesat(_objBytes + _nextBytes, (((byteAt(_obj + 7)) == (numSlotsMask()))
				 ? _obj - BaseHeaderSize
				 : _obj));
		} else {
			_obj = _next;
		}
	}
	l13:
	;
	/* end coalesceFrom: */
	return 1;
}
/*	Sweep the heap, unmarking all objects and moving mobile objects to their 
	correct positions, 
	restoring their savedFirstFields. */
/* SpurPlanningCompactor>>#copyAndUnmark: */
static void NoDbgRegParms NeverInline
copyAndUnmark(sqInt _firstPass)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _finalPass;

	/* begin logPhase: */
	/* end logPhase: */
	if (_firstPass) {
		/* begin unmarkInitialImmobileObjects */
		unmarkInitialImmobileObjectsFreeUnmarked(0);
		/* end unmarkInitialImmobileObjects */
	}
	_finalPass = copyAndUnmarkMobileObjects();
	if ((GIV(lastMobileObject) != null) && (!_finalPass && GIV(biasForGC))) {
		unmarkObjectsFromFirstFreeObject();
	}
}
/*	Free from toFinger up to limit, dealing with possible intervening pinned 
	objects.  */
/* SpurPlanningCompactor>>#freeFrom:upTo:nextObject: */
static void NoDbgRegParms
freeFromupTonextObject(usqInt _initialToFinger, usqInt _limit, sqInt _nextObject)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _numSlots;
	sqInt _obj;
	usqInt _objStart;
	usqInt _toFinger;

	_toFinger = _initialToFinger;
	/* begin startOfObject: */
	_objStart = (((byteAt(_nextObject + 7)) == (numSlotsMask()))
		 ? _nextObject - BaseHeaderSize
		 : _nextObject);
	/* end startOfObject: */
	if (_toFinger < _objStart) {
		/* begin addFreeChunkWithBytes:at: */
		GIV(totalFreeOldSpace) += _objStart - _toFinger;
		freeChunkWithBytesat(_objStart - _toFinger, _toFinger);
		/* end addFreeChunkWithBytes:at: */
	}
	_toFinger = _objStart;
	while (_objStart < _limit) {
		/* begin objectStartingAt: */
		_numSlots = byteAt(_objStart + 7);
		_obj = ((_numSlots == (numSlotsMask()))
			 ? _objStart + BaseHeaderSize
			 : _objStart);
		/* end objectStartingAt: */
		if ((((((usqInt) (longAt(_obj)) ) >> (markedBitFullShift())) & 1) != 0) && (((((usqInt) (longAt(_obj)) ) >> (pinnedBitShift())) & 1) != 0)) {
			/* begin unmarkPinned: */
			if (!(((longAt(_obj)) & (classIndexMask())) == (segmentBridgePun()))) {
				/* begin setIsMarkedOf:to: */
				assert(!(isFreeObject(_obj)));
				unsignedLongAtput(_obj, (unsignedLongAt(_obj)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
				/* end setIsMarkedOf:to: */
				/* begin notePinned: */
				assert(isPinned(_obj));
				if (((longAt(_obj)) & (classIndexMask())) == (segmentBridgePun())) {
					/* begin setIsMarkedOf:to: */
					assert(!(isFreeObject(_obj)));
					unsignedLongAtput(_obj, (unsignedLongAt(_obj)) | (1ULL << (markedBitFullShift())));
					/* end setIsMarkedOf:to: */
				} else {
					while (oopisLessThan((((GIV(segments)[GIV(sweepIndex)]).segSize)) + (((GIV(segments)[GIV(sweepIndex)]).segStart)), _obj)) {
						GIV(sweepIndex) += 1;
					}
					((GIV(segments)[GIV(sweepIndex)]).containsPinned = 1);
				}
				/* end notePinned: */
			}
			/* end unmarkPinned: */
			if (_toFinger < _objStart) {
				/* begin addFreeChunkWithBytes:at: */
				GIV(totalFreeOldSpace) += _objStart - _toFinger;
				freeChunkWithBytesat(_objStart - _toFinger, _toFinger);
				/* end addFreeChunkWithBytes:at: */
			}
			_toFinger = (_objStart = addressAfter(_obj));
		} else {
			_objStart = addressAfter(_obj);
		}
	}
	if (_limit > _toFinger) {
		/* begin addFreeChunkWithBytes:at: */
		GIV(totalFreeOldSpace) += _limit - _toFinger;
		freeChunkWithBytesat(_limit - _toFinger, _toFinger);
		/* end addFreeChunkWithBytes:at: */
	}
}
/*	Return if the heap is fully compacted. 
	That is, if there are no marked objects after some free chunk. 
	 
	The downside of this definition, is that a heap that has a sequence of 
	objects: - marked object 
	- unmarked object 
	- free space 
	- end of the heap 
	 
	Is considered compacted, and thus the unmarked object will not be 
	coallesced with the free space in this passScan for firstFreeObject and firstMobileObject from the start of memory. 
	Answer if the heap is already fully compacted. */
/* SpurPlanningCompactor>>#initializeScanCheckingForFullyCompactedHeap */
static sqInt
initializeScanCheckingForFullyCompactedHeap(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	GIV(firstMobileObject) = (GIV(lastMobileObject) = (GIV(objectAfterLastMobileObject) = null));
	reinitializeScanFrom(GIV(hiddenRootsObj));
	if (!GIV(firstFreeObject)) {
		error("uncompactable heap; no unmarked objects found");
	}
	return GIV(firstMobileObject) >= (((getMemoryMap())->oldSpaceEnd));
}
/* SpurPlanningCompactor>>#isMobile: */
static sqInt NoDbgRegParms
isMobile(sqInt _obj)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return (oopisGreaterThanOrEqualToandLessThanOrEqualTo(_obj, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_obj)) ) >> (pinnedBitShift())) & 1) != 0));
}
/*	For asserts */
/* SpurPlanningCompactor>>#isPostMobile: */
static sqInt NoDbgRegParms
isPostMobile(sqInt _obj)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return oopisGreaterThanOrEqualToandLessThanOrEqualTo(_obj, GIV(mobileStart), GIV(lastMobileObject));
}
/*	Sweep the heap from firstFreeObject forwarding marked objects to where 
	they can be moved to, saving their forwarding pointer in 
	savedFirstFieldsSpace. Continue until either the end of the heap is 
	reached or savedFirstFieldsSpace is full. 
	Answer if the end of the heap was reached (savedFirstFieldsSpace has not 
	overflowed).  
	The enumerations in planCompactSavingForwarders, 
	updatePointersInMobileObjects and copyAndUnmarkMobileObjects 
	match. We could implement them as a single enumeration method taking 
	several block arguments, but arguably that 
	would make understanding an already tricky algorithm more difficult. 
	Instead we tolerate the duplication and encourage 
	the reader to diff the three methods to see where they diverge (e.g. via 
	Cmd-shift-C).  */
/* SpurPlanningCompactor>>#planCompactSavingForwarders */
static sqInt NeverInline
planCompactSavingForwarders(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _availableSpace;
	usqInt _bytes;
	sqInt _followingWord;
	usqInt _followingWordAddress;
	sqInt _limit;
	usqInt _numSlots;
	sqInt _objOop;
	usqInt _previousPin;
	sqInt _prevObj;
	sqInt _prevPrevObj;
	usqInt _startOfPreviousPin;
	usqInt _toFinger;
	usqInt _top;
	sqInt _valuePointer;

	_previousPin = 0;
	{
		(GIV(savedFirstFieldsSpace).top);
		(GIV(savedFirstFieldsSpace).start);
	}
	assert(!(isMarked(GIV(firstFreeObject))));
	/* begin startOfObject: */
	_toFinger = (((byteAt(GIV(firstFreeObject) + 7)) == (numSlotsMask()))
		 ? GIV(firstFreeObject) - BaseHeaderSize
		 : GIV(firstFreeObject));
	/* end startOfObject: */
	_top = (GIV(savedFirstFieldsSpace).start);
	_startOfPreviousPin = 0;
	GIV(lastMobileObject) = null;
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(firstFreeObject)));
	_prevPrevObj = (_prevObj = null);
	_objOop = GIV(firstFreeObject);
	while (1) {
		assert((_objOop % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop)) != 0);
		{
			assert(((_previousPin == null)
				 ? _toFinger <= (startOfObject(_objOop))
				 : (isMarked(_previousPin)) && (_toFinger <= _startOfPreviousPin)));
			assert(GIV(savedFirstFieldsSpaceNotInOldSpace) || (_toFinger < _top));
			if (((((usqInt) (longAt(_objOop)) ) >> (markedBitFullShift())) & 1) != 0) {
				if (((((usqInt) (longAt(_objOop)) ) >> (pinnedBitShift())) & 1) != 0) {
					if (!_previousPin) {
						_previousPin = _objOop;
						/* begin startOfObject: */
						_startOfPreviousPin = (((byteAt(_objOop + 7)) == (numSlotsMask()))
							 ? _objOop - BaseHeaderSize
							 : _objOop);
						/* end startOfObject: */
					}
				} else {
					_bytes = bytesInObject(_objOop);
					while ((_toFinger <= _startOfPreviousPin) && ((_bytes != ((_availableSpace = _startOfPreviousPin - _toFinger))) && ((_bytes + (2 * 8)) > _availableSpace))) {
						do {
							_toFinger = addressAfter(_previousPin);
							/* begin objectStartingAt: */
							_numSlots = byteAt(_toFinger + 7);
							_previousPin = ((_numSlots == (numSlotsMask()))
								 ? _toFinger + BaseHeaderSize
								 : _toFinger);
							/* end objectStartingAt: */
						} while ((((((usqInt) (longAt(_previousPin)) ) >> (markedBitFullShift())) & 1) != 0) && ((((((usqInt) (longAt(_previousPin)) ) >> (pinnedBitShift())) & 1) != 0) && (_previousPin < _objOop)));
						while (!((_previousPin >= _objOop) || ((((((usqInt) (longAt(_previousPin)) ) >> (markedBitFullShift())) & 1) != 0) && (((((usqInt) (longAt(_previousPin)) ) >> (pinnedBitShift())) & 1) != 0)))) {
							_previousPin = oldSpaceObjectAfter(_previousPin);
						}
						if (_previousPin >= _objOop) {
							_previousPin = null;
							_startOfPreviousPin = 0;
						} else {
							/* begin startOfObject: */
							_startOfPreviousPin = (((byteAt(_previousPin + 7)) == (numSlotsMask()))
								 ? _previousPin - BaseHeaderSize
								 : _previousPin);
							/* end startOfObject: */
						}
					}
					/* begin forwardMobileObject:to:savedFirstFieldPtr: */
					GIV(lastMobileObject) = _objOop;
					{
						longAtput(_top, unsignedLongAt((_objOop + BaseHeaderSize) + (0U << (shiftForWord()))));
						/* begin storePointerUnchecked:ofObject:withValue: */
						_valuePointer = (((byteAt(_objOop + 7)) == (numSlotsMask()))
							 ? _toFinger + BaseHeaderSize
							 : _toFinger);
						assert(!(isOopForwarded(_objOop)));
						longAtput((_objOop + BaseHeaderSize) + (0U << (shiftForWord())), _valuePointer);
						/* end storePointerUnchecked:ofObject:withValue: */
					}
					/* end forwardMobileObject:to:savedFirstFieldPtr: */
					_toFinger += _bytes;
					if (((_top += BytesPerOop)) >= ((GIV(savedFirstFieldsSpace).limit))) {
						(GIV(savedFirstFieldsSpace).top = _top - BytesPerOop);
						GIV(objectAfterLastMobileObject) = oldSpaceObjectAfter(GIV(lastMobileObject));
						return 0;
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_limit = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop = _limit;
			goto l7;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	if (GIV(lastMobileObject)) {
		(GIV(savedFirstFieldsSpace).top = _top - BytesPerOop);
		GIV(objectAfterLastMobileObject) = oldSpaceObjectAfter(GIV(lastMobileObject));
	}
	return 1;
}
/*	Search for firstFreeObject and firstMobileObject from initialObject, which 
	is the 
	hiddenRootsObject on the first pass, and the objectAfterLastMobileObject 
	on subsequent passes). */
/* SpurPlanningCompactor>>#reinitializeScanFrom: */
static void NoDbgRegParms
reinitializeScanFrom(sqInt _initialObject)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _followingWord;
	usqInt _followingWordAddress;
	sqInt _limit;
	sqInt _objOop;
	sqInt _prevObj;
	sqInt _prevPrevObj;

	GIV(firstMobileObject) = ((getMemoryMap())->oldSpaceEnd);
	GIV(firstFreeObject) = scanForFirstFreeAndFirstMobileObjectFrom(_initialObject);
	if (GIV(firstFreeObject)) {
		/* begin startOfObject: */
		GIV(mobileStart) = ((usqInt) ((((byteAt(GIV(firstFreeObject) + 7)) == (numSlotsMask()))
			 ? GIV(firstFreeObject) - BaseHeaderSize
			 : GIV(firstFreeObject))) );
		/* end startOfObject: */
	}
	if (GIV(objectAfterLastMobileObject)) {
		/* begin allOldSpaceEntitiesFrom:to:do: */
		assert((isNonImmediate(GIV(firstFreeObject))) && (isInSegments(GIV(firstFreeObject))));
		assert((isNonImmediate(GIV(objectAfterLastMobileObject))) && (isInSegments(GIV(objectAfterLastMobileObject))));
		_prevPrevObj = (_prevObj = null);
		_objOop = GIV(firstFreeObject);
		while (1) {
			assert((_objOop % (allocationUnit())) == 0);
			if (!(oopisLessThanOrEqualTo(_objOop, GIV(objectAfterLastMobileObject)))) 
				break;
			assert((long64At(_objOop)) != 0);
			{
				if (!((((((usqInt) (longAt(_objOop)) ) >> (pinnedBitShift())) & 1) != 0) || ((!(((((usqInt) (longAt(_objOop)) ) >> (markedBitFullShift())) & 1) != 0)) || (GIV(objectAfterLastMobileObject) == _objOop)))) {
					/* begin setIsMarkedOf:to: */
					assert(!(isFreeObject(_objOop)));
					unsignedLongAtput(_objOop, (unsignedLongAt(_objOop)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
					/* end setIsMarkedOf:to: */
				}
			}
			_prevPrevObj = _prevObj;
			_prevObj = _objOop;
			/* begin objectAfter:limit: */
			_limit = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			_followingWordAddress = addressAfter(_objOop);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
				_objOop = _limit;
				goto l3;
			}
			flag("endianness");
			_followingWord = unsignedLongAt(_followingWordAddress);
			_objOop = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress + BaseHeaderSize
				 : _followingWordAddress);
			l3:
			;
			/* end objectAfter:limit: */
		}
		/* end allOldSpaceEntitiesFrom:to:do: */
		GIV(firstMobileObject) = GIV(objectAfterLastMobileObject);
	}
}
/*	Scavenge or simply follow objOop. Answer the new location of objOop. 
	The send should have been guarded by a send of shouldRemapOop:. 
	The method is called remapObj: for compatibility with ObjectMemory. */
/* SpurPlanningCompactor>>#remapObj: */
sqInt
remapObj(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _referent;
	sqInt _resolvedObj;

	/* begin slidingCompactionRemapObj: */
	assert(shouldRemapOop(_objOop));
	if (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(_objOop));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_objOop + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		_resolvedObj = _referent;
		/* end followForwarded: */
	} else {
		assert(!(isInFutureSpace(_objOop)));
		_resolvedObj = _objOop;
	}
	if (GIV(gcPhaseInProgress) > 0) {
		if (GIV(gcPhaseInProgress) == ScavengeInProgress) {
			if ((((_resolvedObj & (tagMask())) == 0) && ((assert(isNonImmediate(_resolvedObj)), (oopisLessThan(_resolvedObj, (GIV(memoryMap)->newSpaceEnd))) && (oopisGreaterThanOrEqualTo(_resolvedObj, (GIV(memoryMap)->newSpaceStart)))))) && (!(oopisGreaterThanOrEqualToandLessThan(_resolvedObj, ((futureSpace()).start), futureSurvivorStart())))) {
				return copyAndForward(_resolvedObj);
			}
		} else {
			assert(slidingCompactionInProgress());
			if ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(_objOop, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_objOop)) ) >> (pinnedBitShift())) & 1) != 0))) {
				/* begin fetchPointer:ofObject: */
				return unsignedLongAt((_objOop + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofObject: */
			}
		}
	}
	return _resolvedObj;
	/* end slidingCompactionRemapObj: */
}
/* SpurPlanningCompactor>>#savedFirstFieldsSpaceWasAllocated */
static sqInt
savedFirstFieldsSpaceWasAllocated(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(savedFirstFieldsSpaceNotInOldSpace) && (oopisGreaterThan((GIV(savedFirstFieldsSpace).start), GIV(nilObj)));
}
/*	Scan from initialObject, setting firstMobileObject to the first marked 
	object after 
	the first free object found. Answer the first free object found, or nil if 
	none.  */
/* SpurPlanningCompactor>>#scanForFirstFreeAndFirstMobileObjectFrom: */
static sqInt NoDbgRegParms
scanForFirstFreeAndFirstMobileObjectFrom(sqInt _initialObject)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _firstFree;
	sqInt _followingWord;
	usqInt _followingWordAddress;
	sqInt _limit;
	sqInt _objOop;
	sqInt _prevObj;
	sqInt _prevPrevObj;

	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), _initialObject));
	_firstFree = 0;
	_prevPrevObj = (_prevObj = null);
	_objOop = _initialObject;
	while (1) {
		assert((_objOop % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop)) != 0);
		{
			if (((((usqInt) (longAt(_objOop)) ) >> (markedBitFullShift())) & 1) != 0) {
				if (_firstFree) {
					GIV(firstMobileObject) = _objOop;
					return _firstFree;
				}
			}
 else {
				if (!_firstFree) {
					_firstFree = _objOop;
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_limit = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop = _limit;
			goto l2;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l2:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	return _firstFree;
}
/*	Answer if the obj should be scavenged, or simply followed. Sent via the 
	compactor from shouldRemapObj:. We test for being already scavenged 
	because mapStackPages 
	via mapInterpreterOops may be applied twice in the context of a global GC 
	where a 
	scavenge, followed by a scan-mark-free, and final compaction passes may 
	result in 
	scavenged fields being visited twice. */
/* SpurPlanningCompactor>>#shouldRemapObj: */
sqInt
shouldRemapObj(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) || ((GIV(gcPhaseInProgress) > 0) && (((GIV(gcPhaseInProgress) == ScavengeInProgress)
		 ? (((_objOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_objOop >= ((GIV(memoryMap)->newSpaceStart)))) && (!(oopisGreaterThanOrEqualToandLessThan(_objOop, ((futureSpace()).start), futureSurvivorStart())))
		 : (oopisGreaterThanOrEqualToandLessThanOrEqualTo(_objOop, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_objOop)) ) >> (pinnedBitShift())) & 1) != 0)))));
}
/*	Sweep the initial immobile heap, unmarking all objects up to the first 
	mobile object. 
	 
	Precondition: all used objects are marked. 
	 
	If freeUnmarked, free unmarked objects as they are found. 
	If the object is a fixed known object (nil, false, true) we should not 
	free it */
/* SpurPlanningCompactor>>#unmarkInitialImmobileObjectsFreeUnmarked: */
static void NoDbgRegParms
unmarkInitialImmobileObjectsFreeUnmarked(sqInt _freeUnmarked)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _followingWord;
	usqInt _followingWordAddress;
	sqInt _limit;
	sqInt _objOop2;
	sqInt _prevObj;
	sqInt _prevPrevObj;

	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj = (_prevObj = null);
	_objOop2 = GIV(nilObj);
	while (1) {
		assert((_objOop2 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop2, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop2)) != 0);
		{
			if (isEnumerableObject(_objOop2)) {
				{
					if (oopisGreaterThanOrEqualTo(_objOop2, GIV(firstMobileObject))) {
						return;
					}
					if (_freeUnmarked && ((!(((((usqInt) (longAt(_objOop2)) ) >> (markedBitFullShift())) & 1) != 0)) && (!((_objOop2 >= GIV(nilObj)) && (_objOop2 <= GIV(trueObj)))))) {
						freeObjectWithoutCoalesce(_objOop2);
					} else {
						/* begin setIsMarkedOf:to: */
						assert(!(isFreeObject(_objOop2)));
						unsignedLongAtput(_objOop2, (unsignedLongAt(_objOop2)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
						/* end setIsMarkedOf:to: */
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_limit = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l2;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l2:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
}
/*	Sweep the final immobile heap, freeing and coalescing unmarked and free 
	objects, and unmarking all marked objects up to the end of memory. */
/* SpurPlanningCompactor>>#unmarkObjectsFromFirstFreeObject */
static void
unmarkObjectsFromFirstFreeObject(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _followingWord;
	usqInt _followingWordAddress;
	int _freeBytes;
	sqInt _limit;
	sqInt _objOop;
	sqInt _prevObj;
	sqInt _prevPrevObj;
	usqInt _startOfFree;

	_startOfFree = 0;
	_freeBytes = 0;
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(firstFreeObject)));
	_prevPrevObj = (_prevObj = null);
	_objOop = GIV(firstFreeObject);
	while (1) {
		assert((_objOop % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop)) != 0);
		{
			if (((((usqInt) (longAt(_objOop)) ) >> (markedBitFullShift())) & 1) != 0) {
				if (_startOfFree) {
					/* begin addFreeChunkWithBytes:at: */
					GIV(totalFreeOldSpace) += _freeBytes;
					freeChunkWithBytesat(_freeBytes, _startOfFree);
					/* end addFreeChunkWithBytes:at: */
					_startOfFree = null;
					_freeBytes = 0;
				}
				if (((((usqInt) (longAt(_objOop)) ) >> (pinnedBitShift())) & 1) != 0) {
					/* begin unmarkPinned: */
					if (!(((longAt(_objOop)) & (classIndexMask())) == (segmentBridgePun()))) {
						/* begin setIsMarkedOf:to: */
						assert(!(isFreeObject(_objOop)));
						unsignedLongAtput(_objOop, (unsignedLongAt(_objOop)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
						/* end setIsMarkedOf:to: */
						/* begin notePinned: */
						assert(isPinned(_objOop));
						if (((longAt(_objOop)) & (classIndexMask())) == (segmentBridgePun())) {
							/* begin setIsMarkedOf:to: */
							assert(!(isFreeObject(_objOop)));
							unsignedLongAtput(_objOop, (unsignedLongAt(_objOop)) | (1ULL << (markedBitFullShift())));
							/* end setIsMarkedOf:to: */
						} else {
							while (oopisLessThan((((GIV(segments)[GIV(sweepIndex)]).segSize)) + (((GIV(segments)[GIV(sweepIndex)]).segStart)), _objOop)) {
								GIV(sweepIndex) += 1;
							}
							((GIV(segments)[GIV(sweepIndex)]).containsPinned = 1);
						}
						/* end notePinned: */
					}
					/* end unmarkPinned: */
				} else {
					/* begin setIsMarkedOf:to: */
					assert(!(isFreeObject(_objOop)));
					unsignedLongAtput(_objOop, (unsignedLongAt(_objOop)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
					/* end setIsMarkedOf:to: */
				}
			} else {
				if (!_startOfFree) {
					/* begin startOfObject: */
					_startOfFree = (((byteAt(_objOop + 7)) == (numSlotsMask()))
						 ? _objOop - BaseHeaderSize
						 : _objOop);
					/* end startOfObject: */
				}
				_freeBytes += bytesInObject(_objOop);
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_limit = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop = _limit;
			goto l5;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l5:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	if (_startOfFree) {
		/* begin addFreeChunkWithBytes:at: */
		GIV(totalFreeOldSpace) += _freeBytes;
		freeChunkWithBytesat(_freeBytes, _startOfFree);
		/* end addFreeChunkWithBytes:at: */
	}
}
/*	Sweep the heap, updating all objects to their eventual locations. 
	Remember to update the savedFirstFields of pointer objects, as these have 
	been forwarded. */
/* SpurPlanningCompactor>>#updatePointers */
static void NeverInline
updatePointers(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _availableSpace;
	usqInt _bytes;
	sqInt _contextSize;
	sqInt _contextSize2;
	sqInt _contextSize3;
	sqInt _contextSize4;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _fmt3;
	sqInt _fmt4;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	sqInt _fwd;
	sqInt _fwd2;
	sqInt _fwd3;
	sqInt _fwd4;
	sqInt _header;
	sqInt _header2;
	sqInt _header22;
	sqInt _header23;
	sqInt _header24;
	sqInt _header3;
	sqInt _header4;
	sqInt _header5;
	sqInt _i;
	sqInt _i2;
	sqInt _i3;
	sqInt _i4;
	sqInt _limit;
	sqInt _limit2;
	sqInt _limit3;
	sqInt _numLiterals;
	sqInt _numLiterals2;
	sqInt _numLiterals3;
	sqInt _numLiterals4;
	usqInt _numPointerSlots;
	usqInt _numPointerSlots2;
	usqInt _numPointerSlots3;
	usqInt _numPointerSlots4;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots22;
	usqInt _numSlots3;
	usqInt _numSlots4;
	usqInt _numSlots5;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _objOop23;
	sqInt _objOop5;
	sqInt _onePass;
	sqInt _oop;
	sqInt _oop2;
	sqInt _oop3;
	sqInt _oop4;
	usqInt _previousPin;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevObj3;
	sqInt _prevObj4;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;
	sqInt _prevPrevObj3;
	sqInt _prevPrevObj4;
	sqInt _sp;
	sqInt _sp2;
	sqInt _sp3;
	sqInt _sp4;
	usqInt _startOfPreviousPin;
	usqInt _toFinger;
	usqInt _top;

	/* begin logPhase: */
	_previousPin = 0;
	/* end logPhase: */
	if (!(GIV(lastMobileObject) != null)) {
		return;
	}
	assert((startOfObject(GIV(firstFreeObject))) == GIV(mobileStart));
	mapInterpreterOops();
	mapExtraRoots();
	updatePointersInManagerHeapEntities();
	/* begin updatePointersInSurvivingObjects */
	/* begin allPastSpaceObjectsDo: */
	/* begin allPastSpaceEntitiesDo: */
	_prevPrevObj2 = (_prevObj2 = null);
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots3 = byteAt(_address + 7);
	_objOop22 = ((_numSlots3 == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop22, GIV(pastSpaceStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop22));
			{
				assert(isMarked(_objOop22));
				/* begin updatePointersIn: */
				/* begin numPointerSlotsOf: */
				_fmt2 = (((usqInt) (longAt(_objOop22)) ) >> (formatShift())) & (formatMask());
				if (_fmt2 <= 5) {
					if ((_fmt2 == (indexablePointersFormat())) && (((longAt(_objOop22)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
						/* begin fetchStackPointerOf: */
						/* begin fetchPointer:ofObject: */
						_sp2 = unsignedLongAt((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						if (!(((_sp2 & 7) == 1))) {
							_contextSize2 = 0;
							goto l48;
						}
						assert((ReceiverIndex + (_sp2 >> 3)) < (lengthOf(_objOop22)));
						_contextSize2 = _sp2 >> 3;
						l48:
						;
						/* end fetchStackPointerOf: */
						_numPointerSlots2 = CtxtTempFrameStart + _contextSize2;
						goto l47;
					}
					/* begin numSlotsOf: */
					assert((classIndexOf(_objOop22)) > (isForwardedObjectClassIndexPun()));
					_numSlots2 = byteAt(_objOop22 + 7);
					_numPointerSlots2 = ((_numSlots2 == (numSlotsMask()))
						 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop22 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
						 : _numSlots2);
					goto l47;
					/* end numSlotsOf: */
				}
				if (_fmt2 == 7) {
					_numPointerSlots2 = 1;
					goto l47;
				}
				if (_fmt2 < (firstCompiledMethodFormat())) {
					_numPointerSlots2 = 0;
					goto l47;
				}
				/* begin methodHeaderOf: */
				assert(isCompiledMethod(_objOop22));
				/* begin fetchPointer:ofObject: */
				_header22 = unsignedLongAt((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_header22 & 7) == 1)) {
					_header3 = _header22;
				} else {
					assert(((usqInt) _header22 ) < ((GIV(memoryMap)->newSpaceStart)));
					assert((((((CogMethod *) _header22 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
					_header3 = ((((CogMethod *) _header22 ))->methodHeader);
				}
				/* end methodHeaderOf: */
				{
					assert(((_header3 & 7) == 1));
					_numLiterals2 = (_header3 >> 3) & AlternateHeaderNumLiteralsMask;
				}
				_numPointerSlots2 = _numLiterals2 + LiteralStart;
				l47:
				;
				/* end numPointerSlotsOf: */
				for (_i2 = 0; _i2 < _numPointerSlots2; _i2 += 1) {
					/* begin updatePointer:in: */
					/* begin fetchPointer:ofObject: */
					_oop2 = unsignedLongAt((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) _i2 ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (((_oop2 & (tagMask())) == 0) && ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(_oop2, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_oop2)) ) >> (pinnedBitShift())) & 1) != 0)))) {
						assert(isMarked(_oop2));
						/* begin fetchPointer:ofObject: */
						_fwd2 = unsignedLongAt((_oop2 + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofObject: */
						assert(isPostMobile(_fwd2));
						/* begin storePointerUnchecked:ofObject:withValue: */
						assert(!(isOopForwarded(_objOop22)));
						longAtput((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) _i2 ) << (shiftForWord())) ), _fwd2);
						/* end storePointerUnchecked:ofObject:withValue: */
					}
					/* end updatePointer:in: */
				}
				/* end updatePointersIn: */
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(pastSpaceStart))) {
			_objOop22 = GIV(pastSpaceStart);
			goto l17;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop22 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l17:
		;
		/* end objectAfter:limit: */
	}
	/* end allPastSpaceEntitiesDo: */
	/* end allPastSpaceObjectsDo: */
	/* end updatePointersInSurvivingObjects */
	/* begin updatePointersInInitialImmobileObjects */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj3 = (_prevObj3 = null);
	_objOop23 = GIV(nilObj);
	while (1) {
		assert((_objOop23 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop23, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop23)) != 0);
		{
			if (isEnumerableObject(_objOop23)) {
				{
					if (oopisGreaterThanOrEqualTo(_objOop23, GIV(firstFreeObject))) {
						goto l30;
					}
					/* begin updatePointersIn: */
					/* begin numPointerSlotsOf: */
					_fmt3 = (((usqInt) (longAt(_objOop23)) ) >> (formatShift())) & (formatMask());
					if (_fmt3 <= 5) {
						if ((_fmt3 == (indexablePointersFormat())) && (((longAt(_objOop23)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
							/* begin fetchStackPointerOf: */
							/* begin fetchPointer:ofObject: */
							_sp3 = unsignedLongAt((_objOop23 + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							if (!(((_sp3 & 7) == 1))) {
								_contextSize3 = 0;
								goto l51;
							}
							assert((ReceiverIndex + (_sp3 >> 3)) < (lengthOf(_objOop23)));
							_contextSize3 = _sp3 >> 3;
							l51:
							;
							/* end fetchStackPointerOf: */
							_numPointerSlots3 = CtxtTempFrameStart + _contextSize3;
							goto l52;
						}
						/* begin numSlotsOf: */
						assert((classIndexOf(_objOop23)) > (isForwardedObjectClassIndexPun()));
						_numSlots4 = byteAt(_objOop23 + 7);
						_numPointerSlots3 = ((_numSlots4 == (numSlotsMask()))
							 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop23 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
							 : _numSlots4);
						goto l52;
						/* end numSlotsOf: */
					}
					if (_fmt3 == 7) {
						_numPointerSlots3 = 1;
						goto l52;
					}
					if (_fmt3 < (firstCompiledMethodFormat())) {
						_numPointerSlots3 = 0;
						goto l52;
					}
					/* begin methodHeaderOf: */
					assert(isCompiledMethod(_objOop23));
					/* begin fetchPointer:ofObject: */
					_header23 = unsignedLongAt((_objOop23 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (((_header23 & 7) == 1)) {
						_header4 = _header23;
					} else {
						assert(((usqInt) _header23 ) < ((GIV(memoryMap)->newSpaceStart)));
						assert((((((CogMethod *) _header23 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
						_header4 = ((((CogMethod *) _header23 ))->methodHeader);
					}
					/* end methodHeaderOf: */
					{
						assert(((_header4 & 7) == 1));
						_numLiterals3 = (_header4 >> 3) & AlternateHeaderNumLiteralsMask;
					}
					_numPointerSlots3 = _numLiterals3 + LiteralStart;
					l52:
					;
					/* end numPointerSlotsOf: */
					for (_i3 = 0; _i3 < _numPointerSlots3; _i3 += 1) {
						/* begin updatePointer:in: */
						/* begin fetchPointer:ofObject: */
						_oop3 = unsignedLongAt((_objOop23 + BaseHeaderSize) + ((sqInt) (((usqInt) _i3 ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						if (((_oop3 & (tagMask())) == 0) && ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(_oop3, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_oop3)) ) >> (pinnedBitShift())) & 1) != 0)))) {
							assert(isMarked(_oop3));
							/* begin fetchPointer:ofObject: */
							_fwd3 = unsignedLongAt((_oop3 + BaseHeaderSize) + (0U << (shiftForWord())));
							/* end fetchPointer:ofObject: */
							assert(isPostMobile(_fwd3));
							/* begin storePointerUnchecked:ofObject:withValue: */
							assert(!(isOopForwarded(_objOop23)));
							longAtput((_objOop23 + BaseHeaderSize) + ((sqInt) (((usqInt) _i3 ) << (shiftForWord())) ), _fwd3);
							/* end storePointerUnchecked:ofObject:withValue: */
						}
						/* end updatePointer:in: */
					}
					/* end updatePointersIn: */
				}
			}
		}
		_prevPrevObj3 = _prevObj3;
		_prevObj3 = _objOop23;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress3 = addressAfter(_objOop23);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, _limit2)) {
			_objOop23 = _limit2;
			goto l22;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_objOop23 = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l22:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	l30:
	;
	/* end updatePointersInInitialImmobileObjects */
	/* begin updatePointersInMobileObjects */
	assert(!(isMarked(GIV(firstFreeObject))));
	/* begin startOfObject: */
	_toFinger = (((byteAt(GIV(firstFreeObject) + 7)) == (numSlotsMask()))
		 ? GIV(firstFreeObject) - BaseHeaderSize
		 : GIV(firstFreeObject));
	/* end startOfObject: */
	_top = (GIV(savedFirstFieldsSpace).start);
	_startOfPreviousPin = 0;
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(firstFreeObject)));
	_prevPrevObj4 = (_prevObj4 = null);
	_objOop5 = GIV(firstFreeObject);
	while (1) {
		assert((_objOop5 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop5, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop5)) != 0);
		{
			assert(((_previousPin == null)
				 ? _toFinger <= (startOfObject(_objOop5))
				 : (isMarked(_previousPin)) && (_toFinger <= _startOfPreviousPin)));
			if (((((usqInt) (longAt(_objOop5)) ) >> (markedBitFullShift())) & 1) != 0) {
				if (((((usqInt) (longAt(_objOop5)) ) >> (pinnedBitShift())) & 1) != 0) {
					if (!_previousPin) {
						_previousPin = _objOop5;
						/* begin startOfObject: */
						_startOfPreviousPin = (((byteAt(_objOop5 + 7)) == (numSlotsMask()))
							 ? _objOop5 - BaseHeaderSize
							 : _objOop5);
						/* end startOfObject: */
					}
					/* begin updatePointersIn: */
					/* begin numPointerSlotsOf: */
					_fmt4 = (((usqInt) (longAt(_objOop5)) ) >> (formatShift())) & (formatMask());
					if (_fmt4 <= 5) {
						if ((_fmt4 == (indexablePointersFormat())) && (((longAt(_objOop5)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
							/* begin fetchStackPointerOf: */
							/* begin fetchPointer:ofObject: */
							_sp4 = unsignedLongAt((_objOop5 + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							if (!(((_sp4 & 7) == 1))) {
								_contextSize4 = 0;
								goto l54;
							}
							assert((ReceiverIndex + (_sp4 >> 3)) < (lengthOf(_objOop5)));
							_contextSize4 = _sp4 >> 3;
							l54:
							;
							/* end fetchStackPointerOf: */
							_numPointerSlots4 = CtxtTempFrameStart + _contextSize4;
							goto l53;
						}
						/* begin numSlotsOf: */
						assert((classIndexOf(_objOop5)) > (isForwardedObjectClassIndexPun()));
						_numSlots22 = byteAt(_objOop5 + 7);
						_numPointerSlots4 = ((_numSlots22 == (numSlotsMask()))
							 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop5 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
							 : _numSlots22);
						goto l53;
						/* end numSlotsOf: */
					}
					if (_fmt4 == 7) {
						_numPointerSlots4 = 1;
						goto l53;
					}
					if (_fmt4 < (firstCompiledMethodFormat())) {
						_numPointerSlots4 = 0;
						goto l53;
					}
					/* begin methodHeaderOf: */
					assert(isCompiledMethod(_objOop5));
					/* begin fetchPointer:ofObject: */
					_header24 = unsignedLongAt((_objOop5 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (((_header24 & 7) == 1)) {
						_header5 = _header24;
					} else {
						assert(((usqInt) _header24 ) < ((GIV(memoryMap)->newSpaceStart)));
						assert((((((CogMethod *) _header24 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
						_header5 = ((((CogMethod *) _header24 ))->methodHeader);
					}
					/* end methodHeaderOf: */
					{
						assert(((_header5 & 7) == 1));
						_numLiterals4 = (_header5 >> 3) & AlternateHeaderNumLiteralsMask;
					}
					_numPointerSlots4 = _numLiterals4 + LiteralStart;
					l53:
					;
					/* end numPointerSlotsOf: */
					for (_i4 = 0; _i4 < _numPointerSlots4; _i4 += 1) {
						/* begin updatePointer:in: */
						/* begin fetchPointer:ofObject: */
						_oop4 = unsignedLongAt((_objOop5 + BaseHeaderSize) + ((sqInt) (((usqInt) _i4 ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						if (((_oop4 & (tagMask())) == 0) && ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(_oop4, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_oop4)) ) >> (pinnedBitShift())) & 1) != 0)))) {
							assert(isMarked(_oop4));
							/* begin fetchPointer:ofObject: */
							_fwd4 = unsignedLongAt((_oop4 + BaseHeaderSize) + (0U << (shiftForWord())));
							/* end fetchPointer:ofObject: */
							assert(isPostMobile(_fwd4));
							/* begin storePointerUnchecked:ofObject:withValue: */
							assert(!(isOopForwarded(_objOop5)));
							longAtput((_objOop5 + BaseHeaderSize) + ((sqInt) (((usqInt) _i4 ) << (shiftForWord())) ), _fwd4);
							/* end storePointerUnchecked:ofObject:withValue: */
						}
						/* end updatePointer:in: */
					}
					/* end updatePointersIn: */
				} else {
					_bytes = bytesInObject(_objOop5);
					while ((_toFinger <= _startOfPreviousPin) && ((_bytes != ((_availableSpace = _startOfPreviousPin - _toFinger))) && ((_bytes + (2 * 8)) > _availableSpace))) {
						do {
							_toFinger = addressAfter(_previousPin);
							/* begin objectStartingAt: */
							_numSlots5 = byteAt(_toFinger + 7);
							_previousPin = ((_numSlots5 == (numSlotsMask()))
								 ? _toFinger + BaseHeaderSize
								 : _toFinger);
							/* end objectStartingAt: */
						} while ((((((usqInt) (longAt(_previousPin)) ) >> (markedBitFullShift())) & 1) != 0) && ((((((usqInt) (longAt(_previousPin)) ) >> (pinnedBitShift())) & 1) != 0) && (_previousPin < _objOop5)));
						while (!((_previousPin >= _objOop5) || ((((((usqInt) (longAt(_previousPin)) ) >> (markedBitFullShift())) & 1) != 0) && (((((usqInt) (longAt(_previousPin)) ) >> (pinnedBitShift())) & 1) != 0)))) {
							_previousPin = oldSpaceObjectAfter(_previousPin);
						}
						if (_previousPin >= _objOop5) {
							_previousPin = null;
							_startOfPreviousPin = 0;
						} else {
							/* begin startOfObject: */
							_startOfPreviousPin = (((byteAt(_previousPin + 7)) == (numSlotsMask()))
								 ? _previousPin - BaseHeaderSize
								 : _previousPin);
							/* end startOfObject: */
						}
					}
					updatePointersInsavedFirstFieldPointer(_objOop5, _top);
					_toFinger += _bytes;
					if (((_top += BytesPerOop)) >= ((GIV(savedFirstFieldsSpace).limit))) {
						assert(((GIV(savedFirstFieldsSpace).top)) == (_top - BytesPerOop));
						_onePass = 0;
						goto l44;
					}
				}
			}
		}
		_prevPrevObj4 = _prevObj4;
		_prevObj4 = _objOop5;
		/* begin objectAfter:limit: */
		_limit3 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop5);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit3)) {
			_objOop5 = _limit3;
			goto l33;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop5 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l33:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	assert(((GIV(savedFirstFieldsSpace).top)) == (_top - BytesPerOop));
	_onePass = 1;
	l44:
	;
	/* end updatePointersInMobileObjects */
	if (!_onePass) {
		/* begin updatePointersInObjectsOverflowingSavedFirstFieldsSpace */
		/* begin allOldSpaceObjectsFrom:do: */
		/* begin allOldSpaceEntitiesFrom:do: */
		assert(isOldObject(GIV(memoryMap), GIV(objectAfterLastMobileObject)));
		_prevPrevObj = (_prevObj = null);
		_objOop2 = GIV(objectAfterLastMobileObject);
		while (1) {
			assert((_objOop2 % (allocationUnit())) == 0);
			if (!(oopisLessThan(_objOop2, (GIV(memoryMap)->oldSpaceEnd)))) 
				break;
			assert((uint64AtPointer(_objOop2)) != 0);
			{
				if (isEnumerableObject(_objOop2)) {
					{
						if (((((usqInt) (longAt(_objOop2)) ) >> (markedBitFullShift())) & 1) != 0) {
							/* begin updatePointersIn: */
							/* begin numPointerSlotsOf: */
							_fmt = (((usqInt) (longAt(_objOop2)) ) >> (formatShift())) & (formatMask());
							if (_fmt <= 5) {
								if ((_fmt == (indexablePointersFormat())) && (((longAt(_objOop2)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
									/* begin fetchStackPointerOf: */
									/* begin fetchPointer:ofObject: */
									_sp = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									if (!(((_sp & 7) == 1))) {
										_contextSize = 0;
										goto l58;
									}
									assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_objOop2)));
									_contextSize = _sp >> 3;
									l58:
									;
									/* end fetchStackPointerOf: */
									_numPointerSlots = CtxtTempFrameStart + _contextSize;
									goto l57;
								}
								/* begin numSlotsOf: */
								assert((classIndexOf(_objOop2)) > (isForwardedObjectClassIndexPun()));
								_numSlots = byteAt(_objOop2 + 7);
								_numPointerSlots = ((_numSlots == (numSlotsMask()))
									 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop2 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
									 : _numSlots);
								goto l57;
								/* end numSlotsOf: */
							}
							if (_fmt == 7) {
								_numPointerSlots = 1;
								goto l57;
							}
							if (_fmt < (firstCompiledMethodFormat())) {
								_numPointerSlots = 0;
								goto l57;
							}
							/* begin methodHeaderOf: */
							assert(isCompiledMethod(_objOop2));
							/* begin fetchPointer:ofObject: */
							_header2 = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							if (((_header2 & 7) == 1)) {
								_header = _header2;
							} else {
								assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
								assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
								_header = ((((CogMethod *) _header2 ))->methodHeader);
							}
							/* end methodHeaderOf: */
							{
								assert(((_header & 7) == 1));
								_numLiterals = (_header >> 3) & AlternateHeaderNumLiteralsMask;
							}
							_numPointerSlots = _numLiterals + LiteralStart;
							l57:
							;
							/* end numPointerSlotsOf: */
							for (_i = 0; _i < _numPointerSlots; _i += 1) {
								/* begin updatePointer:in: */
								/* begin fetchPointer:ofObject: */
								_oop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								if (((_oop & (tagMask())) == 0) && ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(_oop, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_oop)) ) >> (pinnedBitShift())) & 1) != 0)))) {
									assert(isMarked(_oop));
									/* begin fetchPointer:ofObject: */
									_fwd = unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())));
									/* end fetchPointer:ofObject: */
									assert(isPostMobile(_fwd));
									/* begin storePointerUnchecked:ofObject:withValue: */
									assert(!(isOopForwarded(_objOop2)));
									longAtput((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _fwd);
									/* end storePointerUnchecked:ofObject:withValue: */
								}
								/* end updatePointer:in: */
							}
							/* end updatePointersIn: */
						}
					}
				}
			}
			_prevPrevObj = _prevObj;
			_prevObj = _objOop2;
			/* begin objectAfter:limit: */
			_limit = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			_followingWordAddress = addressAfter(_objOop2);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
				_objOop2 = _limit;
				goto l2;
			}
			flag("endianness");
			_followingWord = unsignedLongAt(_followingWordAddress);
			_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress + BaseHeaderSize
				 : _followingWordAddress);
			l2:
			;
			/* end objectAfter:limit: */
		}
		/* end allOldSpaceEntitiesFrom:do: */
		/* end allOldSpaceObjectsFrom:do: */
		/* end updatePointersInObjectsOverflowingSavedFirstFieldsSpace */
	}
}
/*	The special non-pointer objects containing pointers, which are the 
	objStacks and the rememberedSet, 
	must be updated manually since they will not be recognized as containing 
	pointers in the normal sweep. */
/* SpurPlanningCompactor>>#updatePointersInManagerHeapEntities */
static void
updatePointersInManagerHeapEntities(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMRememberedSet * self_in_rememberedSetWithIndexDostartingAt;
	VMRememberedSet * self_in_rememberedSetWithIndexDostartingAt2;
	VMRememberedSet * self_in_rememberedSetWithIndexDostartingAt3;
	VMRememberedSet * self_in_rememberedSetWithIndexDostartingAt4;
	sqInt _contextSize;
	sqInt _contextSize2;
	sqInt _contextSize3;
	sqInt _contextSize4;
	sqInt _finishIndex;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _fmt3;
	sqInt _fmt4;
	sqInt _fwd;
	sqInt _fwd2;
	sqInt _fwd3;
	sqInt _fwd4;
	sqInt _fwd5;
	sqInt _header;
	sqInt _header2;
	sqInt _header22;
	sqInt _header23;
	sqInt _header24;
	sqInt _header3;
	sqInt _header4;
	sqInt _header5;
	sqInt _heapEntity;
	sqInt _i;
	sqInt _i2;
	sqInt _i3;
	sqInt _i4;
	sqInt _i5;
	sqInt _i6;
	sqInt _i7;
	sqInt _i8;
	sqInt _i9;
	sqInt _numLiterals;
	sqInt _numLiterals2;
	sqInt _numLiterals3;
	sqInt _numLiterals4;
	usqInt _numPointerSlots;
	usqInt _numPointerSlots2;
	usqInt _numPointerSlots3;
	usqInt _numPointerSlots4;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots3;
	usqInt _numSlots4;
	sqInt _obj;
	sqInt _obj2;
	sqInt _oop;
	sqInt _oop2;
	sqInt _oop3;
	sqInt _oop4;
	sqInt _oop5;
	sqInt _oop6;
	sqInt _sp;
	sqInt _sp2;
	sqInt _sp3;
	sqInt _sp4;

	/* begin relocateObjStacksForPlanningCompactor */
	GIV(markStack) = relocateObjStackForPlanningCompactor(GIV(markStack));
	GIV(weaklingStack) = relocateObjStackForPlanningCompactor(GIV(weaklingStack));
	GIV(mournQueue) = relocateObjStackForPlanningCompactor(GIV(mournQueue));
	/* end relocateObjStacksForPlanningCompactor */
	if (((((getFromOldSpaceRememberedSet())->rememberedSetSize)) > 0) && ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(GIV(firstFieldOfRememberedSet), GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(GIV(firstFieldOfRememberedSet))) ) >> (pinnedBitShift())) & 1) != 0)))) {
		/* begin fetchPointer:ofObject: */
		GIV(firstFieldOfRememberedSet) = unsignedLongAt((GIV(firstFieldOfRememberedSet) + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofObject: */
	}
	/* begin relocateObjectsInHeapEntity:from:to: */
	/* begin oldRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	_heapEntity = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) OldRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end oldRememberedSetObj */
	_finishIndex = (((getFromOldSpaceRememberedSet())->rememberedSetSize)) - 1;
	for (_i = 1; _i <= _finishIndex; _i += 1) {
		/* begin fetchPointer:ofObject: */
		_oop2 = unsignedLongAt((_heapEntity + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_oop2 & (tagMask())) == 0) && ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(_oop2, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_oop2)) ) >> (pinnedBitShift())) & 1) != 0)))) {
			assert(isMarked(_oop2));
			/* begin fetchPointer:ofObject: */
			_fwd = unsignedLongAt((_oop2 + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofObject: */
			assert(isPostMobile(_fwd));
			/* begin storePointerUnchecked:ofObject:withValue: */
			assert(!(isOopForwarded(_heapEntity)));
			longAtput((_heapEntity + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _fwd);
			/* end storePointerUnchecked:ofObject:withValue: */
		}
	}
	if ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(_heapEntity, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_heapEntity)) ) >> (pinnedBitShift())) & 1) != 0))) {
		/* begin fetchPointer:ofObject: */
		unsignedLongAt((_heapEntity + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofObject: */
	}
	/* end relocateObjectsInHeapEntity:from:to: */
	if ((((getFromPermToOldSpaceRememberedSet())->rememberedSetSize)) > 0) {
		if (!(((((usqInt) (longAt(GIV(firstFieldOfPermToOldRememberedSet))) ) >> (markedBitFullShift())) & 1) != 0)) {
			/* begin updatePointersIn: */
			_obj = GIV(firstFieldOfPermToOldRememberedSet);
			/* begin numPointerSlotsOf: */
			_fmt = (((usqInt) (longAt(_obj)) ) >> (formatShift())) & (formatMask());
			if (_fmt <= 5) {
				if ((_fmt == (indexablePointersFormat())) && (((longAt(_obj)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
					/* begin fetchStackPointerOf: */
					/* begin fetchPointer:ofObject: */
					_sp = unsignedLongAt((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (!(((_sp & 7) == 1))) {
						_contextSize = 0;
						goto l23;
					}
					assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_obj)));
					_contextSize = _sp >> 3;
					l23:
					;
					/* end fetchStackPointerOf: */
					_numPointerSlots = CtxtTempFrameStart + _contextSize;
					goto l18;
				}
				/* begin numSlotsOf: */
				assert((classIndexOf(_obj)) > (isForwardedObjectClassIndexPun()));
				_numSlots = byteAt(_obj + 7);
				_numPointerSlots = ((_numSlots == (numSlotsMask()))
					 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_obj - BaseHeaderSize)) ) << 8) ) ) ) >> 8
					 : _numSlots);
				goto l18;
				/* end numSlotsOf: */
			}
			if (_fmt == 7) {
				_numPointerSlots = 1;
				goto l18;
			}
			if (_fmt < (firstCompiledMethodFormat())) {
				_numPointerSlots = 0;
				goto l18;
			}
			/* begin methodHeaderOf: */
			assert(isCompiledMethod(_obj));
			/* begin fetchPointer:ofObject: */
			_header2 = unsignedLongAt((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_header2 & 7) == 1)) {
				_header = _header2;
			} else {
				assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
				assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
				_header = ((((CogMethod *) _header2 ))->methodHeader);
			}
			/* end methodHeaderOf: */
			{
				assert(((_header & 7) == 1));
				_numLiterals = (_header >> 3) & AlternateHeaderNumLiteralsMask;
			}
			_numPointerSlots = _numLiterals + LiteralStart;
			l18:
			;
			/* end numPointerSlotsOf: */
			for (_i6 = 0; _i6 < _numPointerSlots; _i6 += 1) {
				/* begin updatePointer:in: */
				/* begin fetchPointer:ofObject: */
				_oop3 = unsignedLongAt((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) _i6 ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_oop3 & (tagMask())) == 0) && ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(_oop3, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_oop3)) ) >> (pinnedBitShift())) & 1) != 0)))) {
					assert(isMarked(_oop3));
					/* begin fetchPointer:ofObject: */
					_fwd2 = unsignedLongAt((_oop3 + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofObject: */
					assert(isPostMobile(_fwd2));
					/* begin storePointerUnchecked:ofObject:withValue: */
					assert(!(isOopForwarded(_obj)));
					longAtput((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) _i6 ) << (shiftForWord())) ), _fwd2);
					/* end storePointerUnchecked:ofObject:withValue: */
				}
				/* end updatePointer:in: */
			}
			/* end updatePointersIn: */
			/* begin mark: */
			/* begin setIsMarkedOf:to: */
			assert(!(isFreeObject(GIV(firstFieldOfPermToOldRememberedSet))));
			unsignedLongAtput(GIV(firstFieldOfPermToOldRememberedSet), (unsignedLongAt(GIV(firstFieldOfPermToOldRememberedSet))) | (1ULL << (markedBitFullShift())));
			/* end setIsMarkedOf:to: */
			/* end mark: */
		}
	}
	/* begin rememberedSetWithIndexDo:startingAt: */
	/* begin getFromPermToOldSpaceRememberedSet */
	self_in_rememberedSetWithIndexDostartingAt = GIV(fromPermToOldSpaceRememberedSet);
	/* end getFromPermToOldSpaceRememberedSet */
	for (_i2 = 1; _i2 < ((self_in_rememberedSetWithIndexDostartingAt->rememberedSetSize)); _i2 += 1) {
		{
			_oop = (self_in_rememberedSetWithIndexDostartingAt->rememberedSetArray)[_i2];
			if (!(((((usqInt) (longAt(_oop)) ) >> (markedBitFullShift())) & 1) != 0)) {
				/* begin updatePointersIn: */
				/* begin numPointerSlotsOf: */
				_fmt2 = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
				if (_fmt2 <= 5) {
					if ((_fmt2 == (indexablePointersFormat())) && (((longAt(_oop)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
						/* begin fetchStackPointerOf: */
						/* begin fetchPointer:ofObject: */
						_sp2 = unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						if (!(((_sp2 & 7) == 1))) {
							_contextSize2 = 0;
							goto l48;
						}
						assert((ReceiverIndex + (_sp2 >> 3)) < (lengthOf(_oop)));
						_contextSize2 = _sp2 >> 3;
						l48:
						;
						/* end fetchStackPointerOf: */
						_numPointerSlots2 = CtxtTempFrameStart + _contextSize2;
						goto l49;
					}
					/* begin numSlotsOf: */
					assert((classIndexOf(_oop)) > (isForwardedObjectClassIndexPun()));
					_numSlots2 = byteAt(_oop + 7);
					_numPointerSlots2 = ((_numSlots2 == (numSlotsMask()))
						 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_oop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
						 : _numSlots2);
					goto l49;
					/* end numSlotsOf: */
				}
				if (_fmt2 == 7) {
					_numPointerSlots2 = 1;
					goto l49;
				}
				if (_fmt2 < (firstCompiledMethodFormat())) {
					_numPointerSlots2 = 0;
					goto l49;
				}
				/* begin methodHeaderOf: */
				assert(isCompiledMethod(_oop));
				/* begin fetchPointer:ofObject: */
				_header22 = unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_header22 & 7) == 1)) {
					_header3 = _header22;
				} else {
					assert(((usqInt) _header22 ) < ((GIV(memoryMap)->newSpaceStart)));
					assert((((((CogMethod *) _header22 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
					_header3 = ((((CogMethod *) _header22 ))->methodHeader);
				}
				/* end methodHeaderOf: */
				{
					assert(((_header3 & 7) == 1));
					_numLiterals2 = (_header3 >> 3) & AlternateHeaderNumLiteralsMask;
				}
				_numPointerSlots2 = _numLiterals2 + LiteralStart;
				l49:
				;
				/* end numPointerSlotsOf: */
				for (_i7 = 0; _i7 < _numPointerSlots2; _i7 += 1) {
					/* begin updatePointer:in: */
					/* begin fetchPointer:ofObject: */
					_oop4 = unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) _i7 ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (((_oop4 & (tagMask())) == 0) && ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(_oop4, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_oop4)) ) >> (pinnedBitShift())) & 1) != 0)))) {
						assert(isMarked(_oop4));
						/* begin fetchPointer:ofObject: */
						_fwd3 = unsignedLongAt((_oop4 + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofObject: */
						assert(isPostMobile(_fwd3));
						/* begin storePointerUnchecked:ofObject:withValue: */
						assert(!(isOopForwarded(_oop)));
						longAtput((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) _i7 ) << (shiftForWord())) ), _fwd3);
						/* end storePointerUnchecked:ofObject:withValue: */
					}
					/* end updatePointer:in: */
				}
				/* end updatePointersIn: */
				/* begin mark: */
				/* begin setIsMarkedOf:to: */
				assert(!(isFreeObject(_oop)));
				unsignedLongAtput(_oop, (unsignedLongAt(_oop)) | (1ULL << (markedBitFullShift())));
				/* end setIsMarkedOf:to: */
				/* end mark: */
			}
		}
	}
	/* end rememberedSetWithIndexDo:startingAt: */
	if ((((getFromPermToNewSpaceRememberedSet())->rememberedSetSize)) > 0) {
		if (!(((((usqInt) (longAt(GIV(firstFieldOfPermToNewRememberedSet))) ) >> (markedBitFullShift())) & 1) != 0)) {
			/* begin updatePointersIn: */
			_obj2 = GIV(firstFieldOfPermToNewRememberedSet);
			/* begin numPointerSlotsOf: */
			_fmt3 = (((usqInt) (longAt(_obj2)) ) >> (formatShift())) & (formatMask());
			if (_fmt3 <= 5) {
				if ((_fmt3 == (indexablePointersFormat())) && (((longAt(_obj2)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
					/* begin fetchStackPointerOf: */
					/* begin fetchPointer:ofObject: */
					_sp3 = unsignedLongAt((_obj2 + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (!(((_sp3 & 7) == 1))) {
						_contextSize3 = 0;
						goto l39;
					}
					assert((ReceiverIndex + (_sp3 >> 3)) < (lengthOf(_obj2)));
					_contextSize3 = _sp3 >> 3;
					l39:
					;
					/* end fetchStackPointerOf: */
					_numPointerSlots3 = CtxtTempFrameStart + _contextSize3;
					goto l34;
				}
				/* begin numSlotsOf: */
				assert((classIndexOf(_obj2)) > (isForwardedObjectClassIndexPun()));
				_numSlots3 = byteAt(_obj2 + 7);
				_numPointerSlots3 = ((_numSlots3 == (numSlotsMask()))
					 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_obj2 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
					 : _numSlots3);
				goto l34;
				/* end numSlotsOf: */
			}
			if (_fmt3 == 7) {
				_numPointerSlots3 = 1;
				goto l34;
			}
			if (_fmt3 < (firstCompiledMethodFormat())) {
				_numPointerSlots3 = 0;
				goto l34;
			}
			/* begin methodHeaderOf: */
			assert(isCompiledMethod(_obj2));
			/* begin fetchPointer:ofObject: */
			_header23 = unsignedLongAt((_obj2 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_header23 & 7) == 1)) {
				_header4 = _header23;
			} else {
				assert(((usqInt) _header23 ) < ((GIV(memoryMap)->newSpaceStart)));
				assert((((((CogMethod *) _header23 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
				_header4 = ((((CogMethod *) _header23 ))->methodHeader);
			}
			/* end methodHeaderOf: */
			{
				assert(((_header4 & 7) == 1));
				_numLiterals3 = (_header4 >> 3) & AlternateHeaderNumLiteralsMask;
			}
			_numPointerSlots3 = _numLiterals3 + LiteralStart;
			l34:
			;
			/* end numPointerSlotsOf: */
			for (_i8 = 0; _i8 < _numPointerSlots3; _i8 += 1) {
				/* begin updatePointer:in: */
				/* begin fetchPointer:ofObject: */
				_oop5 = unsignedLongAt((_obj2 + BaseHeaderSize) + ((sqInt) (((usqInt) _i8 ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_oop5 & (tagMask())) == 0) && ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(_oop5, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_oop5)) ) >> (pinnedBitShift())) & 1) != 0)))) {
					assert(isMarked(_oop5));
					/* begin fetchPointer:ofObject: */
					_fwd4 = unsignedLongAt((_oop5 + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofObject: */
					assert(isPostMobile(_fwd4));
					/* begin storePointerUnchecked:ofObject:withValue: */
					assert(!(isOopForwarded(_obj2)));
					longAtput((_obj2 + BaseHeaderSize) + ((sqInt) (((usqInt) _i8 ) << (shiftForWord())) ), _fwd4);
					/* end storePointerUnchecked:ofObject:withValue: */
				}
				/* end updatePointer:in: */
			}
			/* end updatePointersIn: */
			/* begin mark: */
			/* begin setIsMarkedOf:to: */
			assert(!(isFreeObject(GIV(firstFieldOfPermToNewRememberedSet))));
			unsignedLongAtput(GIV(firstFieldOfPermToNewRememberedSet), (unsignedLongAt(GIV(firstFieldOfPermToNewRememberedSet))) | (1ULL << (markedBitFullShift())));
			/* end setIsMarkedOf:to: */
			/* end mark: */
		}
	}
	/* begin rememberedSetWithIndexDo:startingAt: */
	/* begin getFromPermToNewSpaceRememberedSet */
	self_in_rememberedSetWithIndexDostartingAt2 = GIV(fromPermToNewSpaceRememberedSet);
	/* end getFromPermToNewSpaceRememberedSet */
	for (_i3 = 1; _i3 < ((self_in_rememberedSetWithIndexDostartingAt2->rememberedSetSize)); _i3 += 1) {
		{
			_oop = (self_in_rememberedSetWithIndexDostartingAt2->rememberedSetArray)[_i3];
			if (!(((((usqInt) (longAt(_oop)) ) >> (markedBitFullShift())) & 1) != 0)) {
				/* begin updatePointersIn: */
				/* begin numPointerSlotsOf: */
				_fmt4 = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
				if (_fmt4 <= 5) {
					if ((_fmt4 == (indexablePointersFormat())) && (((longAt(_oop)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
						/* begin fetchStackPointerOf: */
						/* begin fetchPointer:ofObject: */
						_sp4 = unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						if (!(((_sp4 & 7) == 1))) {
							_contextSize4 = 0;
							goto l50;
						}
						assert((ReceiverIndex + (_sp4 >> 3)) < (lengthOf(_oop)));
						_contextSize4 = _sp4 >> 3;
						l50:
						;
						/* end fetchStackPointerOf: */
						_numPointerSlots4 = CtxtTempFrameStart + _contextSize4;
						goto l51;
					}
					/* begin numSlotsOf: */
					assert((classIndexOf(_oop)) > (isForwardedObjectClassIndexPun()));
					_numSlots4 = byteAt(_oop + 7);
					_numPointerSlots4 = ((_numSlots4 == (numSlotsMask()))
						 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_oop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
						 : _numSlots4);
					goto l51;
					/* end numSlotsOf: */
				}
				if (_fmt4 == 7) {
					_numPointerSlots4 = 1;
					goto l51;
				}
				if (_fmt4 < (firstCompiledMethodFormat())) {
					_numPointerSlots4 = 0;
					goto l51;
				}
				/* begin methodHeaderOf: */
				assert(isCompiledMethod(_oop));
				/* begin fetchPointer:ofObject: */
				_header24 = unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_header24 & 7) == 1)) {
					_header5 = _header24;
				} else {
					assert(((usqInt) _header24 ) < ((GIV(memoryMap)->newSpaceStart)));
					assert((((((CogMethod *) _header24 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
					_header5 = ((((CogMethod *) _header24 ))->methodHeader);
				}
				/* end methodHeaderOf: */
				{
					assert(((_header5 & 7) == 1));
					_numLiterals4 = (_header5 >> 3) & AlternateHeaderNumLiteralsMask;
				}
				_numPointerSlots4 = _numLiterals4 + LiteralStart;
				l51:
				;
				/* end numPointerSlotsOf: */
				for (_i9 = 0; _i9 < _numPointerSlots4; _i9 += 1) {
					/* begin updatePointer:in: */
					/* begin fetchPointer:ofObject: */
					_oop6 = unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) _i9 ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (((_oop6 & (tagMask())) == 0) && ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(_oop6, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_oop6)) ) >> (pinnedBitShift())) & 1) != 0)))) {
						assert(isMarked(_oop6));
						/* begin fetchPointer:ofObject: */
						_fwd5 = unsignedLongAt((_oop6 + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofObject: */
						assert(isPostMobile(_fwd5));
						/* begin storePointerUnchecked:ofObject:withValue: */
						assert(!(isOopForwarded(_oop)));
						longAtput((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) _i9 ) << (shiftForWord())) ), _fwd5);
						/* end storePointerUnchecked:ofObject:withValue: */
					}
					/* end updatePointer:in: */
				}
				/* end updatePointersIn: */
				/* begin mark: */
				/* begin setIsMarkedOf:to: */
				assert(!(isFreeObject(_oop)));
				unsignedLongAtput(_oop, (unsignedLongAt(_oop)) | (1ULL << (markedBitFullShift())));
				/* end setIsMarkedOf:to: */
				/* end mark: */
			}
		}
	}
	/* end rememberedSetWithIndexDo:startingAt: */
	if ((((getFromPermToOldSpaceRememberedSet())->rememberedSetSize)) > 0) {
		/* begin setIsMarkedOf:to: */
		assert(!(isFreeObject(GIV(firstFieldOfPermToOldRememberedSet))));
		unsignedLongAtput(GIV(firstFieldOfPermToOldRememberedSet), (unsignedLongAt(GIV(firstFieldOfPermToOldRememberedSet))) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
		/* end setIsMarkedOf:to: */
	}
	if ((((getFromPermToNewSpaceRememberedSet())->rememberedSetSize)) > 0) {
		/* begin setIsMarkedOf:to: */
		assert(!(isFreeObject(GIV(firstFieldOfPermToNewRememberedSet))));
		unsignedLongAtput(GIV(firstFieldOfPermToNewRememberedSet), (unsignedLongAt(GIV(firstFieldOfPermToNewRememberedSet))) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
		/* end setIsMarkedOf:to: */
	}
	/* begin rememberedSetWithIndexDo:startingAt: */
	/* begin getFromPermToNewSpaceRememberedSet */
	self_in_rememberedSetWithIndexDostartingAt3 = GIV(fromPermToNewSpaceRememberedSet);
	/* end getFromPermToNewSpaceRememberedSet */
	for (_i4 = 1; _i4 < ((self_in_rememberedSetWithIndexDostartingAt3->rememberedSetSize)); _i4 += 1) {
		{
			_oop = (self_in_rememberedSetWithIndexDostartingAt3->rememberedSetArray)[_i4];
			/* begin setIsMarkedOf:to: */
			assert(!(isFreeObject(_oop)));
			unsignedLongAtput(_oop, (unsignedLongAt(_oop)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
			/* end setIsMarkedOf:to: */
		}
	}
	/* end rememberedSetWithIndexDo:startingAt: */
	/* begin rememberedSetWithIndexDo:startingAt: */
	/* begin getFromPermToOldSpaceRememberedSet */
	self_in_rememberedSetWithIndexDostartingAt4 = GIV(fromPermToOldSpaceRememberedSet);
	/* end getFromPermToOldSpaceRememberedSet */
	for (_i5 = 1; _i5 < ((self_in_rememberedSetWithIndexDostartingAt4->rememberedSetSize)); _i5 += 1) {
		{
			_oop = (self_in_rememberedSetWithIndexDostartingAt4->rememberedSetArray)[_i5];
			/* begin setIsMarkedOf:to: */
			assert(!(isFreeObject(_oop)));
			unsignedLongAtput(_oop, (unsignedLongAt(_oop)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
			/* end setIsMarkedOf:to: */
		}
	}
	/* end rememberedSetWithIndexDo:startingAt: */
	assert(allPermSpaceObjectsUnmarked());
}
/*	Sweep the pointer fields in obj, updating all references to mobile objects 
	to their eventual locations. 
	firstFieldPtr is supplied for mobile objects so that the saved first field 
	can be updated, and so that 
	the first field of a compiled method (which is its header, or reference to 
	a CogMethod holding its header) 
	can be retrieved. */
/* SpurPlanningCompactor>>#updatePointersIn:savedFirstFieldPointer: */
static void NoDbgRegParms
updatePointersInsavedFirstFieldPointer(sqInt _obj, sqInt _firstFieldPtr)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _contextSize;
	sqInt _field;
	sqInt _fmt;
	sqInt _fwd;
	sqInt _fwd2;
	sqInt _header;
	sqInt _i;
	sqInt _numLiterals;
	sqInt _numPointerSlots;
	usqInt _numSlots;
	sqInt _oop;
	sqInt _oop2;
	sqInt _sp;

	_fmt = (((usqInt) (longAt(_obj)) ) >> (formatShift())) & (formatMask());
	/* begin numPointerSlotsWhileCompactingOf:withFormat:savedFirstFieldPointer: */
	assert((_firstFieldPtr != null) && (isMobile(_obj)));
	if (_fmt <= 5) {
		if ((_fmt == (indexablePointersFormat())) && (((longAt(_obj)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
			/* begin fetchStackPointerOf: */
			/* begin fetchPointer:ofObject: */
			_sp = unsignedLongAt((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (!(((_sp & 7) == 1))) {
				_contextSize = 0;
				goto l6;
			}
			assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_obj)));
			_contextSize = _sp >> 3;
			l6:
			;
			/* end fetchStackPointerOf: */
			_numPointerSlots = CtxtTempFrameStart + _contextSize;
			goto l9;
		}
		/* begin numSlotsOf: */
		assert((classIndexOf(_obj)) > (isForwardedObjectClassIndexPun()));
		_numSlots = byteAt(_obj + 7);
		_numPointerSlots = ((_numSlots == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_obj - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots);
		goto l9;
		/* end numSlotsOf: */
	}
	assert(!(_fmt == (forwardedFormat())));
	if (_fmt < (firstCompiledMethodFormat())) {
		_numPointerSlots = 0;
		goto l9;
	}
	/* begin methodHeaderFromSavedFirstField: */
	_field = longAt(_firstFieldPtr);
	if (((_field & 7) == 1)) {
		_header = _field;
		goto l7;
	}
	assert((isNonImmediate(_field)) && (_field < ((GIV(memoryMap)->newSpaceStart))));
	assert((((((CogMethod *) _field ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
	_header = ((((CogMethod *) _field ))->methodHeader);
	l7:
	;
	/* end methodHeaderFromSavedFirstField: */
	{
		assert(((_header & 7) == 1));
		_numLiterals = (_header >> 3) & AlternateHeaderNumLiteralsMask;
	}
	_numPointerSlots = _numLiterals + LiteralStart;
	l9:
	;
	/* end numPointerSlotsWhileCompactingOf:withFormat:savedFirstFieldPointer: */
	if ((_fmt <= 5) && (_numPointerSlots > 0)) {
		_oop = longAt(_firstFieldPtr);
		if (((_oop & (tagMask())) == 0) && ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(_oop, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_oop)) ) >> (pinnedBitShift())) & 1) != 0)))) {
			assert(isMarked(_oop));
			/* begin fetchPointer:ofObject: */
			_fwd = unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofObject: */
			assert(isPostMobile(_fwd));
			longAtput(_firstFieldPtr, _fwd);
		}
	}
	for (_i = 1; _i < _numPointerSlots; _i += 1) {
		/* begin updatePointer:in: */
		/* begin fetchPointer:ofObject: */
		_oop2 = unsignedLongAt((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_oop2 & (tagMask())) == 0) && ((oopisGreaterThanOrEqualToandLessThanOrEqualTo(_oop2, GIV(mobileStart), GIV(lastMobileObject))) && (!(((((usqInt) (longAt(_oop2)) ) >> (pinnedBitShift())) & 1) != 0)))) {
			assert(isMarked(_oop2));
			/* begin fetchPointer:ofObject: */
			_fwd2 = unsignedLongAt((_oop2 + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofObject: */
			assert(isPostMobile(_fwd2));
			/* begin storePointerUnchecked:ofObject:withValue: */
			assert(!(isOopForwarded(_obj)));
			longAtput((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _fwd2);
			/* end storePointerUnchecked:ofObject:withValue: */
		}
		/* end updatePointer:in: */
	}
}
/*	Attempt to allocate a memory segment large enough to hold the 
	savedFirstFieldsSpace. Invoked when neither eden nor a large free chunk 
	are found to be big enough for the job. */
/* SpurPlanningCompactor>>#useSegmentForSavedFirstFieldsSpace: */
static sqInt NoDbgRegParms
useSegmentForSavedFirstFieldsSpace(sqInt _spaceEstimate)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMMemoryMap * self_in_allocateSegmentOfSizeminAddressresultsIn;
	sqInt _allocatedSize;
	sqInt _limit;
	sqInt _minAddress;
	sqInt _roundedSize;
	void *_segAddress;
	void *_segmentAddress;
	size_t _sizeToRequest;
	sqInt _theLimit;
	sqInt _theStart;

	_roundedSize = ((_spaceEstimate + 0x3FF) / 1024) * 1024;
	/* begin allocateSegmentOfSize:minAddress:resultsIn: */
	/* begin getMemoryMap */
	self_in_allocateSegmentOfSizeminAddressresultsIn = GIV(memoryMap);
	/* end getMemoryMap */
	_minAddress = ((sqInt) (firstGapOfSizeAtLeast(_roundedSize)) );
	_sizeToRequest = roundToAllocationSize(self_in_allocateSegmentOfSizeminAddressresultsIn, _roundedSize);
	_segmentAddress = allocateMemoryBaseAddress(_sizeToRequest, _minAddress);
	{
		_allocatedSize = _sizeToRequest;
		_segAddress = _segmentAddress;
	}
	/* end allocateSegmentOfSize:minAddress:resultsIn: */
	if (_segAddress) {
		/* begin configureSavedFirstFieldsSpaceStart:limit:isOldSpace: */
		_theStart = ((usqIntptr_t) _segAddress );
		_theLimit = ((usqIntptr_t) _segAddress ) + _allocatedSize;
		_limit = _theLimit;
		if (GIV(savedFirstFieldSpaceMaxSlots)) {
			_limit = ((_limit < (_theStart + (GIV(savedFirstFieldSpaceMaxSlots) * BytesPerOop))) ? _limit : _theStart + (GIV(savedFirstFieldSpaceMaxSlots) * BytesPerOop));
		}
		{
			(GIV(savedFirstFieldsSpace).start = _theStart);
			(GIV(savedFirstFieldsSpace).limit = _limit);
		}
		GIV(savedFirstFieldsSpaceNotInOldSpace) = !0;
		/* end configureSavedFirstFieldsSpaceStart:limit:isOldSpace: */
		assert(savedFirstFieldsSpaceWasAllocated());
		return 1;
	}
	return 0;
}
/*	Answer 0 if all the mobile objects from firstMobileObject to 
	lastMobileObject have sane forwarding addresses, and that 
	savedFirstFieldsSpace is of 
	matching capacity. Otherwise answer an error code identifying the anomaly. */
/* SpurPlanningCompactor>>#validRelocationPlanInPass: */
static sqInt NoDbgRegParms
validRelocationPlanInPass(sqInt onePass)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _destination;
	sqInt _followingWord;
	usqInt _followingWordAddress;
	sqInt _limit;
	int _nMobiles;
	sqInt _objOop;
	sqInt _prevObj;
	sqInt _prevPrevObj;
	usqInt _toFinger;

	_nMobiles = 0;
	_toFinger = GIV(mobileStart);
	GIV(anomaly) = null;
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(firstMobileObject)));
	_prevPrevObj = (_prevObj = null);
	_objOop = GIV(firstMobileObject);
	while (1) {
		assert((_objOop % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop)) != 0);
		{
			if (((((usqInt) (longAt(_objOop)) ) >> (markedBitFullShift())) & 1) != 0) {
				if (!(((((usqInt) (longAt(_objOop)) ) >> (pinnedBitShift())) & 1) != 0)) {
					_nMobiles += 1;
					/* begin fetchPointer:ofObject: */
					_destination = unsignedLongAt((_objOop + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofObject: */
					if (!(_destination >= _toFinger)) {
						GIV(anomaly) = _objOop;
						return 1;
					}
					_toFinger += bytesInObject(_objOop);
					if (oopisGreaterThan(_objOop, GIV(lastMobileObject))) {
						GIV(anomaly) = _objOop;
						return 2;
					}
					if (_objOop == GIV(lastMobileObject)) {
						return (((((((GIV(savedFirstFieldsSpace).top)) + BytesPerOop) - ((GIV(savedFirstFieldsSpace).start))) / BytesPerOop) == _nMobiles)
							 ? 0
							 : 3);
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop;
		/* begin objectAfter:limit: */
		_limit = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress = addressAfter(_objOop);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop = _limit;
			goto l3;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l3:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	return (((((((GIV(savedFirstFieldsSpace).top)) + BytesPerOop) - ((GIV(savedFirstFieldsSpace).start))) / BytesPerOop) == _nMobiles)
		 ? 0
		 : 4);
}
/* SpurSegmentInfo>>#segLimit */
static usqInt NoDbgRegParms
segLimit(SpurSegmentInfo * self_in_segLimit)
{
	return ((self_in_segLimit->segSize)) + ((self_in_segLimit->segStart));
}
/* SpurSegmentManager>>#addSegmentOfSize: */
static SpurSegmentInfo * NoDbgRegParms
addSegmentOfSize(sqInt _ammount)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	VMMemoryMap * self_in_allocateSegmentOfSizeminAddressresultsIn;
	usqInt _allocatedSize;
	sqInt _i;
	sqInt _idx;
	sqInt _lastSegIndex;
	sqInt _minAddress;
	SpurSegmentInfo *_newSeg;
	sqInt _newSegIndex;
	void *_segAddress;
	sqInt _segAddress2;
	sqInt _segIndex;
	void *_segmentAddress;
	size_t _sizeToRequest;

	_newSegIndex = 0;
	/* begin allocateSegmentOfSize:minAddress:resultsIn: */
	/* begin getMemoryMap */
	self_in_allocateSegmentOfSizeminAddressresultsIn = GIV(memoryMap);
	/* end getMemoryMap */
	_minAddress = ((sqInt) (firstGapOfSizeAtLeast(_ammount)) );
	_sizeToRequest = roundToAllocationSize(self_in_allocateSegmentOfSizeminAddressresultsIn, _ammount);
	_segmentAddress = allocateMemoryBaseAddress(_sizeToRequest, _minAddress);
	{
		_allocatedSize = _sizeToRequest;
		_segAddress = _segmentAddress;
	}
	/* end allocateSegmentOfSize:minAddress:resultsIn: */
	if (_segAddress) {
		/* begin insertSegmentFor: */
		_segAddress2 = ((usqIntptr_t) _segAddress );
		assert(_segAddress2 >= (segLimit(&(GIV(segments)[0]))));
		if (GIV(numSegments) == GIV(numSegInfos)) {
			allocateOrExtendSegmentInfos();
		}
		assert(GIV(numSegments) < GIV(numSegInfos));
		_segIndex = (_lastSegIndex = GIV(numSegments) - 1);
		GIV(numSegments) += 1;
		while (1) {
			if (_segAddress2 >= ((((GIV(segments)[_segIndex]).segSize)) + (((GIV(segments)[_segIndex]).segStart)))) {
				_segIndex += 1;
				for (_idx = _lastSegIndex; _idx >= _segIndex; _idx += -1) {
					GIV(segments)[_idx + 1] = GIV(segments)[_idx];
				}
				_newSegIndex = _segIndex;
				goto l2;
			}
			_segIndex -= 1;
		}
		l2:
		;
		/* end insertSegmentFor: */
		_newSeg = &(GIV(segments)[_newSegIndex]);
		{
			(_newSeg->segStart = ((usqIntptr_t) _segAddress ));
			(_newSeg->segSize = _allocatedSize);
			(_newSeg->swizzle = 0);
		}
		assert(!(segmentOverlap()));
		bridgeFromto(&(GIV(segments)[_newSegIndex - 1]), _newSeg);
		bridgeFromto(_newSeg, ((!(_newSegIndex == (GIV(numSegments) - 1)))
			 ? &(GIV(segments)[_newSegIndex + 1])
			 : 0));
		GIV(totalHeapSizeIncludingBridges) += _allocatedSize;
		for (_i = 0; _i < GIV(numSegments); _i += 1) {
			assert(isInSegments(((GIV(segments)[_i]).segStart)));
			assert(isInSegments((segLimit(&(GIV(segments)[_i]))) - BytesPerWord));
			assert((!(isInSegments(segLimit(&(GIV(segments)[_i]))))) || ((_i < (GIV(numSegments) - 1)) && ((segLimit(&(GIV(segments)[_i]))) == (((GIV(segments)[_i + 1]).segStart)))));
			assert((!(isInSegments((((GIV(segments)[_i]).segStart)) - BytesPerWord))) || ((_i > 0) && ((segLimit(&(GIV(segments)[_i - 1]))) == (((GIV(segments)[_i]).segStart)))));
		}
		return _newSeg;
	}
	return null;
}
/* SpurSegmentManager>>#allBridgesMarked */
static sqInt
allBridgesMarked(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	SpurSegmentInfo *_aSegment;
	sqInt _bridgeObj;
	sqInt _i;
	usqInt _numSlots;

	for (_i = 0; _i < GIV(numSegments); _i += 1) {
		/* begin bridgeFor: */
		_aSegment = ((SpurSegmentInfo *) (&(GIV(segments)[_i])) );
		/* begin objectStartingAt: */
		_address = (((_aSegment->segSize)) + ((_aSegment->segStart))) - (2 * BaseHeaderSize);
		_numSlots = byteAt(_address + 7);
		_bridgeObj = ((_numSlots == (numSlotsMask()))
			 ? _address + BaseHeaderSize
			 : _address);
		/* end objectStartingAt: */
		/* end bridgeFor: */
		assert(isValidSegmentBridge(_bridgeObj));
		if (!(((((usqInt) (longAt(_bridgeObj)) ) >> (markedBitFullShift())) & 1) != 0)) {
			return 0;
		}
	}
	return 1;
}
/*	Increase the number of allocated segInfos by 16. */
/* SpurSegmentManager>>#allocateOrExtendSegmentInfos */
static void
allocateOrExtendSegmentInfos(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _newNumSegs;

	if (GIV(numSegInfos) == 0) {
		GIV(numSegInfos) = 16;
		GIV(segments) = calloc(GIV(numSegInfos), sizeof(SpurSegmentInfo));
		return;
	}
	_newNumSegs = GIV(numSegInfos) + 16;
	GIV(segments) = realloc(GIV(segments), _newNumSegs * (sizeof(SpurSegmentInfo)));
	{
		if (GIV(segments) == 0) {
			error("out of memory; cannot allocate more segments");
		}
		memset(GIV(segments) + GIV(numSegInfos), 0, (_newNumSegs - GIV(numSegInfos)) * (sizeof(SpurSegmentInfo)));
	}
	GIV(numSegInfos) = _newNumSegs;
}
/* SpurSegmentManager>>#bridgeAt: */
static sqInt NoDbgRegParms
bridgeAt(sqInt _segIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	usqInt _numSlots;

	/* begin objectStartingAt: */
	_address = ((((&(GIV(segments)[_segIndex]))->segSize)) + (((&(GIV(segments)[_segIndex]))->segStart))) - (2 * BaseHeaderSize);
	_numSlots = byteAt(_address + 7);
	return ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
}
/* SpurSegmentManager>>#bridgeFor: */
static sqInt NoDbgRegParms
bridgeFor(SpurSegmentInfo *_aSegment)
{
	sqInt _address;
	usqInt _numSlots;

	/* begin objectStartingAt: */
	_address = (((_aSegment->segSize)) + ((_aSegment->segStart))) - (2 * BaseHeaderSize);
	_numSlots = byteAt(_address + 7);
	return ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
}
/*	Create a bridge from aSegment to the next segment, 
	or create a terminating bridge if there is no next segment. */
/* SpurSegmentManager>>#bridgeFrom:to: */
static void NoDbgRegParms
bridgeFromto(SpurSegmentInfo *_aSegment, SpurSegmentInfo *_nextSegmentOrNil)
{
	sqInt _bridgeSpan;
	sqInt _clifton;
	usqInt _segEnd;

	_segEnd = ((_aSegment->segSize)) + ((_aSegment->segStart));
	_clifton = _segEnd - (2 * BaseHeaderSize);
	if (_nextSegmentOrNil == null) {
		/* begin bridgeSize */
		_bridgeSpan = 2 * BaseHeaderSize;
		/* end bridgeSize */
	} else {
		_bridgeSpan = (((_nextSegmentOrNil->segStart)) - _segEnd) + (2 * BaseHeaderSize);
	}
	assert(_bridgeSpan >= 0);
	initSegmentBridgeWithBytesat(_bridgeSpan, _clifton);
	assert((addressAfter(objectStartingAt(_clifton))) == (((_nextSegmentOrNil == null)
		 ? segLimit(_aSegment)
		 : (_nextSegmentOrNil->segStart))));
}
/* SpurSegmentManager>>#checkSegments */
static void
checkSegments(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;

	assert(GIV(numSegments) >= 1);
	for (_i = 0; _i < GIV(numSegments); _i += 1) {
		assert(addressCouldBeObj(((GIV(segments)[_i]).segStart)));
		assert(isValidSegmentBridge(bridgeAt(_i)));
	}
	assert(((segLimit(&(GIV(segments)[GIV(numSegments) - 1]))) - (bridgeSize())) == (((getMemoryMap())->oldSpaceEnd)));
}
/*	The image has been loaded, old segments reconstructed, and the heap 
	swizzled into a single contiguous segment. Collapse the segments into one. */
/* SpurSegmentManager>>#collapseSegmentsPostSwizzle */
static void
collapseSegmentsPostSwizzle(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	SpurSegmentInfo * cascade0;

	GIV(canSwizzle) = 0;
	GIV(numSegments) = 1;
	{
		cascade0 = &(GIV(segments)[0]);
		(cascade0->segStart = ((getMemoryMap())->oldSpaceStart));
		(cascade0->segSize = (GIV(totalHeapSizeIncludingBridges) = (((getMemoryMap())->oldSpaceEnd)) - (((getMemoryMap())->oldSpaceStart))));
	}
}
/*	Answer the segment limit of the first segment followed by a gap of at 
	least size bytes. */
/* SpurSegmentManager>>#firstGapOfSizeAtLeast: */
static void * NoDbgRegParms
firstGapOfSizeAtLeast(sqInt _size)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _bridge;
	sqInt _i;
	usqInt _numSlots;

	for (_i = 0; _i <= (GIV(numSegments) - 2); _i += 1) {
		/* begin objectStartingAt: */
		_address = ((((&(GIV(segments)[_i]))->segSize)) + (((&(GIV(segments)[_i]))->segStart))) - (2 * BaseHeaderSize);
		_numSlots = byteAt(_address + 7);
		_bridge = ((_numSlots == (numSlotsMask()))
			 ? _address + BaseHeaderSize
			 : _address);
		/* end objectStartingAt: */
		if (((bytesInObject(_bridge)) - (2 * BaseHeaderSize)) >= _size) {
			return ((void *) ((((GIV(segments)[_i]).segSize)) + (((GIV(segments)[_i]).segStart))) );
		}
	}
	return ((void *) ((((GIV(segments)[GIV(numSegments) - 1]).segSize)) + (((GIV(segments)[GIV(numSegments) - 1]).segStart))) );
}
/* SpurSegmentManager>>#firstSegmentBytes */
static size_t
firstSegmentBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((GIV(segments)[0]).segSize);
}
/* SpurSegmentManager>>#isEmptySegment: */
static sqInt NoDbgRegParms
isEmptySegment(SpurSegmentInfo *_seg)
{
	sqInt _address;
	sqInt _firstObj;
	usqInt _numSlots;

	/* begin objectStartingAt: */
	_address = (_seg->segStart);
	_numSlots = byteAt(_address + 7);
	_firstObj = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	return (((longAt(_firstObj)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) && ((addressAfter(_firstObj)) == ((((_seg->segSize)) + ((_seg->segStart))) - (2 * BaseHeaderSize)));
}
/* SpurSegmentManager>>#isInSegments: */
static sqInt NoDbgRegParms
isInSegments(usqInt _address)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;

	for (_i = 0; _i < GIV(numSegments); _i += 1) {
		if (_address < (((GIV(segments)[_i]).segStart))) {
			return 0;
		}
		if (_address < ((((GIV(segments)[_i]).segSize)) + (((GIV(segments)[_i]).segStart)))) {
			return 1;
		}
	}
	return 0;
}
/*	bridges bridge the gaps between segments. They are the last object in each 
	segment.  */
/* SpurSegmentManager>>#isValidSegmentBridge: */
static sqInt NoDbgRegParms
isValidSegmentBridge(sqInt _objOop)
{
	return ((addressCouldBeObj(_objOop)) || (_objOop == (((getMemoryMap())->oldSpaceEnd)))) && ((((longAt(_objOop)) & (classIndexMask())) == (segmentBridgePun())) && (((byteAt(_objOop + 7)) == (numSlotsMask())) || ((numSlotsOfAny(_objOop)) == 0)));
}
/*	Answer the the next non-empty segment or nil. The size of a segment 
	includes that of its bridge. A segment containing just a free object and a 
	bridge will still 
	have a size of manager bridgeSize after shortening it in 
	prepareForSnapshot.  */
/* SpurSegmentManager>>#nextNonEmptySegmentAfter: */
static SpurSegmentInfo * NoDbgRegParms
nextNonEmptySegmentAfter(sqInt _i)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _nextx;

	_nextx = _i;
	while (1) {
		if (((_nextx += 1)) >= GIV(numSegments)) {
			return null;
		}
		if ((((GIV(segments)[_nextx]).segSize)) > (2 * BaseHeaderSize)) {
			return &(GIV(segments)[_nextx]);
		}
	}
	return 0;
}
/*	Restore all shortened segments to their proper size, re-freeing the 
	trailing space. */
/* SpurSegmentManager>>#postSnapshot */
static void
postSnapshot(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _bytes;
	usqInt _freeChunk;
	sqInt _i;
	sqInt _newEndOfMemory;
	SpurSegmentInfo *_seg;

	_seg = &(GIV(segments)[GIV(numSegments) - 1]);
	if (((_seg->lastFreeObject)) == null) {
		assert((((getMemoryMap())->oldSpaceEnd)) == ((segLimit(_seg)) - (bridgeSize())));
	} else {
		/* begin setEndOfMemory: */
		_newEndOfMemory = (((_seg->savedSegSize)) + ((_seg->segStart))) - (2 * BaseHeaderSize);
		/* begin setOldSpaceEnd: */
		(GIV(memoryMap)->oldSpaceEnd) = _newEndOfMemory;
		assert((((GIV(memoryMap)->permSpaceStart)) == 0) || (_newEndOfMemory < ((GIV(memoryMap)->permSpaceStart))));
		/* end setOldSpaceEnd: */
		if (GIV(freeOldSpaceStart) > _newEndOfMemory) {
			GIV(freeOldSpaceStart) = _newEndOfMemory;
		}
		/* end setEndOfMemory: */
	}
	for (_i = GIV(numSegments) - 1; _i >= 0; _i += -1) {
		_seg = &(GIV(segments)[_i]);
		{
			_freeChunk = (_seg->lastFreeObject);
			if (!(_freeChunk == null)) {
				_address = (((_seg->segSize)) + ((_seg->segStart))) - (2 * BaseHeaderSize);
				(_seg->segSize = (_seg->savedSegSize));
				bridgeFromto(_seg, ((_i < (GIV(numSegments) - 1))
					 ? &(GIV(segments)[_i + 1])
					 : 0));
				/* begin addFreeChunkWithBytes:at: */
				_bytes = ((((_seg->segSize)) + ((_seg->segStart))) - _address) - (2 * BaseHeaderSize);
				GIV(totalFreeOldSpace) += _bytes;
				freeChunkWithBytesat(_bytes, _address);
				/* end addFreeChunkWithBytes:at: */
			}
		}
	}
	checkSegments();
	/* begin checkFreeSpace: */
	assert(bitsSetInFreeSpaceMaskForAllFreeLists());
	assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
	if ((checkForLeaks & (GCModeFreeSpace | GCModeFull)) == (GCModeFreeSpace | GCModeFull)) {
		runLeakCheckerForFreeSpace(GCModeFreeSpace);
	}
	/* end checkFreeSpace: */
}
/*	shorten all segments by any trailing free space. */
/* SpurSegmentManager>>#prepareForSnapshot */
static void NeverInline
prepareForSnapshot(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	SpurSegmentInfo * cascade0;
	sqInt _cameFrom;
	usqInt _chunkBytes;
	sqInt _fieldIndex;
	sqInt _fieldIndex2;
	sqInt _fieldIndex3;
	sqInt _fieldIndex4;
	sqInt _followingWord;
	usqInt _followingWordAddress;
	usqInt _freeChunk;
	sqInt _i;
	sqInt _i2;
	sqInt _largeChild;
	sqInt _limit;
	sqInt _newEndOfMemory;
	sqInt _next;
	usqInt _node;
	SpurSegmentInfo *_seg;
	sqInt _smallChild;
	sqInt _treeNode;

	checkSegments();
	for (_i = 0; _i < GIV(numSegments); _i += 1) {
		{
			cascade0 = &(GIV(segments)[_i]);
			(cascade0->savedSegSize = ((GIV(segments)[_i]).segSize));
			(cascade0->lastFreeObject = null);
		}
	}
	/* begin freeTreeNodesDo: */
	_treeNode = GIV(freeLists)[0];
	if (_treeNode == 0) {
		goto l6;
	}
	_cameFrom = -1;
	do {
		assert((bytesInObject(_treeNode)) >= ((numFreeLists()) * (allocationUnit())));
		/* begin fetchPointer:ofFreeChunk: */
		_fieldIndex2 = 3;
		_smallChild = unsignedLongAt((_treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex2 ) << (shiftForWord())) ));
		/* end fetchPointer:ofFreeChunk: */
		/* begin fetchPointer:ofFreeChunk: */
		_fieldIndex3 = 4;
		_largeChild = unsignedLongAt((_treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex3 ) << (shiftForWord())) ));
		/* end fetchPointer:ofFreeChunk: */
		assert((_smallChild == 0) || (_treeNode == (fetchPointerofFreeChunk(freeChunkParentIndex(), _smallChild))));
		assert((_largeChild == 0) || (_treeNode == (fetchPointerofFreeChunk(freeChunkParentIndex(), _largeChild))));
		if (((_smallChild == 0) && (_largeChild == 0)) || (((_largeChild == 0)
			 ? _cameFrom == _smallChild
			 : _cameFrom == _largeChild))) {
			{
				_node = _treeNode;
				while (_node != 0) {
					/* begin objectAfter:limit: */
					_limit = ((sqInt) (((getMemoryMap())->oldSpaceEnd)) );
					_followingWordAddress = addressAfter(_node);
					if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
						_next = _limit;
						goto l11;
					}
					flag("endianness");
					_followingWord = unsignedLongAt(_followingWordAddress);
					_next = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
						 ? _followingWordAddress + BaseHeaderSize
						 : _followingWordAddress);
					l11:
					;
					/* end objectAfter:limit: */
					if (((longAt(_next)) & (classIndexMask())) == (segmentBridgePun())) {
						/* begin segmentContainingObj: */
						for (_i2 = GIV(numSegments) - 1; _i2 >= 0; _i2 += -1) {
							if (_node >= (((GIV(segments)[_i2]).segStart))) {
								_seg = &(GIV(segments)[_i2]);
								goto l10;
							}
						}
						_seg = null;
						l10:
						;
						/* end segmentContainingObj: */
						(_seg->lastFreeObject = _node);
						_node = 0;
					} else {
						/* begin fetchPointer:ofFreeChunk: */
						_fieldIndex = 0;
						_node = unsignedLongAt((_node + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
						/* end fetchPointer:ofFreeChunk: */
					}
				}
			}
			_cameFrom = _treeNode;
			/* begin fetchPointer:ofFreeChunk: */
			_fieldIndex4 = 2;
			_treeNode = unsignedLongAt((_treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex4 ) << (shiftForWord())) ));
			/* end fetchPointer:ofFreeChunk: */
		} else {
			if ((_smallChild != 0) && (_cameFrom != _smallChild)) {
				_treeNode = _smallChild;
			} else {
				assert(_largeChild != 0);
				_treeNode = _largeChild;
			}
			_cameFrom = -1;
		}
	} while (_treeNode != 0);
	l6:
	;
	/* end freeTreeNodesDo: */
	for (_i = 0; _i < GIV(numSegments); _i += 1) {
		{
			_freeChunk = ((GIV(segments)[_i]).lastFreeObject);
			if (!(_freeChunk == null)) {
				/* begin detachFreeObject: */
				_chunkBytes = bytesInObject(_freeChunk);
				GIV(totalFreeOldSpace) -= _chunkBytes;
				unlinkFreeChunkchunkBytes(_freeChunk, _chunkBytes);
				/* end detachFreeObject: */
				((GIV(segments)[_i]).segSize = (((((byteAt(_freeChunk + 7)) == (numSlotsMask()))
					 ? _freeChunk - BaseHeaderSize
					 : _freeChunk)) + (2 * BaseHeaderSize)) - (((GIV(segments)[_i]).segStart)));
				bridgeFromto(&(GIV(segments)[_i]), ((_i < (GIV(numSegments) - 1))
					 ? &(GIV(segments)[_i + 1])
					 : 0));
			}
		}
	}
	/* begin setEndOfMemory: */
	_newEndOfMemory = ((((GIV(segments)[GIV(numSegments) - 1]).segSize)) + (((GIV(segments)[GIV(numSegments) - 1]).segStart))) - (2 * BaseHeaderSize);
	/* begin setOldSpaceEnd: */
	(GIV(memoryMap)->oldSpaceEnd) = _newEndOfMemory;
	assert((((GIV(memoryMap)->permSpaceStart)) == 0) || (_newEndOfMemory < ((GIV(memoryMap)->permSpaceStart))));
	/* end setOldSpaceEnd: */
	if (GIV(freeOldSpaceStart) > _newEndOfMemory) {
		GIV(freeOldSpaceStart) = _newEndOfMemory;
	}
	/* end setEndOfMemory: */
}
/* SpurSegmentManager>>#segmentContainingObj: */
EXPORT(SpurSegmentInfo *)
segmentContainingObj(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;

	for (_i = GIV(numSegments) - 1; _i >= 0; _i += -1) {
		if (_objOop >= (((GIV(segments)[_i]).segStart))) {
			return &(GIV(segments)[_i]);
		}
	}
	return null;
}
/*	Answers true if a segment overlaps with another one. */
/* SpurSegmentManager>>#segmentOverlap */
static sqInt
segmentOverlap(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _endi;
	usqInt _endj;
	sqInt _i;
	sqInt _j;
	usqInt _starti;
	usqInt _startj;

	for (_i = 0; _i < GIV(numSegments); _i += 1) {
		_starti = ((GIV(segments)[_i]).segStart);
		_endi = (((GIV(segments)[_i]).segSize)) + (((GIV(segments)[_i]).segStart));
		for (_j = 0; _j < GIV(numSegments); _j += 1) {
			_startj = ((GIV(segments)[_j]).segStart);
			_endj = (((GIV(segments)[_j]).segSize)) + (((GIV(segments)[_j]).segStart));
			if (!(_i == _j)) {
				if (!((_starti < _startj) || (_starti >= _endj))) {
					return 1;
				}
				if (!((_endi <= _startj) || (_endi >= _endj))) {
					return 1;
				}
			}
		}
	}
	return 0;
}
/*	Answer if any shrinkage was achieved. */
/* SpurSegmentManager>>#shrinkObjectMemory: */
static sqInt NoDbgRegParms
shrinkObjectMemory(usqInt _delta)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	SpurSegmentInfo *_best;
	usqInt _chunkBytes;
	usqInt _currentEnd;
	sqInt _delta2;
	SpurSegmentInfo *_emptySeg;
	sqInt _freeChunk;
	sqInt _i;
	sqInt _i2;
	sqInt _i3;
	sqInt _j;
	usqInt _numSlots;
	SpurSegmentInfo *_seg;
	SpurSegmentInfo *_segInfo;
	usqInt _shrinkage;

	/* begin checkFreeSpace: */
	assert(bitsSetInFreeSpaceMaskForAllFreeLists());
	_i = 0;
	assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
	if ((checkForLeaks & (GCModeFreeSpace | GCModeFreeSpace)) == (GCModeFreeSpace | GCModeFreeSpace)) {
		runLeakCheckerForFreeSpace(GCModeFreeSpace);
	}
	/* end checkFreeSpace: */
	_shrinkage = _delta;
	while (1) {
		/* begin findEmptySegNearestInSizeTo: */
		_best = null;
		_delta2 = _shrinkage;
		for (_i3 = 0; _i3 < GIV(numSegments); _i3 += 1) {
			_seg = &(GIV(segments)[_i3]);
			if (isEmptySegment(_seg)) {
				if (_best == null) {
					_best = _seg;
				} else {
					if ((_shrinkage >= (((_seg->segSize)) * 0.75)) && ((SQABS(((sqInt) (((_seg->segSize)) - _shrinkage) ))) < _delta2)) {
						_best = _seg;
						_delta2 = SQABS(((sqInt) (((_seg->segSize)) - _shrinkage) ));
					}
				}
			}
		}
		_emptySeg = _best;
		/* end findEmptySegNearestInSizeTo: */
		if ((_emptySeg == null) || (((_emptySeg->segSize)) > _shrinkage)) {
			/* begin checkFreeSpace: */
			assert(bitsSetInFreeSpaceMaskForAllFreeLists());
			assert(GIV(totalFreeOldSpace) == (totalFreeListBytes()));
			if ((checkForLeaks & (GCModeFreeSpace | GCModeFreeSpace)) == (GCModeFreeSpace | GCModeFreeSpace)) {
				runLeakCheckerForFreeSpace(GCModeFreeSpace);
			}
			/* end checkFreeSpace: */
			return _shrinkage < _delta;
		}
		_shrinkage -= (_emptySeg->segSize);
		/* begin detachFreeObject: */
		/* begin objectStartingAt: */
		_address = (_emptySeg->segStart);
		_numSlots = byteAt(_address + 7);
		_freeChunk = ((_numSlots == (numSlotsMask()))
			 ? _address + BaseHeaderSize
			 : _address);
		/* end objectStartingAt: */
		_chunkBytes = bytesInObject(_freeChunk);
		GIV(totalFreeOldSpace) -= _chunkBytes;
		unlinkFreeChunkchunkBytes(_freeChunk, _chunkBytes);
		/* end detachFreeObject: */
		/* begin removeSegment: */
		/* begin indexOfSegment: */
		for (_i2 = 0; _i2 < GIV(numSegments); _i2 += 1) {
			if (((_emptySeg->segStart)) == (((GIV(segments)[_i2]).segStart))) {
				_i = _i2;
				goto l2;
			}
		}
		error("segment not found");
		l2:
		;
		/* end indexOfSegment: */
		assert(_i > 0);
		GIV(totalHeapSizeIncludingBridges) -= (_emptySeg->segSize);
		sqDeallocateMemorySegmentAtOfSize(((void *) ((_emptySeg->segStart)) ), (_emptySeg->segSize));
		for (_j = _i; _j <= (GIV(numSegments) - 2); _j += 1) {
			GIV(segments)[_j] = GIV(segments)[_j + 1];
		}
		GIV(numSegments) -= 1;
		bridgeFromto(&(GIV(segments)[_i - 1]), ((_i <= (GIV(numSegments) - 1))
			 ? &(GIV(segments)[_i])
			 : 0));
		/* begin setLastSegment: */
		_segInfo = ((SpurSegmentInfo *) (&(GIV(segments)[GIV(numSegments) - 1])) );
		_currentEnd = (((_segInfo->segSize)) + ((_segInfo->segStart))) - (2 * BaseHeaderSize);
		if (_currentEnd <= ((GIV(memoryMap)->oldSpaceEnd))) {
			/* begin setOldSpaceEnd: */
			(GIV(memoryMap)->oldSpaceEnd) = _currentEnd;
			assert((((GIV(memoryMap)->permSpaceStart)) == 0) || (_currentEnd < ((GIV(memoryMap)->permSpaceStart))));
			/* end setOldSpaceEnd: */
			if (GIV(freeOldSpaceStart) > _currentEnd) {
				GIV(freeOldSpaceStart) = _currentEnd;
			}
		}
		/* end setLastSegment: */
		/* end removeSegment: */
	}
	return 0;
}
/* SpurSegmentManager>>#someSegmentContainsPinned */
static sqInt
someSegmentContainsPinned(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;

	for (_i = 0; _i < GIV(numSegments); _i += 1) {
		if (((GIV(segments)[_i]).containsPinned)) {
			return 1;
		}
	}
	return 0;
}
/* SpurSegmentManager>>#swizzleObj: */
static sqInt NoDbgRegParms
swizzleObj(sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;

	assert(GIV(canSwizzle));
	if (_objOop >= 0x20000000000LL) {
		return _objOop;
	}
	for (_i = GIV(numSegments) - 1; _i >= 1; _i += -1) {
		if (_objOop >= (((GIV(segments)[_i]).segStart))) {
			return _objOop + (((GIV(segments)[_i]).swizzle));
		}
	}
	return _objOop + (((GIV(segments)[0]).swizzle));
}
/* SpurSegmentManager>>#totalBytesInNonEmptySegments */
static size_t
totalBytesInNonEmptySegments(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	size_t _total;

	_total = 0;
	for (_i = 0; _i < GIV(numSegments); _i += 1) {
		if ((((GIV(segments)[_i]).segSize)) > (2 * BaseHeaderSize)) {
			_total += ((GIV(segments)[_i]).segSize);
		}
	}
	return _total;
}
/* SpurSegmentManager>>#totalBytesInSegments */
static usqInt
totalBytesInSegments(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	usqInt _total;

	_total = 0;
	for (_i = 0; _i < GIV(numSegments); _i += 1) {
		_total += ((GIV(segments)[_i]).segSize);
	}
	assert(GIV(totalHeapSizeIncludingBridges) == _total);
	return _total;
}
/*	Answer the current activeProcess.useful for VM debugging */
/* StackInterpreter>>#activeProcess */
sqInt
activeProcess(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _objOop;
	sqInt _objOop2;

	/* begin memoryActiveProcess */
	/* begin fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	return unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end memoryActiveProcess */
}
/*	The various poll/select calls in the VM should attempt to tally the 
	ammount of time spent at idle here, so as to render the uptime value 
	meaningful.  */
/* StackInterpreter>>#addIdleUsecs: */
void
addIdleUsecs(sqInt _idleUsecs)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	GIV(statIdleUsecs) += _idleUsecs;
}
/*	Add the given process to the end of the given linked list 
	and set the backpointer of process to its new list. */
/* StackInterpreter>>#addLastLink:toList: */
static void NoDbgRegParms
addLastLinktoList(sqInt _proc, sqInt _aList)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _lastLink;

	assert(!(isForwarded(_proc)));
	assert(!(isForwarded(_aList)));
	assert((fetchPointerofObject(NextLinkIndex, _proc)) == (nilObject()));
	if ((assert(!(isForwarded(_aList))), (unsignedLongAt((_aList + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ))) == GIV(nilObj))) {
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_aList)));
		if (((_aList & (tagMask())) == 0) && ((_aList & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_proc & (tagMask())) == 0) && (((_proc & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_proc >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_aList)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _aList);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_aList)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l3;
		}
		if (_proc & (tagMask())) {
			goto l3;
		}
		if (!(_aList >= 0x20000000000LL)) {
			goto l3;
		}
		if (_proc >= 0x20000000000LL) {
			goto l3;
		}
		if ((_proc >= GIV(nilObj)) && (_proc <= GIV(trueObj))) {
			goto l3;
		}
		if (!(_proc >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l3;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _aList);
		l3:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_aList + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ), _proc);
		/* end storePointer:ofObject:withValue: */
	} else {
		/* begin fetchPointer:ofObject: */
		_lastLink = unsignedLongAt((_aList + BaseHeaderSize) + ((sqInt) (((usqInt) LastLinkIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert(_lastLink != _proc);
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_lastLink)));
		if (((_lastLink & (tagMask())) == 0) && ((_lastLink & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_proc & (tagMask())) == 0) && (((_proc & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_proc >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_lastLink)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _lastLink);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_lastLink)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l5;
		}
		if (_proc & (tagMask())) {
			goto l5;
		}
		if (!(_lastLink >= 0x20000000000LL)) {
			goto l5;
		}
		if (_proc >= 0x20000000000LL) {
			goto l5;
		}
		if ((_proc >= GIV(nilObj)) && (_proc <= GIV(trueObj))) {
			goto l5;
		}
		if (!(_proc >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l5;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _lastLink);
		l5:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_lastLink + BaseHeaderSize) + ((sqInt) (((usqInt) NextLinkIndex ) << (shiftForWord())) ), _proc);
		/* end storePointer:ofObject:withValue: */
	}
	/* begin storePointer:ofObject:withValue: */
	assert(!(isForwarded(_aList)));
	if (((_aList & (tagMask())) == 0) && ((_aList & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((_proc & (tagMask())) == 0) && (((_proc & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_proc >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_aList)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _aList);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(_aList)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l7;
	}
	if (_proc & (tagMask())) {
		goto l7;
	}
	if (!(_aList >= 0x20000000000LL)) {
		goto l7;
	}
	if (_proc >= 0x20000000000LL) {
		goto l7;
	}
	if ((_proc >= GIV(nilObj)) && (_proc <= GIV(trueObj))) {
		goto l7;
	}
	if (!(_proc >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l7;
	}
	remember(getFromPermToNewSpaceRememberedSet(), _aList);
	l7:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((_aList + BaseHeaderSize) + ((sqInt) (((usqInt) LastLinkIndex ) << (shiftForWord())) ), _proc);
	/* end storePointer:ofObject:withValue: */
	/* begin storePointer:ofObject:withValue: */
	assert(!(isForwarded(_proc)));
	if (((_proc & (tagMask())) == 0) && ((_proc & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((_aList & (tagMask())) == 0) && (((_aList & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_aList >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_proc)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _proc);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(_proc)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l9;
	}
	if (_aList & (tagMask())) {
		goto l9;
	}
	if (!(_proc >= 0x20000000000LL)) {
		goto l9;
	}
	if (_aList >= 0x20000000000LL) {
		goto l9;
	}
	if ((_aList >= GIV(nilObj)) && (_aList <= GIV(trueObj))) {
		goto l9;
	}
	if (!(_aList >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l9;
	}
	remember(getFromPermToNewSpaceRememberedSet(), _proc);
	l9:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((_proc + BaseHeaderSize) + ((sqInt) (((usqInt) MyListIndex ) << (shiftForWord())) ), _aList);
	/* end storePointer:ofObject:withValue: */
}
/*	Answer if maybeClassObj looks like a class object */
/* StackInterpreter>>#addressCouldBeClassObj: */
static sqInt NoDbgRegParms
addressCouldBeClassObj(sqInt _maybeClassObj)
{
	return (addressCouldBeObj(_maybeClassObj)) && (objCouldBeClassObj(_maybeClassObj));
}
/* StackInterpreter>>#allOnesAsCharStar */
static char *
allOnesAsCharStar(void)
{
	return ((char *) ((usqInt) -1 ) );
}
/*	for Cogit */
/* StackInterpreter>>#argumentCountOfClosure: */
sqInt
argumentCountOfClosure(sqInt _closurePointer)
{
	sqInt _oop;

	/* begin quickFetchInteger:ofObject: */
	/* begin fetchPointer:ofObject: */
	_oop = unsignedLongAt((_closurePointer + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureNumArgsIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(((_oop & 7) == 1));
	return _oop >> 3;
	/* end quickFetchInteger:ofObject: */
}
/* StackInterpreter>>#argumentCountOfMethodHeader: */
sqInt
argumentCountOfMethodHeader(sqInt _header)
{
	return (((usqInt) _header ) >> MethodHeaderArgCountShift) & 15;
}
/* StackInterpreter>>#argumentCountOf: */
sqInt
argumentCountOf(sqInt _methodPointer)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _header;
	sqInt _header2;

	/* begin argumentCountOfMethodHeader: */
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_methodPointer));
	/* begin fetchPointer:ofObject: */
	_header2 = unsignedLongAt((_methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header2 & 7) == 1)) {
		_header = _header2;
	} else {
		assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_header = ((((CogMethod *) _header2 ))->methodHeader);
	}
	/* end methodHeaderOf: */
	return (((usqInt) _header ) >> MethodHeaderArgCountShift) & 15;
	/* end argumentCountOfMethodHeader: */
}
/*	Return the address of first indexable field of resulting array object, or 
	fail if 
	the instance variable does not contain an indexable bytes or words object.Note: May be called by translated primitive code. */
/* StackInterpreter>>#arrayValueOf: */
void *
arrayValueOf(sqInt _arrayOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (((_arrayOop & (tagMask())) == 0) && (isPureBitsFormat((((usqInt) (longAt(_arrayOop)) ) >> (formatShift())) & (formatMask())))) {
		return ((void *) (pointerForOop(_arrayOop + BaseHeaderSize)) );
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	return 0;
}
/* StackInterpreter>>#assertValidExecutionPointe:r:s: */
void
assertValidExecutionPointers(usqInt _lip, char *_lifp, char *_lisp)
{
	assertValidExecutionPointersimbarline(_lip, _lifp, _lisp, !(isMachineCodeIP(((usqInt) (unsignedLongAt(_lifp + FoxMethod)) ))), __LINE__);
}
/*	Order in the stackLimit checks is important because stackLimit is smashed 
	by interrupts. So always check for unsmashed value first to avoid race 
	condition.  */
/* StackInterpreter>>#assertValidStackLimits: */
static void NoDbgRegParms
assertValidStackLimits(sqInt _ln)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	assertl((GIV(stackLimit) == ((GIV(stackPage)->realStackLimit))) || (GIV(stackLimit) == (allOnesAsCharStar())), _ln);
	assertl((((GIV(stackPage)->stackLimit)) == ((GIV(stackPage)->realStackLimit))) || (((GIV(stackPage)->stackLimit)) == (allOnesAsCharStar())), _ln);
}
/*	convert true and false (Smalltalk) to true or false(C) */
/* StackInterpreter>>#booleanValueOf: */
sqInt
booleanValueOf(sqInt _obj)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (_obj == GIV(trueObj)) {
		return 1;
	}
	if (_obj == GIV(falseObj)) {
		return 0;
	}
	/* begin success: */
	{
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
	}
	/* end success: */
	return null;
}
/*	Context switch should not be allowed on every method activation. In 
	particular the implementation of ensure: and ifCurtailed: depends on there 
	being no 
	suspension point on failing primitive 198 (primitiveMarkUnwindMethod). 
	slowPrimitiveResponse states 
	``N.B. This means there is no suspension point on primitive failure 
	which methods such as ensure: and ifCurtailed: rely on.'' 
	Rather than prevent context switch on all primitives but the ones we 
	really need 
	to be suspension points (primitiveSignal et al) we choose to allow context 
	switch for all but primitiveMarkUnwindMethod. */
/* StackInterpreter>>#canContextSwitchIfActivating:header: */
sqInt
canContextSwitchIfActivatingheader(sqInt _theMethod, sqInt _methodHeader)
{
	sqInt _firstBytecode;
	sqInt _primitiveIndex;

	if (_methodHeader & AlternateHeaderHasPrimFlag) {
		_firstBytecode = (_theMethod + ((LiteralStart + ((_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) * BytesPerOop)) + BaseHeaderSize;
		_primitiveIndex = (byteAt(_firstBytecode + 1)) + ((sqInt) (((usqInt) (byteAt(_firstBytecode + 2)) ) << 8) );
	} else {
		_primitiveIndex = 0;
	}
	return 
#    if 1
			_primitiveIndex != 198
#    else /* 1 */
			(_primitiveIndex == 0) || (((_primitiveIndex >= 85) && (_primitiveIndex <= 88)) || (_primitiveIndex == 167))
#    endif /* 1 */
			;
}
/*	Above ObjectMemory, arg must lie in range 0-255! */
/* StackInterpreter>>#characterForAscii: */
sqInt
characterForAscii(sqInt _ascii)
{
	return ((sqInt) (((usqInt) _ascii ) << (numTagBits())) ) + (characterTag());
}
/*	Check for a hit of the longRunningPrimitive probe and if so attempt to 
	signal the 
	longRunningPrimitiveCheckSemaphore. Answer if a process switch occurred as 
	a result. */
/* StackInterpreter>>#checkDeliveryOfLongRunningPrimitiveSignal */
static sqInt
checkDeliveryOfLongRunningPrimitiveSignal(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if ((GIV(longRunningPrimitiveStopUsecs) > GIV(longRunningPrimitiveStartUsecs)) && ((GIV(longRunningPrimitiveCheckSemaphore) != null) && GIV(longRunningPrimitiveSignalUndelivered))) {
		GIV(longRunningPrimitiveSignalUndelivered) = 0;
		GIV(longRunningPrimitiveGCUsecs) = (((GIV(gcStartUsecs) < GIV(longRunningPrimitiveStopUsecs)) && (GIV(statGCEndUsecs) > GIV(longRunningPrimitiveStartUsecs)))
			 ? GIV(statGCEndUsecs) - GIV(gcStartUsecs)
			 : 0);
		return synchronousSignal(GIV(longRunningPrimitiveCheckSemaphore));
	}
	return 0;
}
/*	Note: May be called by translated primitive code. */
/* StackInterpreter>>#checkedIntegerValueOf: */
sqInt
checkedIntegerValueOf(sqInt _intOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (((_intOop & 7) == 1)) {
		return _intOop >> 3;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
}
/*	Check for possible interrupts and handle one if necessary. 
	Answer if a context switch has occurred. */
/* StackInterpreter>>#checkForEventsMayContextSwitch: */
static sqInt NoDbgRegParms
checkForEventsMayContextSwitch(sqInt _mayContextSwitch)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _now;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _sema;
	int _switched;
	char *_theSP;

	GIV(statCheckForEvents) += 1;
	/* begin restoreStackLimit */
	(GIV(stackPage)->stackLimit = (GIV(stackPage)->realStackLimit));
	GIV(stackLimit) = (GIV(stackPage)->stackLimit);
	/* end restoreStackLimit */
	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	_theSP = GIV(stackPointer);
	assert(_theSP < GIV(framePointer));
	assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(GIV(stackPage)->headFP = GIV(framePointer));
		(GIV(stackPage)->headSP = _theSP);
	}
	/* end setHeadFP:andSP:inPage: */
	assert(pageListIsWellFormed());
	/* end writeBackHeadFramePointers */
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	ioSynchronousCheckForEvents();
	/* begin checkCogCompiledCodeCompactionCalledFor */
	if (GIV(cogCompiledCodeCompactionCalledFor)) {
		commenceCogCompiledCodeCompaction();
	}
	/* end checkCogCompiledCodeCompactionCalledFor */
	if (GIV(needGCFlag)) {
		if (!(sufficientSpaceAfterGC(0))) {
			setSignalLowSpaceFlagAndSaveProcess();
		}
	}
	if (!_mayContextSwitch) {
		return 0;
	}
	_switched = 0;
	if ((GIV(profileProcess) != GIV(nilObj)) || ((GIV(nextProfileTick) > 0) && ((ioHighResClock()) >= GIV(nextProfileTick)))) {
		GIV(nextProfileTick) = 0;
		if (GIV(profileProcess) == GIV(nilObj)) {
			/* begin memoryActiveProcess */
			/* begin fetchPointer:ofObject: */
			/* begin fetchPointer:ofObject: */
			/* begin splObj: */
			/* begin fetchPointer:ofObject: */
			_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			/* end splObj: */
			_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			GIV(profileProcess) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			/* end memoryActiveProcess */
			/* begin nilObject */
			GIV(profileMethod) = GIV(nilObj);
			/* end nilObject */
		}
		if ((GIV(profileSemaphore) != GIV(nilObj)) && (synchronousSignal(GIV(profileSemaphore)))) {
			_switched = 1;
		}
	}
	if (checkDeliveryOfLongRunningPrimitiveSignal()) {
		_switched = 1;
	}
	if (GIV(signalLowSpace)) {
		/* begin signalLowSpace: */
		GIV(signalLowSpace) = 0;
		/* end signalLowSpace: */
		/* begin splObj: */
		/* begin fetchPointer:ofObject: */
		_sema = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) TheLowSpaceSemaphore ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		if ((_sema != GIV(nilObj)) && (synchronousSignal(_sema))) {
			_switched = 1;
		}
	}
	_now = ioUTCMicroseconds();
	if (GIV(nextWakeupUsecs) != 0) {
		if (_now >= GIV(nextWakeupUsecs)) {
			GIV(nextWakeupUsecs) = 0;
			/* begin splObj: */
			/* begin fetchPointer:ofObject: */
			_sema = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) TheTimerSemaphore ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			/* end splObj: */
			if ((_sema != GIV(nilObj)) && (synchronousSignal(_sema))) {
				_switched = 1;
			}
		}
	}
	if (GIV(pendingFinalizationSignals) > 0) {
		GIV(pendingFinalizationSignals) = 0;
		/* begin splObj: */
		/* begin fetchPointer:ofObject: */
		_sema = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) TheFinalizationSemaphore ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		if ((_sema != GIV(nilObj)) && (synchronousSignal(_sema))) {
			_switched = 1;
		}
	}
	if (signalExternalSemaphores()) {
		_switched = 1;
	}
	return _switched;
}
/*	Perform an integrity/leak check using the heapMap. Assume 
	clearLeakMapAndMapAccessibleObjects has set a bit at each 
	object's header. Check that all oops in the interpreter's state 
	points to a header. Answer 0 if all checks pass. */
/* StackInterpreter>>#checkInterpreterIntegrity */
static sqInt
checkInterpreterIntegrity(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	int _flags;
	sqInt _i;

	_flags = 0;
	if (!(checkOopIntegritynamed(GIV(specialObjectsOop), "specialObjectsOop"))) {
		_flags = 1;
	}
	if (!(checkOopIntegritynamed(GIV(newMethod), "newMethod"))) {
		_flags += 2;
	}
	if (!(checkOopIntegritynamed(GIV(profileProcess), "profileProcess"))) {
		_flags += 4;
	}
	if (!(checkOopIntegritynamed(GIV(profileMethod), "profileMethod"))) {
		_flags += 8;
	}
	if (!(checkOopIntegritynamed(GIV(profileSemaphore), "profileSemaphore"))) {
		_flags += 16;
	}
	if (!(GIV(tempOop) == 0)) {
		if (!(checkOopIntegritynamed(GIV(tempOop), "tempOop"))) {
			_flags += 32;
		}
	}
	if (!(GIV(tempOop2) == 0)) {
		if (!(checkOopIntegritynamed(GIV(tempOop2), "tempOop2"))) {
			_flags += 64;
		}
	}
	for (_i = 1; _i <= GIV(jmpDepth); _i += 1) {
		if (!(checkOopIntegritynamedindex(GIV(suspendedCallbacks)[_i], "suspendedCallbacks", _i))) {
			_flags += 128;
		}
		if (!(checkOopIntegritynamedindex(GIV(suspendedMethods)[_i], "suspendedMethods", _i))) {
			_flags += 256;
		}
	}
	if (!(checkLogIntegrity())) {
		_flags += 512;
	}
	return _flags;
}
/*	Another version of isWidowedContext: for debugging. 
	This will not bereave a widowed context. */
/* StackInterpreter>>#checkIsStillMarriedContext:currentFP: */
static sqInt NoDbgRegParms
checkIsStillMarriedContextcurrentFP(sqInt _aContext, char *_currentFP)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_limitFP;
	char *_maybeFP;
	sqInt _maybeFrameCtxt;
	sqInt _referent;
	sqInt _senderOop;
	StackPage *_thePage;

	if (!((((_aContext & (tagMask())) == 0) && (((longAt(_aContext)) & (classIndexMask())) == ClassMethodContextCompactIndex)) && ((((unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)))) {
		return 0;
	}
	/* begin frameOfMarriedContext: */
	/* begin fetchPointer:ofObject: */
	_senderOop = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	{
		assert(((_senderOop & 7) == 1));
		_maybeFP = pointerForOop(_senderOop - 1);
	}
	/* end frameOfMarriedContext: */
	/* begin stackPageFor: */
	/* begin stackPageAt: */
	_thePage = stackPageAtpages((assert((((char *) _maybeFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _maybeFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_maybeFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
	/* end stackPageAt: */
	/* end stackPageFor: */
	_limitFP = (((_thePage == GIV(stackPage)) && (_currentFP != null))
		 ? _currentFP
		 : (_thePage->headFP));
	if (!((_maybeFP >= _limitFP) && ((isNonImmediate(((sqInt) (pointerForOop(unsignedLongAt(_maybeFP + FoxSavedFP))) ))) && (((withSmallIntegerTags(pointerForOop(unsignedLongAt(_maybeFP + FoxSavedFP)))) == (unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )))) && (((isMachineCodeIP(((usqInt) (unsignedLongAt(_maybeFP + FoxMethod)) )))
		 ? ((unsignedLongAt(_maybeFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
		 : (byteAt((_maybeFP + FoxIFrameFlags) + 2)) != 0)))))) {
		return 0;
	}
	_maybeFrameCtxt = unsignedLongAt(_maybeFP + FoxThisContext);
	if ((!(((_thePage->baseFP)) == 0)) && ((isFrameonPage(_maybeFP, _thePage)) && (((long64At(_maybeFrameCtxt)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(_maybeFrameCtxt));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_maybeFrameCtxt + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		_maybeFrameCtxt = _referent;
		/* end followForwarded: */
	}
	return _maybeFrameCtxt == _aContext;
}
/*	Check if the profile timer has expired and if so take a sample. 
	If the primitive has failed sample the profileMethod as nil. */
/* StackInterpreter>>#checkProfileTick: */
static void NoDbgRegParms
checkProfileTick(sqInt _aPrimitiveMethod)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _objOop;
	sqInt _objOop2;

	assert(GIV(nextProfileTick) != 0);
	if ((ioHighResClock()) >= GIV(nextProfileTick)) {
		/* begin memoryActiveProcess */
		/* begin fetchPointer:ofObject: */
		/* begin fetchPointer:ofObject: */
		/* begin splObj: */
		/* begin fetchPointer:ofObject: */
		_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		GIV(profileProcess) = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end memoryActiveProcess */
		if (!GIV(primFailCode)) {
			GIV(profileMethod) = _aPrimitiveMethod;
		} else {
			/* begin nilObject */
			GIV(profileMethod) = GIV(nilObj);
			/* end nilObject */
		}
		forceInterruptCheck();
		GIV(nextProfileTick) = 0;
	}
}
/*	Perform an integrity/leak check using the heapMap. Assume 
	clearLeakMapAndMapAccesibleObjects has set a bit at each 
	object's header. Scan all objects accessible from the stack 
	checking that every pointer points to a header. Answer if no 
	dangling pointers were detected. */
/* StackInterpreter>>#checkStackIntegrity */
static sqInt
checkStackIntegrity(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char * _baseFrameArgumentSP2;
	char * _baseFrameFP;
	char * _callerFP;
	CogMethod *_cogMethod;
	char * _currentSP;
	char *_frameRcvrOffset;
	sqInt _i;
	sqInt _methodField;
	sqInt _methodOk;
	int _ok;
	sqInt _oop;
	sqInt _oop2;
	sqInt _oop3;
	usqInt _oop4;
	char *_theFP2;
	StackPage *_thePage2;
	char * _theSP2;
	char *_theSP3;

	_ok = 1;
	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	_theSP3 = GIV(stackPointer);
	assert(_theSP3 < GIV(framePointer));
	assert((_theSP3 < ((GIV(stackPage)->baseAddress))) && (_theSP3 > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(GIV(stackPage)->headFP = GIV(framePointer));
		(GIV(stackPage)->headSP = _theSP3);
	}
	/* end setHeadFP:andSP:inPage: */
	assert(pageListIsWellFormed());
	/* end writeBackHeadFramePointers */
	/* begin usedStackPagesDo: */
	/* begin allStackPagesDo: */
	for (_i = 0; _i < GIV(numStackPages); _i += 1) {
		/* begin stackPageAt: */
		_thePage2 = stackPageAtpages(_i, GIV(pages));
		/* end stackPageAt: */
		{
			if (!(((_thePage2->baseFP)) == 0)) {
				{
					/* begin framesInPage:do: */
					_theSP2 = (_thePage2->headSP);
					_theFP2 = (_thePage2->headFP);
					if (!(_thePage2 == GIV(stackPage))) {
						_theSP2 += BytesPerWord;
					}
					while (1) {
						{
							/* begin frameStackValuesWithFP:withSP:do: */
							_currentSP = ((char *) _theSP2 );
							_frameRcvrOffset = ((isMachineCodeIP(((usqInt) (unsignedLongAt(((char *) _theFP2 ) + FoxMethod)) )))
								 ? ((char *) _theFP2 ) + FoxMFReceiver
								 : ((char *) _theFP2 ) + FoxIFReceiver);
							while (_currentSP <= _frameRcvrOffset) {
								_oop3 = unsignedLongAt(_currentSP);
								{
									if (((_oop3 & (tagMask())) == 0) && ((heapMapAtWord(pointerForOop(_oop3))) == 0)) {
										printFrameThingandFrameat("object leak in frame temp", _theFP2, _currentSP);
										_ok = 0;
									}
								}
								_currentSP += BytesPerWord;
							}
							/* end frameStackValuesWithFP:withSP:do: */
							if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP2 + FoxMethod)) )))
								 ? ((unsignedLongAt(_theFP2 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
								 : (byteAt((_theFP2 + FoxIFrameFlags) + 2)) != 0)) {
								_oop = unsignedLongAt(_theFP2 + FoxThisContext);
								if ((_oop & (tagMask())) || ((heapMapAtWord(pointerForOop(_oop))) == 0)) {
									printFrameThingandFrameat("object leak in frame ctxt", _theFP2, _theFP2 + FoxThisContext);
									_ok = 0;
								}
								if (!(((_oop & (tagMask())) == 0) && (((longAt(_oop)) & (classIndexMask())) == ClassMethodContextCompactIndex))) {
									printFrameThingandFrameat("frame ctxt should be context", _theFP2, _theFP2 + FoxThisContext);
									_ok = 0;
								}
								if (!((((_oop & (tagMask())) == 0) && (((longAt(_oop)) & (classIndexMask())) == ClassMethodContextCompactIndex)) && ((((unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)))) {
									printFrameThingandFrameat("frame ctxt should be married", _theFP2, _theFP2 + FoxThisContext);
									_ok = 0;
								}
								if (!((((_oop & (tagMask())) == 0) && (((longAt(_oop)) & (classIndexMask())) == ClassMethodContextCompactIndex)) && (((((unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && ((frameOfMarriedContext(_oop)) == _theFP2)))) {
									printFrameThingandFrameat("frame ctxt should be married to this frame ", _theFP2, _theFP2 + FoxThisContext);
									_ok = 0;
								}
							}
							/* begin checkMethodIntegrityInFrame: */
							if (!(isMachineCodeIP(((usqInt) (unsignedLongAt(((char *) _theFP2 ) + FoxMethod)) )))) {
								_oop4 = unsignedLongAt(((char *) _theFP2 ) + FoxMethod);
								if ((_oop4 & (tagMask())) || ((heapMapAtWord(pointerForOop(_oop4))) == 0)) {
									printFrameThingandFrameat("object leak in iframe mthd", ((char *) _theFP2 ), ((char *) _theFP2 ) + FoxMethod);
									_methodOk = 0;
									goto l8;
								}
								_methodOk = 1;
								goto l8;
							}
							/* begin mframeHomeMethod: */
							_methodField = unsignedLongAt(((char *) _theFP2 ) + FoxMethod);
							_cogMethod = ((CogMethod *) (_methodField & MFMethodMask) );
							/* end mframeHomeMethod: */
							if ((heapMapAtWord(pointerForOop(_cogMethod))) == 0) {
								printFrameThingandFrameat("object leak in mframe mthd", ((char *) _theFP2 ), ((char *) _theFP2 ) + FoxMethod);
								_methodOk = 0;
								goto l8;
							}
							_methodOk = 1;
							l8:
							;
							/* end checkMethodIntegrityInFrame: */
							if (!_methodOk) {
								_ok = 0;
							}
						}
						if (!(((_callerFP = pointerForOop(unsignedLongAt(_theFP2 + FoxSavedFP)))) != 0)) 
							break;
						_theSP2 = (_theFP2 + FoxCallerSavedIP) + BytesPerWord;
						_theFP2 = _callerFP;
					}
					_baseFrameFP = _theFP2;
					/* end framesInPage:do: */
					/* begin baseFrameArguments:inPage:do: */
					_baseFrameArgumentSP2 = (_baseFrameFP + FoxCallerSavedIP) + BytesPerWord;
					while (_baseFrameArgumentSP2 <= ((_thePage2->baseAddress))) {
						_oop2 = unsignedLongAt(_baseFrameArgumentSP2);
						{
							if (((_oop2 & (tagMask())) == 0) && ((heapMapAtWord(pointerForOop(_oop2))) == 0)) {
								printFrameThingandFrameat("object leak in frame arg", _baseFrameFP, _baseFrameArgumentSP2);
								_ok = 0;
							}
						}
						_baseFrameArgumentSP2 += BytesPerWord;
					}
					/* end baseFrameArguments:inPage:do: */
				}
			}
		}
	}
	/* end allStackPagesDo: */
	/* end usedStackPagesDo: */
	return _ok;
}
/*	Version of stackPointerForMaybeMarriedContext: with no side-effects (does 
	not widow). 
	Used for assertion checking. Safe only in external primitives 
	(framePointer valid). 
	Answer the stackPointer of a Context. */
/* StackInterpreter>>#checkStackPointerForMaybeMarriedContext: */
static sqInt NoDbgRegParms
checkStackPointerForMaybeMarriedContext(sqInt _aContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _header;
	sqInt _header2;
	sqInt _methodPointer;
	sqInt _sp;
	sqInt _sp2;

	if (checkIsStillMarriedContextcurrentFP(_aContext, GIV(framePointer))) {
		_sp = checkStackPointerIndexForFrame(frameOfMarriedContext(_aContext));
		assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_aContext)));
		return _sp;
	}
	if ((((unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
		/* begin argumentCountOf: */
		_methodPointer = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ));
		/* begin argumentCountOfMethodHeader: */
		/* begin methodHeaderOf: */
		assert(isCompiledMethod(_methodPointer));
		/* begin fetchPointer:ofObject: */
		_header2 = unsignedLongAt((_methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_header2 & 7) == 1)) {
			_header = _header2;
		} else {
			assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
			assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
			_header = ((((CogMethod *) _header2 ))->methodHeader);
		}
		/* end methodHeaderOf: */
		return (((usqInt) _header ) >> MethodHeaderArgCountShift) & 15;
		/* end argumentCountOfMethodHeader: */
		/* end argumentCountOf: */
	}
	/* begin fetchStackPointerOf: */
	/* begin fetchPointer:ofObject: */
	_sp2 = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (!(((_sp2 & 7) == 1))) {
		return 0;
	}
	assert((ReceiverIndex + (_sp2 >> 3)) < (lengthOf(_aContext)));
	return _sp2 >> 3;
	/* end fetchStackPointerOf: */
}
/*	Version of stackPointerIndexForFrame: that does not depend on writing back 
	head frame pointers. 
	Used for assertion checking. Safe only in external primitives 
	(framePointer valid). 
	Answer the 0-based index rel to the given frame. 
	(This is what stackPointer used to be before conversion to pointer)In the StackInterpreter stacks grow down. */
/* StackInterpreter>>#checkStackPointerIndexForFrame: */
static sqInt NoDbgRegParms
checkStackPointerIndexForFrame(char *_theFP)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_aFrame;
	char *_prevFrame;
	char *_startFrame;
	StackPage *_thePage;
	char *_theSP;

	if (_theFP == GIV(framePointer)) {
		return (((usqInt) ((((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? _theFP + FoxMFReceiver
			 : _theFP + FoxIFReceiver)) - GIV(stackPointer)) ) >> (shiftForWord())) + (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
			 : byteAt((_theFP + FoxIFrameFlags) + 1)));
	}
	/* begin stackPageFor: */
	/* begin stackPageAt: */
	_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
	/* end stackPageAt: */
	/* end stackPageFor: */
	/* begin findSPOrNilOf:on:startingFrom: */
	_startFrame = ((_thePage == GIV(stackPage))
		 ? GIV(framePointer)
		 : (_thePage->headFP));
	if (_startFrame == _theFP) {
		if (((_thePage->headSP)) >= _startFrame) {
			_theSP = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
				 ? _theFP + FoxMFReceiver
				 : _theFP + FoxIFReceiver);
			goto l3;
		}
		_theSP = ((_thePage == GIV(stackPage))
			 ? (_thePage->headSP)
			 : ((_thePage->headSP)) + BytesPerWord);
		goto l3;
	}
	_aFrame = _startFrame;
	while (1) {
		_prevFrame = _aFrame;
		_aFrame = pointerForOop(unsignedLongAt(_aFrame + FoxSavedFP));
		if (!(_aFrame != 0)) 
			break;
		if (_theFP == _aFrame) {
			{
				assert(!(isBaseFrame(_prevFrame)));
				_theSP = (_prevFrame + (frameStackedReceiverOffset(_prevFrame))) + BytesPerWord;
			}
			goto l3;
		}
	}
	_theSP = null;
	l3:
	;
	/* end findSPOrNilOf:on:startingFrom: */
	if (!_theSP) {
		return -1;
	}
	return (((usqInt) ((((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? _theFP + FoxMFReceiver
		 : _theFP + FoxIFReceiver)) - _theSP) ) >> (shiftForWord())) + (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
		 : byteAt((_theFP + FoxIFrameFlags) + 1)));
}
/*	Check if aClass's name is className */
/* StackInterpreter>>#classNameOf:Is: */
static sqInt NoDbgRegParms
classNameOfIs(sqInt _aClass, char *_className)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _length;
	sqInt _name;
	char *_srcName;

	if ((lengthOfformat(_aClass, (((usqInt) (longAt(_aClass)) ) >> (formatShift())) & (formatMask()))) <= GIV(classNameIndex)) {
		return 0;
	}
	/* begin fetchPointer:ofObject: */
	_name = unsignedLongAt((_aClass + BaseHeaderSize) + ((sqInt) (((usqInt) GIV(classNameIndex) ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (!(((_name & (tagMask())) == 0) && (((((usqInt) (longAt(_name)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())))) {
		return 0;
	}
	_length = stSizeOf(_name);
	_srcName = ((char *) (arrayValueOf(_name)) );
	for (_i = 0; _i < _length; _i += 1) {
		if (!((_srcName[_i]) == (_className[_i]))) {
			return 0;
		}
	}
	return (_className[_length]) == 0;
}
/*	Does thisCntx have aContext in its sender chain? 
	Cheapo implementation above extant machinery. */
/* StackInterpreter>>#context:hasSender: */
static sqInt NoDbgRegParms
contexthasSender(sqInt _thisCntx, sqInt _aContext)
{
	sqInt _handlerOrNilOrZero;

	_handlerOrNilOrZero = findMethodWithPrimitiveFromContextUpToContext(-1, _thisCntx, _aContext);
	return _handlerOrNilOrZero == 0;
}
/*	For asserts. Check that theIP maps back correctly to the context's pc. 
	The CallPrimitive bytecode presents a complication. */
/* StackInterpreter>>#context:hasValidInversePCMappingOf:in: */
static sqInt NoDbgRegParms
contexthasValidInversePCMappingOfin(sqInt _aContext, sqInt _theIP, char *_theFP)
{
	sqInt _encodedip;
	sqInt _methodHeader;
	sqInt _pc;

	/* begin fetchPointer:ofObject: */
	_pc = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	_encodedip = contextInstructionPointerframe(_theIP, _theFP);
	return (_pc == _encodedip) || (((_methodHeader = methodHeaderOf(unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) )))), (_methodHeader & AlternateHeaderHasPrimFlag) && (((_encodedip >> 3) - (_pc >> 3)) == 3)));
}
/*	for Cogit */
/* StackInterpreter>>#copiedValueCountOfFullClosure: */
sqInt
copiedValueCountOfFullClosure(sqInt _closurePointer)
{
	return (numSlotsOf(_closurePointer)) - FullClosureFirstCopiedValueIndex;
}
/*	This entry point needs to be implemented for the interpreter proxy. 
	Since BitBlt is now a plugin we need to look up BitBltPlugin:=copyBits 
	and call it. This entire mechanism should eventually go away and be 
	replaced with a dynamic lookup from BitBltPlugin itself but for backward 
	compatibility this stub is provided */
/* StackInterpreter>>#copyBits */
sqInt
copyBits(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	void *_fn;

	_fn = ioLoadFunctionFrom("copyBits", "BitBltPlugin");
	if (_fn == 0) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	return ((sqInt (*)(void))_fn)();
}
/*	This entry point needs to be implemented for the interpreter proxy. 
	Since BitBlt is now a plugin we need to look up 
	BitBltPlugin:=copyBitsFrom:to:at: and call it. This entire mechanism 
	should eventually go away and be 
	replaced with a dynamic lookup from BitBltPlugin itself but for backward 
	compatibility this stub is provided */
/* StackInterpreter>>#copyBitsFrom:to:at: */
sqInt
copyBitsFromtoat(sqInt x0, sqInt x1, sqInt y)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	void *_fn;

	_fn = ioLoadFunctionFrom("copyBitsFromtoat", "BitBltPlugin");
	if (_fn == 0) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	return ((sqInt (*)(sqInt, sqInt, sqInt))_fn)(x0, x1, y);
}
/* StackInterpreter>>#couldBeProcess: */
static sqInt NoDbgRegParms NeverInline
couldBeProcess(sqInt _oop)
{
	return (addressCouldBeObj(_oop)) && ((((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) <= 5) && ((!(((_oop & (tagMask())) == 0) && (((longAt(_oop)) & (classIndexMask())) == ClassMethodContextCompactIndex))) && (((lengthOfformat(_oop, (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask()))) > MyListIndex) && (isContext(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) SuspendedContextIndex ) << (shiftForWord())) )))))));
}
/*	For testing in Smalltalk, this method should be overridden in a subclass. */
/* StackInterpreter>>#cr */
static sqInt
cr(void)
{
	print("\n");
	return 1;
}
/*	Bundle up the selector, arguments and lookupClass into a Message object.  
	In the process it pops the arguments off the stack, and pushes the message 
	object.  
	This can then be presented as the argument of e.g. #doesNotUnderstand: */
/* StackInterpreter>>#createActualMessageTo: */
static void NoDbgRegParms
createActualMessageTo(sqInt _lookupClass)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _argumentArray;
	sqInt _i;
	usqInt _message;
	usqInt _newObj;
	usqInt _newObj2;
	usqInt _numBytes;
	usqInt _numBytes2;
	sqInt _numSlots;
	char *_sp;

	assert((isImmediate(GIV(messageSelector))) || (addressCouldBeObj(GIV(messageSelector))));
	/* begin eeInstantiateSmallClassIndex:format:numSlots: */
	assert((GIV(argumentCount) >= 0) && ((classAtIndex(ClassArrayCompactIndex)) != GIV(nilObj)));
	assert(2 == (instSpecOfClass(classAtIndex(ClassArrayCompactIndex))));
	/* begin allocateSmallNewSpaceSlots:format:classIndex: */
	assert(GIV(argumentCount) < (numSlotsMask()));
	_newObj = GIV(freeStart);
	_numBytes = BaseHeaderSize + (((GIV(argumentCount) < 1)
		 ? 8
		 : GIV(argumentCount) * BytesPerOop));
	assert((_numBytes % (allocationUnit())) == 0);
	assert((_newObj % (allocationUnit())) == 0);
	if ((GIV(freeStart) + _numBytes) > GIV(scavengeThreshold)) {
		if (!GIV(needGCFlag)) {
			/* begin scheduleScavenge */
			GIV(needGCFlag) = 1;
			forceInterruptCheck();
			/* end scheduleScavenge */
		}
		if ((GIV(freeStart) + _numBytes) > (((eden()).limit))) {
			error("no room in eden for allocateSmallNewSpaceSlots:format:classIndex:");
			_argumentArray = 0;
			goto l5;
		}
	}
	long64Atput(_newObj, ((((usqLong) GIV(argumentCount) ) << (numSlotsFullShift())) + (2U << (formatShift()))) + ClassArrayCompactIndex);
	GIV(freeStart) += _numBytes;
	_argumentArray = _newObj;
	/* end allocateSmallNewSpaceSlots:format:classIndex: */
	l5:
	;
	/* end eeInstantiateSmallClassIndex:format:numSlots: */
	/* begin eeInstantiateSmallClassIndex:format:numSlots: */
	_numSlots = MessageLookupClassIndex + 1;
	assert((_numSlots >= 0) && ((classAtIndex(ClassMessageCompactIndex)) != GIV(nilObj)));
	assert(1 == (instSpecOfClass(classAtIndex(ClassMessageCompactIndex))));
	/* begin allocateSmallNewSpaceSlots:format:classIndex: */
	assert(_numSlots < (numSlotsMask()));
	_newObj2 = GIV(freeStart);
	_numBytes2 = BaseHeaderSize + (((_numSlots < 1)
		 ? 8
		 : _numSlots * BytesPerOop));
	assert((_numBytes2 % (allocationUnit())) == 0);
	assert((_newObj2 % (allocationUnit())) == 0);
	if ((GIV(freeStart) + _numBytes2) > GIV(scavengeThreshold)) {
		if (!GIV(needGCFlag)) {
			/* begin scheduleScavenge */
			GIV(needGCFlag) = 1;
			forceInterruptCheck();
			/* end scheduleScavenge */
		}
		if ((GIV(freeStart) + _numBytes2) > (((eden()).limit))) {
			error("no room in eden for allocateSmallNewSpaceSlots:format:classIndex:");
			_message = 0;
			goto l6;
		}
	}
	long64Atput(_newObj2, ((((usqLong) _numSlots ) << (numSlotsFullShift())) + (1U << (formatShift()))) + ClassMessageCompactIndex);
	GIV(freeStart) += _numBytes2;
	_message = _newObj2;
	/* end allocateSmallNewSpaceSlots:format:classIndex: */
	l6:
	;
	/* end eeInstantiateSmallClassIndex:format:numSlots: */
	for (_i = (GIV(argumentCount) - 1) * BytesPerOop; _i >= 0; _i += -BytesPerOop) {
		longAtput((_argumentArray + BaseHeaderSize) + _i, popStack());
	}
	{
		/* begin storePointerUnchecked:ofObject:withValue: */
		assert(!(isOopForwarded(_message)));
		longAtput((_message + BaseHeaderSize) + ((sqInt) (((usqInt) MessageSelectorIndex ) << (shiftForWord())) ), GIV(messageSelector));
		/* end storePointerUnchecked:ofObject:withValue: */
		/* begin storePointerUnchecked:ofObject:withValue: */
		assert(!(isOopForwarded(_message)));
		longAtput((_message + BaseHeaderSize) + ((sqInt) (((usqInt) MessageArgumentsIndex ) << (shiftForWord())) ), _argumentArray);
		/* end storePointerUnchecked:ofObject:withValue: */
		/* begin storePointerUnchecked:ofObject:withValue: */
		assert(!(isOopForwarded(_message)));
		longAtput((_message + BaseHeaderSize) + ((sqInt) (((usqInt) MessageLookupClassIndex ) << (shiftForWord())) ), _lookupClass);
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	/* begin push: */
	unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _message);
	GIV(stackPointer) = _sp;
	/* end push: */
	GIV(argumentCount) = 1;
}
/*	Return the default number of stack pages allocate at startup. 
	The Spur default reflects tuning for GC performance ast Cadence. 
	The actual value can be set via vmParameterAt: and/or a preference in the 
	ini file. */
/* StackInterpreter>>#defaultNumStackPages */
static sqInt
defaultNumStackPages(void)
{
	return 50;
}
/* StackInterpreter>>#divorceAllFrames */
static sqInt
divorceAllFrames(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeContext;
	sqInt _i;
	char *_theFP;
	StackPage *_thePage2;
	char *_theSP;
	char *_theSP2;

	if (GIV(stackPage) != 0) {
		/* begin writeBackHeadFramePointers */
		assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
		assert(GIV(stackPage) == (mostRecentlyUsedPage()));
		assert(!(isFree(GIV(stackPage))));
		/* begin setHeadFP:andSP:inPage: */
		_theSP = GIV(stackPointer);
		assert(_theSP < GIV(framePointer));
		assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
		assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
		{
			(GIV(stackPage)->headFP = GIV(framePointer));
			(GIV(stackPage)->headSP = _theSP);
		}
		/* end setHeadFP:andSP:inPage: */
		assert(pageListIsWellFormed());
		/* end writeBackHeadFramePointers */
	}
	/* begin ensureFrameIsMarried:SP: */
	_theFP = GIV(framePointer);
	_theSP2 = GIV(stackPointer) + BytesPerWord;
	if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
		 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0)) {
		assert(isContext(frameContext(_theFP)));
		_activeContext = unsignedLongAt(_theFP + FoxThisContext);
		goto l2;
	}
	_activeContext = marryFrameSP(_theFP, _theSP2);
	l2:
	;
	/* end ensureFrameIsMarried:SP: */
	/* begin usedStackPagesDo: */
	/* begin allStackPagesDo: */
	for (_i = 0; _i < GIV(numStackPages); _i += 1) {
		/* begin stackPageAt: */
		_thePage2 = stackPageAtpages(_i, GIV(pages));
		/* end stackPageAt: */
		{
			if (!(((_thePage2->baseFP)) == 0)) {
				{
					divorceFramesIn(_thePage2);
				}
			}
		}
	}
	/* end allStackPagesDo: */
	/* end usedStackPagesDo: */
	/* begin zeroStackPage */
	assert((GIV(stackPage) == 0) || ((((GIV(stackPage)->headFP)) == GIV(framePointer)) && (((GIV(stackPage)->headSP)) == GIV(stackPointer))));
	GIV(stackPage) = 0;
	/* end zeroStackPage */
	return _activeContext;
}
/* StackInterpreter>>#divorceFramesIn: */
static void NoDbgRegParms
divorceFramesIn(StackPage *_aStackPage)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _calleeContext;
	char *_calleeFP;
	sqInt _callerContextOrNil;
	sqInt _theContext;
	char *_theFP;
	sqInt _theIP;
	StackPage *_thePage;
	char *_theSP;
	sqInt _valuePointer;
	sqInt _valuePointer2;

	GIV(statStackPageDivorce) += 1;
	_theFP = (_aStackPage->headFP);
	_theSP = (_aStackPage->headSP);
	_theIP = unsignedLongAt(_theSP);
	_theSP += BytesPerWord;
	_calleeContext = null;
	while (1) {
		/* begin ensureFrameIsMarried:SP: */
		if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
			 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0)) {
			assert(isContext(frameContext(_theFP)));
			_theContext = unsignedLongAt(_theFP + FoxThisContext);
			goto l7;
		}
		_theContext = marryFrameSP(_theFP, _theSP);
		l7:
		;
		/* end ensureFrameIsMarried:SP: */
		updateStateOfSpouseContextForFrameWithSP(_theFP, _theSP);
		/* begin storePointerUnchecked:ofObject:withValue: */
		_valuePointer = contextInstructionPointerframe(_theIP, _theFP);
		assert(!(isOopForwarded(_theContext)));
		longAtput((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), _valuePointer);
		/* end storePointerUnchecked:ofObject:withValue: */
		assert((frameReceiver(_theFP)) == (fetchPointerofObject(ReceiverIndex, _theContext)));
		if (_calleeContext != null) {
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(_calleeContext)));
			if (((_calleeContext & (tagMask())) == 0) && ((_calleeContext & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((_theContext & (tagMask())) == 0) && (((_theContext & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_theContext >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(_calleeContext)) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), _calleeContext);
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(_calleeContext)) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l3;
			}
			if (_theContext & (tagMask())) {
				goto l3;
			}
			if (!(_calleeContext >= 0x20000000000LL)) {
				goto l3;
			}
			if (_theContext >= 0x20000000000LL) {
				goto l3;
			}
			if ((_theContext >= GIV(nilObj)) && (_theContext <= GIV(trueObj))) {
				goto l3;
			}
			if (!(_theContext >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l3;
			}
			remember(getFromPermToNewSpaceRememberedSet(), _calleeContext);
			l3:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((_calleeContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), _theContext);
			/* end storePointer:ofObject:withValue: */
		}
		_calleeContext = _theContext;
		_calleeFP = _theFP;
		_theIP = ((sqInt) (pointerForOop(unsignedLongAt(_theFP + FoxCallerSavedIP))) );
		_theFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP));
		if (!(_theFP != 0)) 
			break;
		{
			assert(!(isBaseFrame(_calleeFP)));
			_theSP = (_calleeFP + (frameStackedReceiverOffset(_calleeFP))) + BytesPerWord;
		}
	}
	/* begin storePointer:ofObject:withValue: */
	/* begin frameCallerContext: */
	assert(isBaseFrame(_calleeFP));
	/* begin stackPageFor: */
	/* begin stackPageAt: */
	_thePage = stackPageAtpages((assert((((char *) _calleeFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _calleeFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_calleeFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
	/* end stackPageAt: */
	/* end stackPageFor: */
	_callerContextOrNil = unsignedLongAt((_thePage->baseAddress));
	assert(addressCouldBeObj(_callerContextOrNil));
	assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
	_valuePointer2 = _callerContextOrNil;
	/* end frameCallerContext: */
	assert(!(isForwarded(_theContext)));
	if (((_theContext & (tagMask())) == 0) && ((_theContext & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((_valuePointer2 & (tagMask())) == 0) && (((_valuePointer2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_valuePointer2 >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_theContext)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _theContext);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(_theContext)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l5;
	}
	if (_valuePointer2 & (tagMask())) {
		goto l5;
	}
	if (!(_theContext >= 0x20000000000LL)) {
		goto l5;
	}
	if (_valuePointer2 >= 0x20000000000LL) {
		goto l5;
	}
	if ((_valuePointer2 >= GIV(nilObj)) && (_valuePointer2 <= GIV(trueObj))) {
		goto l5;
	}
	if (!(_valuePointer2 >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l5;
	}
	remember(getFromPermToNewSpaceRememberedSet(), _theContext);
	l5:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), _valuePointer2);
	/* end storePointer:ofObject:withValue: */
	(_aStackPage->baseFP = 0);
}
/*	Divorce a single frame and its context. If it is not the top frame of a 
	stack this means splitting its stack. */
/* StackInterpreter>>#divorceFrame:andContext: */
static void NoDbgRegParms
divorceFrameandContext(char *_theFP, sqInt _ctxt)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _callerContextOrNil;
	sqInt _callerCtx;
	char *_callerFP;
	char *_callerFP2;
	sqInt _callerIP;
	char *_callerSP;
	char *_frameAbove;
	StackPage *_lruOrFree;
	StackPage *_newPage;
	int _onCurrent;
	sqInt _theIP;
	StackPage *_thePage;
	StackPage *_thePage2;
	char *_theSP;
	sqInt _valuePointer;

	assert((GIV(stackPage) == 0) || (GIV(stackPage) == (mostRecentlyUsedPage())));
	/* begin stackPageFor: */
	/* begin stackPageAt: */
	_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
	/* end stackPageAt: */
	/* end stackPageFor: */
	if (!((_onCurrent = _thePage == GIV(stackPage)))) {
		markStackPageNextMostRecentlyUsed(_thePage);
	}
	_theSP = findSPOfon(_theFP, _thePage);
	updateStateOfSpouseContextForFrameWithSP(_theFP, _theSP);
	/* begin ensureCallerContext: */
	_callerFP2 = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP));
	if (_callerFP2 == 0) {
		/* begin frameCallerContext: */
		assert(isBaseFrame(_theFP));
		/* begin stackPageFor: */
		/* begin stackPageAt: */
		_thePage2 = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
		/* end stackPageAt: */
		/* end stackPageFor: */
		_callerContextOrNil = unsignedLongAt((_thePage2->baseAddress));
		assert(addressCouldBeObj(_callerContextOrNil));
		assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
		_callerCtx = _callerContextOrNil;
		goto l8;
		/* end frameCallerContext: */
	}
	/* begin ensureFrameIsMarried:SP: */
	if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_callerFP2 + FoxMethod)) )))
		 ? ((unsignedLongAt(_callerFP2 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
		 : (byteAt((_callerFP2 + FoxIFrameFlags) + 2)) != 0)) {
		assert(isContext(frameContext(_callerFP2)));
		_callerCtx = unsignedLongAt(_callerFP2 + FoxThisContext);
		goto l8;
	}
	_callerCtx = marryFrameSP(_callerFP2, (assert(!(isBaseFrame(_theFP))), (_theFP + (frameStackedReceiverOffset(_theFP))) + BytesPerWord));
	/* end ensureFrameIsMarried:SP: */
	l8:
	;
	/* end ensureCallerContext: */
	if (((_frameAbove = findFrameAboveinPage(_theFP, _thePage))) == 0) {
		_theIP = unsignedLongAt((_thePage->headSP));
	} else {
		/* begin newStackPage */
		_lruOrFree = (GIV(mostRecentlyUsedPage)->nextPage);
		if (((_lruOrFree->baseFP)) == 0) {
			_newPage = _lruOrFree;
			goto l3;
		}
		divorceFramesIn(_lruOrFree);
		_newPage = _lruOrFree;
		l3:
		;
		/* end newStackPage */
		_theIP = oopForPointer(pointerForOop(unsignedLongAt(_frameAbove + FoxCallerSavedIP)));
		_frameAbove = moveFramesInthroughtoPage(_thePage, _frameAbove, _newPage);
		if (_onCurrent) {
			/* begin setStackPageAndLimit: */
			assert(_newPage != 0);
			GIV(stackPage) = _newPage;
			if (GIV(stackLimit) != ((char *) ((usqInt) -1 ) )) {
				GIV(stackLimit) = (GIV(stackPage)->stackLimit);
			}
			markStackPageMostRecentlyUsed(_newPage);
			/* end setStackPageAndLimit: */
			/* begin setStackPointersFromPage: */
			GIV(stackPointer) = (_newPage->headSP);
			GIV(framePointer) = (_newPage->headFP);
			/* end setStackPointersFromPage: */
		} else {
			markStackPageMostRecentlyUsed(_newPage);
		}
		assert((frameCallerContext(_frameAbove)) == _ctxt);
	}
	/* begin storePointerUnchecked:ofObject:withValue: */
	_valuePointer = contextInstructionPointerframe(_theIP, _theFP);
	assert(!(isOopForwarded(_ctxt)));
	longAtput((_ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), _valuePointer);
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin storePointer:ofObject:withValue: */
	assert(!(isForwarded(_ctxt)));
	if (((_ctxt & (tagMask())) == 0) && ((_ctxt & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((_callerCtx & (tagMask())) == 0) && (((_callerCtx & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_callerCtx >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_ctxt)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _ctxt);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(_ctxt)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l4;
	}
	if (_callerCtx & (tagMask())) {
		goto l4;
	}
	if (!(_ctxt >= 0x20000000000LL)) {
		goto l4;
	}
	if (_callerCtx >= 0x20000000000LL) {
		goto l4;
	}
	if ((_callerCtx >= GIV(nilObj)) && (_callerCtx <= GIV(trueObj))) {
		goto l4;
	}
	if (!(_callerCtx >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l4;
	}
	remember(getFromPermToNewSpaceRememberedSet(), _ctxt);
	l4:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((_ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), _callerCtx);
	/* end storePointer:ofObject:withValue: */
	_callerFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP));
	if (_callerFP == 0) {
		freeStackPage(_thePage);
	} else {
		_callerIP = oopForPointer(pointerForOop(unsignedLongAt(_theFP + FoxCallerSavedIP)));
		_callerSP = ((assert(!(isBaseFrame(_theFP))), (_theFP + (frameStackedReceiverOffset(_theFP))) + BytesPerWord)) - BytesPerWord;
		unsignedLongAtput(_callerSP, _callerIP);
		/* begin setHeadFP:andSP:inPage: */
		assert(_callerSP < _callerFP);
		assert((_callerSP < ((_thePage->baseAddress))) && (_callerSP > (((_thePage->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
		assert((_callerFP < ((_thePage->baseAddress))) && (_callerFP > (((_thePage->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
		{
			(_thePage->headFP = _callerFP);
			(_thePage->headSP = _callerSP);
		}
		/* end setHeadFP:andSP:inPage: */
	}
}
/*	Rounds negative results towards negative infinity, rather than zero. */
/* StackInterpreter>>#doPrimitiveDiv:by: */
static sqInt NoDbgRegParms
doPrimitiveDivby(sqInt _rcvr, sqInt _arg)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerArg;
	sqInt _integerRcvr;
	sqInt _posArg;
	sqInt _posRcvr;
	sqInt _result;
	sqInt _successBoolean;

	_integerArg = 0;
	_integerRcvr = 0;
	if ((_rcvr & _arg) & (smallIntegerTag())) {
		_integerRcvr = _rcvr >> 3;
		_integerArg = _arg >> 3;
		/* begin success: */
		if (!(_integerArg != 0)) {
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
		}
		/* end success: */
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	}
	if (GIV(primFailCode)) {
		return 1;
	}
	if (_integerRcvr > 0) {
		if (_integerArg > 0) {
			_result = _integerRcvr / _integerArg;
		} else {
			_posArg = 0 - _integerArg;
			_result = 0 - ((_integerRcvr + (_posArg - 1)) / _posArg);
		}
	} else {
		_posRcvr = 0 - _integerRcvr;
		if (_integerArg > 0) {
			_result = 0 - ((_posRcvr + (_integerArg - 1)) / _integerArg);
		} else {
			_posArg = 0 - _integerArg;
			_result = _posRcvr / _posArg;
		}
	}
	/* begin success: */
	_successBoolean = (((((usqInt) _result ) >> 60) + 1) & 15) <= 1;
	if (!_successBoolean) {
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
	}
	/* end success: */
	return _result;
}
/* StackInterpreter>>#doPrimitiveMod:by: */
static sqInt NoDbgRegParms
doPrimitiveModby(sqInt _rcvr, sqInt _arg)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerArg;
	sqInt _integerRcvr;
	sqInt _integerResult;
	sqInt _successBoolean;

	_integerArg = 0;
	_integerRcvr = 0;
	if ((_rcvr & _arg) & (smallIntegerTag())) {
		_integerRcvr = _rcvr >> 3;
		_integerArg = _arg >> 3;
		/* begin success: */
		if (!(_integerArg != 0)) {
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
		}
		/* end success: */
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	}
	if (GIV(primFailCode)) {
		return 1;
	}
	_integerResult = _integerRcvr % _integerArg;
	if (_integerArg < 0) {
		if (_integerResult > 0) {
			_integerResult += _integerArg;
		}
	}
 else {
		if (_integerResult < 0) {
			_integerResult += _integerArg;
		}
	}
	/* begin success: */
	_successBoolean = (((((usqInt) _integerResult ) >> 60) + 1) & 15) <= 1;
	if (!_successBoolean) {
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
	}
	/* end success: */
	return _integerResult;
}
/*	Signal the external semaphore with the given index. Answer if a context 
	switch occurs as a result. Do not bounds check. This has been done in the 
	caller.  */
/* StackInterpreter>>#doSignalSemaphoreWithIndex: */
sqInt
doSignalSemaphoreWithIndex(sqInt _index)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _sema;
	sqInt _sema2;
	sqInt _xArray;

	/* begin getExternalSemaphoreWithIndex: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_xArray = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ExternalObjectsArray ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	assert(isArray(_xArray));
	/* begin fetchPointer:ofObject: */
	_sema2 = unsignedLongAt((_xArray + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(!(isOopForwarded(_sema2)));
	assert(isSemaphoreOop(_sema2));
	_sema = _sema2;
	/* end getExternalSemaphoreWithIndex: */
	return (((_sema & (tagMask())) == 0) && (((longAt(_sema)) & (classIndexMask())) == (rawHashBitsOf(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassSemaphore ) << (shiftForWord())) )))))) && (synchronousSignal(_sema));
}
/* StackInterpreter>>#doWaitSemaphore:reEnterInterpreter: */
void
doWaitSemaphorereEnterInterpreter(sqInt _sema, sqInt _hasToReenter)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeProc;
	sqInt _excessSignals;
	sqInt _inInterpreter;
	sqInt _objOop;
	sqInt _objOop2;

	_excessSignals = fetchIntegerofObject(ExcessSignalsIndex, _sema);
	if (_excessSignals > 0) {
		/* begin storeInteger:ofObject:withValue: */
		if ((((((usqInt) (_excessSignals - 1) ) >> 60) + 1) & 15) <= 1) {
			/* begin storePointerUnchecked:ofObject:withValue: */
			assert(!(isOopForwarded(_sema)));
			longAtput((_sema + BaseHeaderSize) + ((sqInt) (((usqInt) ExcessSignalsIndex ) << (shiftForWord())) ), ((((usqInt) (_excessSignals - 1) ) << 3) | 1));
			/* end storePointerUnchecked:ofObject:withValue: */
		} else {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
		}
		/* end storeInteger:ofObject:withValue: */
	} else {
		_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
		/* begin memoryActiveProcess */
		/* begin fetchPointer:ofObject: */
		/* begin fetchPointer:ofObject: */
		/* begin splObj: */
		/* begin fetchPointer:ofObject: */
		_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		_activeProc = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end memoryActiveProcess */
		addLastLinktoList(_activeProc, _sema);
		transferTofrom(wakeHighestPriority(), CSWait);
		if (_hasToReenter) {
			/* begin forProcessPrimitiveReturnToExecutivePostContextSwitch: */
			if (GIV(nextProfileTick) > 0) {
				checkProfileTick(GIV(newMethod));
			}
			returnToExecutivepostContextSwitch(_inInterpreter, 1);
			/* end forProcessPrimitiveReturnToExecutivePostContextSwitch: */
		}
	}
}
/*	For ``fast'' temporary access (ok, to mitigate slower temp access) we need 
	fast access to a method's numArgs. Could have a variable set on save and 
	return. We'll investigate this. For the moment we just use a byte in the 
	frameFlags field. This is endian dependent. Store numArgs in byte at 
	FoxFrameFields + 1. 
	Store hasContext flag in top bit (allows for 64-bit tags) of byte at 
	FoxFrameFields. Make frameFields look like a SmallInteger for the benefit 
	of gc (dubious).bitsPerWord := BytesPerWord * 8 */
/* StackInterpreter>>#encodeFrameFieldHasContext:isBlock:numArgs: */
static sqInt NoDbgRegParms
encodeFrameFieldHasContextisBlocknumArgs(sqInt _hasContext, sqInt _isBlock, sqInt _numArgs)
{
	return ((VMBIGENDIAN)
		 ? ((1 + ((sqInt) (((usqInt) _numArgs ) << ((BytesPerWord * 8) - 8)) )) + (((_hasContext)
			 ? 1ULL << ((BytesPerWord * 8) - 16)
			 : 0))) + (((_isBlock)
			 ? 1ULL << ((BytesPerWord * 8) - 24)
			 : 0))
		 : ((1 + ((sqInt) (((usqInt) _numArgs ) << 8) )) + (((_hasContext)
			 ? 1U << 16
			 : 0))) + (((_isBlock)
			 ? 1U << 24
			 : 0)));
}
/*	Answerr the caller context for a frame. If the frame has a caller 
	frame that doesn't have a context, then marry the caller frame. */
/* StackInterpreter>>#ensureCallerContext: */
static sqInt NoDbgRegParms
ensureCallerContext(char *_theFP)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _callerContextOrNil;
	char *_callerFP;
	StackPage *_thePage;

	_callerFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP));
	if (_callerFP == 0) {
		/* begin frameCallerContext: */
		assert(isBaseFrame(_theFP));
		/* begin stackPageFor: */
		/* begin stackPageAt: */
		_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
		/* end stackPageAt: */
		/* end stackPageFor: */
		_callerContextOrNil = unsignedLongAt((_thePage->baseAddress));
		assert(addressCouldBeObj(_callerContextOrNil));
		assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
		return _callerContextOrNil;
		/* end frameCallerContext: */
	}
	/* begin ensureFrameIsMarried:SP: */
	if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_callerFP + FoxMethod)) )))
		 ? ((unsignedLongAt(_callerFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
		 : (byteAt((_callerFP + FoxIFrameFlags) + 2)) != 0)) {
		assert(isContext(frameContext(_callerFP)));
		return unsignedLongAt(_callerFP + FoxThisContext);
	}
	return marryFrameSP(_callerFP, (assert(!(isBaseFrame(_theFP))), (_theFP + (frameStackedReceiverOffset(_theFP))) + BytesPerWord));
	/* end ensureFrameIsMarried:SP: */
}
/*	Ensure the image data has been updated to suit the current VM. */
/* StackInterpreter>>#ensureImageFormatIsUpToDate: */
static void NoDbgRegParms
ensureImageFormatIsUpToDate(sqInt _swapBytes)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _addr;
	sqInt _addr2;
	sqInt _address;
	sqInt _address2;
	sqInt _address22;
	sqInt _address3;
	sqInt _currentObject;
	sqInt _currentObject2;
	sqInt _fmt;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord22;
	sqInt _followingWord3;
	sqInt _followingWord32;
	sqInt _followingWord4;
	sqInt _followingWord42;
	sqInt _followingWord5;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress22;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress32;
	usqInt _followingWordAddress4;
	usqInt _followingWordAddress42;
	usqInt _followingWordAddress5;
	usqInt _limit;
	sqInt _limit2;
	sqInt _limit22;
	usqInt _limit3;
	sqInt _methodHeader;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots22;
	usqInt _numSlots3;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _objOop222;
	sqInt _objOop23;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevObj22;
	sqInt _prevObj3;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;
	sqInt _prevPrevObj22;
	sqInt _prevPrevObj3;
	sqInt _startAddr;
	sqInt _stopAddr;
	sqInt _stopAddr2;
	int _swapFloatWords;
	sqInt _temp;
	sqInt _temp2;
	sqInt _wordAddr;

	if (_swapBytes) {
		/* begin reverseBytesInImage */
		/* begin reverseBytesInMemory */
		/* begin reverseBytesFrom:to: */
		_startAddr = ((sqInt) ((GIV(memoryMap)->oldSpaceStart)) );
		_stopAddr = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_addr = _startAddr;
		while (oopisLessThan(_addr, _stopAddr)) {
			longAtput(_addr, SQ_SWAP_8_BYTES(longAt(_addr)));
			_addr += BytesPerWord;
		}
		/* end reverseBytesFrom:to: */
		/* end reverseBytesInMemory */
		/* begin updateObjectsPostByteSwap */
		_swapFloatWords = VMBIGENDIAN != GIV(imageFloatsBigEndian);
		assert(ClassFloatCompactIndex != 0);
		/* begin allObjectsDo: */
		/* begin allNewSpaceObjectsDo: */
		/* begin allNewSpaceEntitiesDo: */
		_prevPrevObj3 = (_prevObj3 = null);
		assert((((pastSpace()).start)) < (((eden()).start)));
		/* begin objectStartingAt: */
		_address3 = ((pastSpace()).start);
		_numSlots3 = byteAt(_address3 + 7);
		_objOop23 = ((_numSlots3 == (numSlotsMask()))
			 ? _address3 + BaseHeaderSize
			 : _address3);
		/* end objectStartingAt: */
		_limit3 = GIV(pastSpaceStart);
		while (oopisLessThan(_objOop23, _limit3)) {
			{
				assert(isEnumerableObjectNoAssert(_objOop23));
				{
					_fmt = (((usqInt) (longAt(_objOop23)) ) >> (formatShift())) & (formatMask());
					if (_fmt >= (firstByteFormat())) {
						_wordAddr = _objOop23 + BaseHeaderSize;
						if (_fmt >= (firstCompiledMethodFormat())) {
							_methodHeader = longAt(_objOop23 + BaseHeaderSize);
							_wordAddr += (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) + LiteralStart) * BytesPerOop;
						}
						/* begin reverseBytesFrom:to: */
						_stopAddr2 = _objOop23 + (((numSlotsOf(_objOop23)) << (shiftForWord())) + BaseHeaderSize);
						_addr2 = _wordAddr;
						while (oopisLessThan(_addr2, _stopAddr2)) {
							longAtput(_addr2, SQ_SWAP_8_BYTES(longAt(_addr2)));
							_addr2 += BytesPerWord;
						}
						/* end reverseBytesFrom:to: */
					}
					if (_fmt == (firstLongFormat())) {
						if (_swapFloatWords && ((compactClassIndexOf(_objOop23)) == ClassFloatCompactIndex)) {
							_temp2 = longAt(_objOop23 + BaseHeaderSize);
							longAtput(_objOop23 + BaseHeaderSize, longAt((_objOop23 + BaseHeaderSize) + 4));
							longAtput((_objOop23 + BaseHeaderSize) + 4, _temp2);
						}
					}
				}
			}
			_prevPrevObj3 = _prevObj3;
			_prevObj3 = _objOop23;
			/* begin objectAfter:limit: */
			_followingWordAddress5 = addressAfter(_objOop23);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress5, _limit3)) {
				_objOop23 = _limit3;
				goto l10;
			}
			flag("endianness");
			_followingWord5 = unsignedLongAt(_followingWordAddress5);
			_objOop23 = (((((usqInt) _followingWord5 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress5 + BaseHeaderSize
				 : _followingWordAddress5);
			l10:
			;
			/* end objectAfter:limit: */
		}
		/* begin objectStartingAt: */
		_address22 = ((eden()).start);
		_numSlots22 = byteAt(_address22 + 7);
		_objOop23 = ((_numSlots22 == (numSlotsMask()))
			 ? _address22 + BaseHeaderSize
			 : _address22);
		/* end objectStartingAt: */
		while (oopisLessThan(_objOop23, GIV(freeStart))) {
			{
				assert(isEnumerableObjectNoAssert(_objOop23));
				{
					_fmt = (((usqInt) (longAt(_objOop23)) ) >> (formatShift())) & (formatMask());
					if (_fmt >= (firstByteFormat())) {
						_wordAddr = _objOop23 + BaseHeaderSize;
						if (_fmt >= (firstCompiledMethodFormat())) {
							_methodHeader = longAt(_objOop23 + BaseHeaderSize);
							_wordAddr += (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) + LiteralStart) * BytesPerOop;
						}
						/* begin reverseBytesFrom:to: */
						_stopAddr2 = _objOop23 + (((numSlotsOf(_objOop23)) << (shiftForWord())) + BaseHeaderSize);
						_addr2 = _wordAddr;
						while (oopisLessThan(_addr2, _stopAddr2)) {
							longAtput(_addr2, SQ_SWAP_8_BYTES(longAt(_addr2)));
							_addr2 += BytesPerWord;
						}
						/* end reverseBytesFrom:to: */
					}
					if (_fmt == (firstLongFormat())) {
						if (_swapFloatWords && ((compactClassIndexOf(_objOop23)) == ClassFloatCompactIndex)) {
							_temp2 = longAt(_objOop23 + BaseHeaderSize);
							longAtput(_objOop23 + BaseHeaderSize, longAt((_objOop23 + BaseHeaderSize) + 4));
							longAtput((_objOop23 + BaseHeaderSize) + 4, _temp2);
						}
					}
				}
			}
			_prevPrevObj3 = _prevObj3;
			_prevObj3 = _objOop23;
			/* begin objectAfter:limit: */
			_followingWordAddress22 = addressAfter(_objOop23);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress22, GIV(freeStart))) {
				_objOop23 = GIV(freeStart);
				goto l13;
			}
			flag("endianness");
			_followingWord22 = unsignedLongAt(_followingWordAddress22);
			_objOop23 = (((((usqInt) _followingWord22 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress22 + BaseHeaderSize
				 : _followingWordAddress22);
			l13:
			;
			/* end objectAfter:limit: */
		}
		/* end allNewSpaceEntitiesDo: */
		/* end allNewSpaceObjectsDo: */
		/* begin allOldSpaceObjectsDo: */
		/* begin allOldSpaceObjectsFrom:do: */
		/* begin allOldSpaceEntitiesFrom:do: */
		assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
		_prevPrevObj22 = (_prevObj22 = null);
		_objOop222 = GIV(nilObj);
		while (1) {
			assert((_objOop222 % (allocationUnit())) == 0);
			if (!(oopisLessThan(_objOop222, (GIV(memoryMap)->oldSpaceEnd)))) 
				break;
			assert((uint64AtPointer(_objOop222)) != 0);
			{
				if (isEnumerableObject(_objOop222)) {
					{
						_fmt = (((usqInt) (longAt(_objOop222)) ) >> (formatShift())) & (formatMask());
						if (_fmt >= (firstByteFormat())) {
							_wordAddr = _objOop222 + BaseHeaderSize;
							if (_fmt >= (firstCompiledMethodFormat())) {
								_methodHeader = longAt(_objOop222 + BaseHeaderSize);
								_wordAddr += (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) + LiteralStart) * BytesPerOop;
							}
							/* begin reverseBytesFrom:to: */
							_stopAddr2 = _objOop222 + (((numSlotsOf(_objOop222)) << (shiftForWord())) + BaseHeaderSize);
							_addr2 = _wordAddr;
							while (oopisLessThan(_addr2, _stopAddr2)) {
								longAtput(_addr2, SQ_SWAP_8_BYTES(longAt(_addr2)));
								_addr2 += BytesPerWord;
							}
							/* end reverseBytesFrom:to: */
						}
						if (_fmt == (firstLongFormat())) {
							if (_swapFloatWords && ((compactClassIndexOf(_objOop222)) == ClassFloatCompactIndex)) {
								_temp2 = longAt(_objOop222 + BaseHeaderSize);
								longAtput(_objOop222 + BaseHeaderSize, longAt((_objOop222 + BaseHeaderSize) + 4));
								longAtput((_objOop222 + BaseHeaderSize) + 4, _temp2);
							}
						}
					}
				}
			}
			_prevPrevObj22 = _prevObj22;
			_prevObj22 = _objOop222;
			/* begin objectAfter:limit: */
			_limit22 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			_followingWordAddress42 = addressAfter(_objOop222);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress42, _limit22)) {
				_objOop222 = _limit22;
				goto l11;
			}
			flag("endianness");
			_followingWord42 = unsignedLongAt(_followingWordAddress42);
			_objOop222 = (((((usqInt) _followingWord42 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress42 + BaseHeaderSize
				 : _followingWordAddress42);
			l11:
			;
			/* end objectAfter:limit: */
		}
		/* end allOldSpaceEntitiesFrom:do: */
		/* end allOldSpaceObjectsFrom:do: */
		/* end allOldSpaceObjectsDo: */
		/* begin allPermSpaceObjectsDo: */
		_currentObject2 = (GIV(memoryMap)->permSpaceStart);
		while (!(_currentObject2 == GIV(permSpaceFreeStart))) {
			if (!(((longAt(_currentObject2)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
				{
					_fmt = (((usqInt) (longAt(_currentObject2)) ) >> (formatShift())) & (formatMask());
					if (_fmt >= (firstByteFormat())) {
						_wordAddr = _currentObject2 + BaseHeaderSize;
						if (_fmt >= (firstCompiledMethodFormat())) {
							_methodHeader = longAt(_currentObject2 + BaseHeaderSize);
							_wordAddr += (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) + LiteralStart) * BytesPerOop;
						}
						/* begin reverseBytesFrom:to: */
						_stopAddr2 = _currentObject2 + (((numSlotsOf(_currentObject2)) << (shiftForWord())) + BaseHeaderSize);
						_addr2 = _wordAddr;
						while (oopisLessThan(_addr2, _stopAddr2)) {
							longAtput(_addr2, SQ_SWAP_8_BYTES(longAt(_addr2)));
							_addr2 += BytesPerWord;
						}
						/* end reverseBytesFrom:to: */
					}
					if (_fmt == (firstLongFormat())) {
						if (_swapFloatWords && ((compactClassIndexOf(_currentObject2)) == ClassFloatCompactIndex)) {
							_temp2 = longAt(_currentObject2 + BaseHeaderSize);
							longAtput(_currentObject2 + BaseHeaderSize, longAt((_currentObject2 + BaseHeaderSize) + 4));
							longAtput((_currentObject2 + BaseHeaderSize) + 4, _temp2);
						}
					}
				}
			}
			/* begin objectAfter:limit: */
			_followingWordAddress32 = addressAfter(_currentObject2);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress32, GIV(permSpaceFreeStart))) {
				_currentObject2 = GIV(permSpaceFreeStart);
				goto l14;
			}
			flag("endianness");
			_followingWord32 = unsignedLongAt(_followingWordAddress32);
			_currentObject2 = (((((usqInt) _followingWord32 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress32 + BaseHeaderSize
				 : _followingWordAddress32);
			l14:
			;
			/* end objectAfter:limit: */
		}
		/* end allPermSpaceObjectsDo: */
		/* end allObjectsDo: */
		/* end updateObjectsPostByteSwap */
		/* end reverseBytesInImage */
	} else {
		/* begin convertFloatsToPlatformOrder */
		if (VMBIGENDIAN == GIV(imageFloatsBigEndian)) {
			goto l8;
		}
		assert(ClassFloatCompactIndex != 0);
		/* begin allObjectsDo: */
		/* begin allNewSpaceObjectsDo: */
		/* begin allNewSpaceEntitiesDo: */
		_prevPrevObj = (_prevObj = null);
		assert((((pastSpace()).start)) < (((eden()).start)));
		/* begin objectStartingAt: */
		_address = ((pastSpace()).start);
		_numSlots = byteAt(_address + 7);
		_objOop2 = ((_numSlots == (numSlotsMask()))
			 ? _address + BaseHeaderSize
			 : _address);
		/* end objectStartingAt: */
		_limit = GIV(pastSpaceStart);
		while (oopisLessThan(_objOop2, _limit)) {
			{
				assert(isEnumerableObjectNoAssert(_objOop2));
				{
					if ((compactClassIndexOf(_objOop2)) == ClassFloatCompactIndex) {
						_temp = uint32AtPointer(_objOop2 + BaseHeaderSize);
						uint32AtPointerput(_objOop2 + BaseHeaderSize, uint32AtPointer((_objOop2 + BaseHeaderSize) + 4));
						uint32AtPointerput((_objOop2 + BaseHeaderSize) + 4, _temp);
					}
				}
			}
			_prevPrevObj = _prevObj;
			_prevObj = _objOop2;
			/* begin objectAfter:limit: */
			_followingWordAddress = addressAfter(_objOop2);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
				_objOop2 = _limit;
				goto l2;
			}
			flag("endianness");
			_followingWord = unsignedLongAt(_followingWordAddress);
			_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress + BaseHeaderSize
				 : _followingWordAddress);
			l2:
			;
			/* end objectAfter:limit: */
		}
		/* begin objectStartingAt: */
		_address2 = ((eden()).start);
		_numSlots2 = byteAt(_address2 + 7);
		_objOop2 = ((_numSlots2 == (numSlotsMask()))
			 ? _address2 + BaseHeaderSize
			 : _address2);
		/* end objectStartingAt: */
		while (oopisLessThan(_objOop2, GIV(freeStart))) {
			{
				assert(isEnumerableObjectNoAssert(_objOop2));
				{
					if ((compactClassIndexOf(_objOop2)) == ClassFloatCompactIndex) {
						_temp = uint32AtPointer(_objOop2 + BaseHeaderSize);
						uint32AtPointerput(_objOop2 + BaseHeaderSize, uint32AtPointer((_objOop2 + BaseHeaderSize) + 4));
						uint32AtPointerput((_objOop2 + BaseHeaderSize) + 4, _temp);
					}
				}
			}
			_prevPrevObj = _prevObj;
			_prevObj = _objOop2;
			/* begin objectAfter:limit: */
			_followingWordAddress2 = addressAfter(_objOop2);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
				_objOop2 = GIV(freeStart);
				goto l3;
			}
			flag("endianness");
			_followingWord2 = unsignedLongAt(_followingWordAddress2);
			_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress2 + BaseHeaderSize
				 : _followingWordAddress2);
			l3:
			;
			/* end objectAfter:limit: */
		}
		/* end allNewSpaceEntitiesDo: */
		/* end allNewSpaceObjectsDo: */
		/* begin allOldSpaceObjectsDo: */
		/* begin allOldSpaceObjectsFrom:do: */
		/* begin allOldSpaceEntitiesFrom:do: */
		assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
		_prevPrevObj2 = (_prevObj2 = null);
		_objOop22 = GIV(nilObj);
		while (1) {
			assert((_objOop22 % (allocationUnit())) == 0);
			if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
				break;
			assert((uint64AtPointer(_objOop22)) != 0);
			{
				if (isEnumerableObject(_objOop22)) {
					{
						if ((compactClassIndexOf(_objOop22)) == ClassFloatCompactIndex) {
							_temp = uint32AtPointer(_objOop22 + BaseHeaderSize);
							uint32AtPointerput(_objOop22 + BaseHeaderSize, uint32AtPointer((_objOop22 + BaseHeaderSize) + 4));
							uint32AtPointerput((_objOop22 + BaseHeaderSize) + 4, _temp);
						}
					}
				}
			}
			_prevPrevObj2 = _prevObj2;
			_prevObj2 = _objOop22;
			/* begin objectAfter:limit: */
			_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			_followingWordAddress4 = addressAfter(_objOop22);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
				_objOop22 = _limit2;
				goto l7;
			}
			flag("endianness");
			_followingWord4 = unsignedLongAt(_followingWordAddress4);
			_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress4 + BaseHeaderSize
				 : _followingWordAddress4);
			l7:
			;
			/* end objectAfter:limit: */
		}
		/* end allOldSpaceEntitiesFrom:do: */
		/* end allOldSpaceObjectsFrom:do: */
		/* end allOldSpaceObjectsDo: */
		/* begin allPermSpaceObjectsDo: */
		_currentObject = (GIV(memoryMap)->permSpaceStart);
		while (!(_currentObject == GIV(permSpaceFreeStart))) {
			if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
				{
					if ((compactClassIndexOf(_currentObject)) == ClassFloatCompactIndex) {
						_temp = uint32AtPointer(_currentObject + BaseHeaderSize);
						uint32AtPointerput(_currentObject + BaseHeaderSize, uint32AtPointer((_currentObject + BaseHeaderSize) + 4));
						uint32AtPointerput((_currentObject + BaseHeaderSize) + 4, _temp);
					}
				}
			}
			/* begin objectAfter:limit: */
			_followingWordAddress3 = addressAfter(_currentObject);
			if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
				_currentObject = GIV(permSpaceFreeStart);
				goto l6;
			}
			flag("endianness");
			_followingWord3 = unsignedLongAt(_followingWordAddress3);
			_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? _followingWordAddress3 + BaseHeaderSize
				 : _followingWordAddress3);
			l6:
			;
			/* end objectAfter:limit: */
		}
		/* end allPermSpaceObjectsDo: */
		/* end allObjectsDo: */
		l8:
		;
		/* end convertFloatsToPlatformOrder */
	}
}
/*	Ensure aFramePtr is a base frame. Then we can assign its sender. 
	Answer the possibly moved location of the frame. */
/* StackInterpreter>>#ensureIsBaseFrame: */
static char * NoDbgRegParms
ensureIsBaseFrame(char *_aFramePtr)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	int _onCurrent;
	char *_theFP;
	StackPage *_thePage;
	StackPage *_thePage2;

	if ((unsignedLongAt(_aFramePtr + FoxSavedFP)) == 0) {
		return _aFramePtr;
	}
	_theFP = _aFramePtr;
	/* begin stackPageFor: */
	/* begin stackPageAt: */
	_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
	/* end stackPageAt: */
	/* end stackPageFor: */
	_onCurrent = _thePage == GIV(stackPage);
	_theFP = storeSenderOfFramewithValue(_theFP, ensureCallerContext(_theFP));
	if (_onCurrent) {
		assert(GIV(stackPage) != _thePage);
		/* begin setStackPointersFromPage: */
		_thePage2 = GIV(stackPage);
		GIV(stackPointer) = (_thePage2->headSP);
		GIV(framePointer) = (_thePage2->headFP);
		/* end setStackPointersFromPage: */
	} else {
		markStackPageMostRecentlyUsed(GIV(stackPage));
	}
	assert(pageListIsWellFormed());
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	return _theFP;
}
/* StackInterpreter>>#establishFrameForContextToReturnTo: */
static char * NoDbgRegParms
establishFrameForContextToReturnTo(sqInt _contextToReturnTo)
{
	sqInt _senderOop;
	StackPage *_thePage;

	if (!(((_contextToReturnTo & (tagMask())) == 0) && (((longAt(_contextToReturnTo)) & (classIndexMask())) == ClassMethodContextCompactIndex))) {
		return 0;
	}
	if ((((unsignedLongAt((_contextToReturnTo + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
		if (isWidowedContext(_contextToReturnTo)) {
			return 0;
		}
		/* begin frameOfMarriedContext: */
		/* begin fetchPointer:ofObject: */
		_senderOop = unsignedLongAt((_contextToReturnTo + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		return (assert(((_senderOop & 7) == 1)), pointerForOop(_senderOop - 1));
		/* end frameOfMarriedContext: */
	}
	if (!((((unsignedLongAt((_contextToReturnTo + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ))) & 7) == 1))) {
		return 0;
	}
	_thePage = makeBaseFrameFor(_contextToReturnTo);
	markStackPageMostRecentlyUsed(_thePage);
	return (_thePage->baseFP);
}
/*	Invoke a quick primitive. 
	Called under the assumption that primFunctionPtr has been preloaded */
/* StackInterpreter>>#executeQuickPrimitive */
static sqInt
executeQuickPrimitive(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aValue;
	sqInt _localPrimIndex;
	sqInt _objOop;

	assert(isPrimitiveFunctionPointerAnIndex());
	_localPrimIndex = ((sqInt) primitiveFunctionPointer );
	assert((_localPrimIndex > 0xFF) && (_localPrimIndex < 520));
	if (_localPrimIndex >= 264) {
		/* begin stackTopPut: */
		/* begin fetchPointer:ofObject: */
		_objOop = unsignedLongAt(GIV(stackPointer));
		_aValue = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (_localPrimIndex - 264) ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		unsignedLongAtput(GIV(stackPointer), _aValue);
		/* end stackTopPut: */
		return 1;
	}
	if (_localPrimIndex == 256) {
		return 1;
	}
	if (_localPrimIndex == 257) {
		/* begin stackTopPut: */
		unsignedLongAtput(GIV(stackPointer), GIV(trueObj));
		/* end stackTopPut: */
		return 1;
	}
	if (_localPrimIndex == 258) {
		/* begin stackTopPut: */
		unsignedLongAtput(GIV(stackPointer), GIV(falseObj));
		/* end stackTopPut: */
		return 1;
	}
	if (_localPrimIndex == 259) {
		/* begin stackTopPut: */
		unsignedLongAtput(GIV(stackPointer), GIV(nilObj));
		/* end stackTopPut: */
		return 1;
	}
	unsignedLongAtput(GIV(stackPointer), ((((usqInt) (_localPrimIndex - 261) ) << 3) | 1));
	return 1;
}
/*	not inlined for breakpoint value... */
/* StackInterpreter>>#failUnbalancedPrimitive */
static void
failUnbalancedPrimitive(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin primitiveFailFor: */
	GIV(primFailCode) = PrimErrBadNumArgs;
	/* end primitiveFailFor: */
}
/*	Fetch the instance variable at the given index of the given object. Return 
	the address of first indexable field of resulting array object, or fail if 
	the instance variable does not contain an indexable bytes or words object.Note: May be called by translated primitive code. */
/* StackInterpreter>>#fetchArray:ofObject: */
void *
fetchArrayofObject(sqInt _fieldIndex, sqInt _objectPointer)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _arrayOop;

	/* begin fetchPointer:ofObject: */
	_arrayOop = unsignedLongAt((_objectPointer + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* begin arrayValueOf: */
	if (((_arrayOop & (tagMask())) == 0) && (isPureBitsFormat((((usqInt) (longAt(_arrayOop)) ) >> (formatShift())) & (formatMask())))) {
		return ((void *) (pointerForOop(_arrayOop + BaseHeaderSize)) );
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	return null;
	/* end primitiveFail */
	/* end arrayValueOf: */
}
/*	Fetch the instance variable at the given index of the given object. Return 
	the C double precision floating point value of that instance variable, or 
	fail if it is not a Float.Note: May be called by translated primitive code. */
/* StackInterpreter>>#fetchFloat:ofObject: */
double
fetchFloatofObject(sqInt _fieldIndex, sqInt _objectPointer)
{
	sqInt _floatOop;

	/* begin fetchPointer:ofObject: */
	_floatOop = unsignedLongAt((_objectPointer + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	return floatValueOf(_floatOop);
}
/*	Note: May be called by translated primitive code. */
/* StackInterpreter>>#fetchInteger:ofObject: */
sqInt
fetchIntegerofObject(sqInt _fieldIndex, sqInt _objectPointer)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _intOop;

	/* begin fetchPointer:ofObject: */
	_intOop = unsignedLongAt((_objectPointer + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* begin checkedIntegerValueOf: */
	if (((_intOop & 7) == 1)) {
		return _intOop >> 3;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	/* end checkedIntegerValueOf: */
}
/*	Fetch a slot from a married context. Compute the value 
	of the relevant inst var from the spouse frame's state. 
	 
	This method assumes frame pointers have been written back. */
/* StackInterpreter>>#fetchPointer:ofMarriedContext: */
static sqInt NoDbgRegParms
fetchPointerofMarriedContext(sqInt _offset, sqInt _aContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _callerContextOrNil;
	char *_callerFP;
	char *_callerFP2;
	char *_fp;
	sqInt _frameNumArgs;
	sqInt _frameNumArgs2;
	sqInt _senderOop;
	sqInt _senderOop2;
	char *_spouseFP;
	char *_theFPAbove;
	sqInt _theIP;
	StackPage *_thePage;
	StackPage *_thePage2;
	sqInt _value;

	assert(isContext(_aContext));
	assert((((GIV(stackPage)->headFP)) == GIV(framePointer)) && (((GIV(stackPage)->headSP)) == GIV(stackPointer)));
	assert(checkIsStillMarriedContextcurrentFP(_aContext, GIV(framePointer)));
	if (_offset <= ReceiverIndex) {
		if (!(_offset <= StackPointerIndex)) {
			/* begin fetchPointer:ofObject: */
			return unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) _offset ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
		}
		/* begin frameOfMarriedContext: */
		/* begin fetchPointer:ofObject: */
		_senderOop = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		{
			assert(((_senderOop & 7) == 1));
			_spouseFP = pointerForOop(_senderOop - 1);
		}
		/* end frameOfMarriedContext: */
		if (_offset == SenderIndex) {
			/* begin ensureCallerContext: */
			_callerFP2 = pointerForOop(unsignedLongAt(_spouseFP + FoxSavedFP));
			if (_callerFP2 == 0) {
				/* begin frameCallerContext: */
				assert(isBaseFrame(_spouseFP));
				/* begin stackPageFor: */
				/* begin stackPageAt: */
				_thePage2 = stackPageAtpages((assert((((char *) _spouseFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _spouseFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_spouseFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
				/* end stackPageAt: */
				/* end stackPageFor: */
				_callerContextOrNil = unsignedLongAt((_thePage2->baseAddress));
				assert(addressCouldBeObj(_callerContextOrNil));
				assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
				return _callerContextOrNil;
				/* end frameCallerContext: */
			}
			/* begin ensureFrameIsMarried:SP: */
			if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_callerFP2 + FoxMethod)) )))
				 ? ((unsignedLongAt(_callerFP2 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
				 : (byteAt((_callerFP2 + FoxIFrameFlags) + 2)) != 0)) {
				assert(isContext(frameContext(_callerFP2)));
				return unsignedLongAt(_callerFP2 + FoxThisContext);
			}
			return marryFrameSP(_callerFP2, (assert(!(isBaseFrame(_spouseFP))), (_spouseFP + (frameStackedReceiverOffset(_spouseFP))) + BytesPerWord));
			/* end ensureFrameIsMarried:SP: */
			/* end ensureCallerContext: */
		}
		if (_offset == StackPointerIndex) {
			return ((((usqInt) (stackPointerIndexForFrame(_spouseFP)) ) << 3) | 1);
		}
		if (_offset == InstructionPointerIndex) {
			/* begin instructionPointerForFrame:currentFP:currentIP: */
			{
				if (_spouseFP == GIV(framePointer)) {
					_theIP = oopForPointer(GIV(instructionPointer));
				} else {
					/* begin stackPageFor: */
					/* begin stackPageAt: */
					_thePage = stackPageAtpages((assert((((char *) _spouseFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _spouseFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_spouseFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
					/* end stackPageAt: */
					/* end stackPageFor: */
					/* begin findFrameAbove:inPage: */
					_fp = (_thePage->headFP);
					if (_fp == _spouseFP) {
						_theFPAbove = 0;
						goto l6;
					}
					while (((_callerFP = pointerForOop(unsignedLongAt(_fp + FoxSavedFP)))) != 0) {
						if (_callerFP == _spouseFP) {
							_theFPAbove = _fp;
							goto l6;
						}
						_fp = _callerFP;
					}
					error("did not find theFP in stack page");
					_theFPAbove = 0;
					l6:
					;
					/* end findFrameAbove:inPage: */
					_theIP = ((_theFPAbove == 0)
						 ? longAt((_thePage->headSP))
						 : oopForPointer(pointerForOop(unsignedLongAt(_theFPAbove + FoxCallerSavedIP))));
				}
				_value = contextInstructionPointerframe(_theIP, _spouseFP);
			}
			return ((((int) _value ) < 0)
				 ? mustMapMachineCodePCcontext(_value >> 3, unsignedLongAt(_spouseFP + FoxThisContext))
				 : _value);
			/* end instructionPointerForFrame:currentFP:currentIP: */
		}
	}
	/* begin frameOfMarriedContext: */
	/* begin fetchPointer:ofObject: */
	_senderOop2 = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	{
		assert(((_senderOop2 & 7) == 1));
		_spouseFP = pointerForOop(_senderOop2 - 1);
	}
	/* end frameOfMarriedContext: */
	return ((((_offset - ReceiverIndex) >= 1) && ((_offset - ReceiverIndex) <= (stackPointerIndexForFrame(_spouseFP))))
		 ? ((isMachineCodeIP(((usqInt) (unsignedLongAt(_spouseFP + FoxMethod)) )))
			 ? (((_offset - (ReceiverIndex + 1)) < ((_frameNumArgs = ((((CogMethod *) ((unsignedLongAt(_spouseFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs))))
				 ? unsignedLongAt((_spouseFP + FoxCallerSavedIP) + ((_frameNumArgs - (_offset - (ReceiverIndex + 1))) * BytesPerWord))
				 : unsignedLongAt(((((isMachineCodeIP(((usqInt) (unsignedLongAt(_spouseFP + FoxMethod)) )))
					 ? _spouseFP + FoxMFReceiver
					 : _spouseFP + FoxIFReceiver)) - BytesPerWord) + ((_frameNumArgs - (_offset - (ReceiverIndex + 1))) * BytesPerWord)))
			 : (((_offset - (ReceiverIndex + 1)) < ((_frameNumArgs2 = byteAt((_spouseFP + FoxIFrameFlags) + 1))))
				 ? unsignedLongAt((_spouseFP + FoxCallerSavedIP) + ((_frameNumArgs2 - (_offset - (ReceiverIndex + 1))) * BytesPerWord))
				 : unsignedLongAt(((_spouseFP + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs2 - (_offset - (ReceiverIndex + 1))) * BytesPerWord))))
		 : (/* begin nilObject */ GIV(nilObj) /* end nilObject */));
}
/*	Return the stackPointer of a Context or BlockContext. 
	Does not deal with married contexts. Use only for debug 
	printing or object tracing functions. To obtain an accurate 
	stack pointer use stackPointerForMaybeMarriedContext: */
/* StackInterpreter>>#fetchStackPointerOf: */
static sqInt NoDbgRegParms
fetchStackPointerOf(sqInt _aContext)
{
	sqInt _sp;

	/* begin fetchPointer:ofObject: */
	_sp = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (!(((_sp & 7) == 1))) {
		return 0;
	}
	assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_aContext)));
	return _sp >> 3;
}
/* StackInterpreter>>#findClassContainingMethod:startingAt: */
static sqInt NoDbgRegParms
findClassContainingMethodstartingAt(sqInt _meth, sqInt _classObj)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classDict;
	usqInt _classDictSize;
	sqInt _currClass;
	int _i;
	sqInt _methodArray;
	usqInt _numSlots;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _objOop3;
	sqInt _referent;
	sqInt _referent2;
	sqInt _referent3;
	sqInt _referent4;

	if (((_classObj & (tagMask())) == 0) && (((long64At(_classObj)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(_classObj));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_classObj + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		_currClass = _referent;
		/* end followForwarded: */
	} else {
		_currClass = _classObj;
	}
	do {
		assert(!(isForwarded(_currClass)));
		if (!(addressCouldBeClassObj(_currClass))) {
			/* begin nilObject */
			return GIV(nilObj);
			/* end nilObject */
		}
		/* begin noFixupFollowField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop2 = unsignedLongAt((_currClass + BaseHeaderSize) + ((sqInt) (((usqInt) MethodDictionaryIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_objOop2 & (tagMask())) == 0) && (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin followForwarded: */
			assert(isUnambiguouslyForwarder(_objOop2));
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent3 = unsignedLongAt((_objOop2 + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
			while (((_referent3 & (tagMask())) == 0) && (((long64At(_referent3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent3 = unsignedLongAt((_referent3 + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
			}
			_objOop2 = _referent3;
			/* end followForwarded: */
		}
		_classDict = _objOop2;
		/* end noFixupFollowField:ofObject: */
		assert(!(isForwarded(_classDict)));
		/* begin numSlotsOf: */
		assert((classIndexOf(_classDict)) > (isForwardedObjectClassIndexPun()));
		_numSlots = byteAt(_classDict + 7);
		_classDictSize = ((_numSlots == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_classDict - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots);
		/* end numSlotsOf: */
		if (_classDictSize > MethodArrayIndex) {
			/* begin noFixupFollowField:ofObject: */
			/* begin fetchPointer:ofObject: */
			_objOop = unsignedLongAt((_classDict + BaseHeaderSize) + ((sqInt) (((usqInt) MethodArrayIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin followForwarded: */
				assert(isUnambiguouslyForwarder(_objOop));
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent2 = unsignedLongAt((_objOop + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
				while (((_referent2 & (tagMask())) == 0) && (((long64At(_referent2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent2 = unsignedLongAt((_referent2 + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
				}
				_objOop = _referent2;
				/* end followForwarded: */
			}
			_methodArray = _objOop;
			/* end noFixupFollowField:ofObject: */
			assert(!(isForwarded(_methodArray)));
			_i = 0;
			while (_i < (_classDictSize - SelectorStart)) {
				if (_meth == (noFixupFollowFieldofObject(_i, _methodArray))) {
					return _currClass;
				}
				_i += 1;
			}
		}
		/* begin noFixupFollowField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop3 = unsignedLongAt((_currClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_objOop3 & (tagMask())) == 0) && (((long64At(_objOop3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin followForwarded: */
			assert(isUnambiguouslyForwarder(_objOop3));
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent4 = unsignedLongAt((_objOop3 + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
			while (((_referent4 & (tagMask())) == 0) && (((long64At(_referent4)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent4 = unsignedLongAt((_referent4 + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
			}
			_objOop3 = _referent4;
			/* end followForwarded: */
		}
		_currClass = _objOop3;
		/* end noFixupFollowField:ofObject: */
	} while (!(_currClass == GIV(nilObj)));
	return _currClass;
}
/* StackInterpreter>>#findClassOfMethod:forReceiver: */
sqInt
findClassOfMethodforReceiver(sqInt _meth, sqInt _rcvr)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _rclass;
	sqInt _tagBits;

	if (((_rcvr & (tagMask())) || (addressCouldBeObj(_rcvr))) && (!(((_rcvr & (tagMask())) == 0) && (((long64At(_rcvr)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)))) {
		_rclass = findClassContainingMethodstartingAt(_meth, ((((_tagBits = _rcvr & (tagMask()))) != 0)
			 ? unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) ))
			 : fetchClassOfNonImm(_rcvr)));
		if (_rclass != GIV(nilObj)) {
			return _rclass;
		}
	}
	if (!((addressCouldBeObj(_meth)) && (((((usqInt) (longAt(_meth)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())))) {
		/* begin nilObject */
		return GIV(nilObj);
		/* end nilObject */
	}
	return findClassContainingMethodstartingAt(_meth, safeMethodClassOf(_meth));
}
/*	Answer the frame above theFP (adjacent frame nearest head end). 
	If theFP is the head frame answer 0. */
/* StackInterpreter>>#findFrameAbove:inPage: */
static char * NoDbgRegParms
findFrameAboveinPage(char *_theFP, StackPage *_thePage)
{
	char *_callerFP;
	char *_fp;

	_fp = (_thePage->headFP);
	if (_fp == _theFP) {
		return 0;
	}
	while (((_callerFP = pointerForOop(unsignedLongAt(_fp + FoxSavedFP)))) != 0) {
		if (_callerFP == _theFP) {
			return _fp;
		}
		_fp = _callerFP;
	}
	error("did not find theFP in stack page");
	return 0;
}
/* StackInterpreter>>#findHomeForContext: */
static sqInt NoDbgRegParms
findHomeForContext(sqInt _aContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _closureOrNil;

	if (!(((_aContext & (tagMask())) == 0) && (((longAt(_aContext)) & (classIndexMask())) == ClassMethodContextCompactIndex))) {
		return null;
	}
	/* begin fetchPointer:ofObject: */
	_closureOrNil = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ClosureIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_closureOrNil == GIV(nilObj)) {
		return _aContext;
	}
	if ((compactClassIndexOf(_closureOrNil)) != ClassFullBlockClosureCompactIndex) {
		return null;
	}
	return findHomeForContext(unsignedLongAt((_closureOrNil + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureOuterContextIndex ) << (shiftForWord())) )));
}
/*	See findUnwindThroughContext:. Alas this is mutually recursive with 
	findMethodWithPrimitive:FromFP:SP:ThroughContext: instead of iterative. 
	We're doing the simplest thing that could possibly work. Niceties can 
	wait. Being mutually-recursive with findMethodWithPrimitive:FromFP:UpToContext: 
	gives the author's type inference algorithm headaches. Wimp out by 
	declaring the return type. */
/* StackInterpreter>>#findMethodWithPrimitive:FromContext:UpToContext: */
static sqInt NoDbgRegParms
findMethodWithPrimitiveFromContextUpToContext(sqInt _primitive, sqInt _senderContext, sqInt _homeContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _callerContextOrNil;
	sqInt _senderContext2;
	sqInt _senderOop;
	char *_startFP;
	sqInt _theContext;
	char *_theFP;
	char *_theFPAbove;
	sqInt _theMethod;
	sqInt _theMethod2;
	StackPage *_thePage;
	char *_theSP;

	assert((_senderContext == (nilObject())) || (isContext(_senderContext)));
	assert((_homeContext == (nilObject())) || (isContext(_homeContext)));
	_theContext = _senderContext;
	while (1) {
		if (_theContext == GIV(nilObj)) {
			return _theContext;
		}
		if ((((unsignedLongAt((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) 
			break;
		if (_theContext == _homeContext) {
			return 0;
		}
		if (!((_primitive == 0) || ((unsignedLongAt((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) ClosureIndex ) << (shiftForWord())) ))) != GIV(nilObj)))) {
			/* begin fetchPointer:ofObject: */
			_theMethod = unsignedLongAt((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if ((primitiveIndexOfMethodheader(_theMethod, methodHeaderOf(_theMethod))) == _primitive) {
				return _theContext;
			}
		}
		/* begin fetchPointer:ofObject: */
		_theContext = unsignedLongAt((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
	}
	if (isWidowedContext(_theContext)) {
		/* begin nilObject */
		return GIV(nilObj);
		/* end nilObject */
	}
	/* begin findMethodWithPrimitive:FromFP:UpToContext: */
	/* begin frameOfMarriedContext: */
	/* begin fetchPointer:ofObject: */
	_senderOop = unsignedLongAt((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	{
		assert(((_senderOop & 7) == 1));
		_startFP = pointerForOop(_senderOop - 1);
	}
	/* end frameOfMarriedContext: */
	_theFP = _startFP;
	_theFPAbove = _startFP;
	do {
		if ((((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
			 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0)) && (_homeContext == (unsignedLongAt(_theFP + FoxThisContext)))) {
			return 0;
		}
		if (!((_primitive == 0) || (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagIsBlockFlag) != 0
			 : (byteAt((_theFP + FoxIFrameFlags) + 3)) != 0)))) {
			_theMethod2 = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
				 ? ((mframeHomeMethod(_theFP))->methodObject)
				 : unsignedLongAt(_theFP + FoxMethod));
			if ((primitiveIndexOfMethodheader(_theMethod2, methodHeaderOf(_theMethod2))) == _primitive) {
				if (_theFP == _theFPAbove) {
					_theSP = findSPOfon(_theFP, stackPageFor(_theFP));
				} else {
					{
						assert(!(isBaseFrame(_theFPAbove)));
						_theSP = (_theFPAbove + (frameStackedReceiverOffset(_theFPAbove))) + BytesPerWord;
					}
				}
				/* begin ensureFrameIsMarried:SP: */
				if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
					 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
					 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0)) {
					assert(isContext(frameContext(_theFP)));
					return unsignedLongAt(_theFP + FoxThisContext);
				}
				return marryFrameSP(_theFP, _theSP);
				/* end ensureFrameIsMarried:SP: */
			}
		}
		_theFPAbove = _theFP;
		_theFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP));
	} while (_theFP != 0);
	/* begin frameCallerContext: */
	assert(isBaseFrame(_theFPAbove));
	/* begin stackPageFor: */
	/* begin stackPageAt: */
	_thePage = stackPageAtpages((assert((((char *) _theFPAbove ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFPAbove ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFPAbove, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
	/* end stackPageAt: */
	/* end stackPageFor: */
	_callerContextOrNil = unsignedLongAt((_thePage->baseAddress));
	assert(addressCouldBeObj(_callerContextOrNil));
	assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
	_senderContext2 = _callerContextOrNil;
	/* end frameCallerContext: */
	if (!(((_senderContext2 & (tagMask())) == 0) && (((longAt(_senderContext2)) & (classIndexMask())) == ClassMethodContextCompactIndex))) {
		/* begin nilObject */
		return GIV(nilObj);
		/* end nilObject */
	}
	return findMethodWithPrimitiveFromContextUpToContext(_primitive, _senderContext2, _homeContext);
	/* end findMethodWithPrimitive:FromFP:UpToContext: */
}
/* StackInterpreter>>#findSelectorOfMethod: */
sqInt
findSelectorOfMethod(sqInt _meth)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classDict;
	usqInt _classDictSize;
	sqInt _classObj;
	int _i;
	sqInt _methodArray;
	usqInt _numSlots;
	sqInt _selector;

	if (!(addressCouldBeObj(_meth))) {
		/* begin nilObject */
		return GIV(nilObj);
		/* end nilObject */
	}
	if (((long64At(_meth)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		return findSelectorOfMethod(followForwarded(_meth));
	}
	if (!(((_meth & (tagMask())) == 0) && (((((usqInt) (longAt(_meth)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())))) {
		/* begin nilObject */
		return GIV(nilObj);
		/* end nilObject */
	}
	{
		_selector = maybeSelectorOfMethod(_meth);
		if (!(_selector == null)) {
			return _selector;
		}
	}
	_classObj = safeMethodClassOf(_meth);
	if (addressCouldBeClassObj(_classObj)) {
		/* begin fetchPointer:ofObject: */
		_classDict = unsignedLongAt((_classObj + BaseHeaderSize) + ((sqInt) (((usqInt) MethodDictionaryIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* begin numSlotsOf: */
		assert((classIndexOf(_classDict)) > (isForwardedObjectClassIndexPun()));
		_numSlots = byteAt(_classDict + 7);
		_classDictSize = ((_numSlots == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_classDict - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots);
		/* end numSlotsOf: */
		if (_classDictSize > MethodArrayIndex) {
			/* begin fetchPointer:ofObject: */
			_methodArray = unsignedLongAt((_classDict + BaseHeaderSize) + ((sqInt) (((usqInt) MethodArrayIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			_i = 0;
			while (_i < (_classDictSize - SelectorStart)) {
				if (_meth == (unsignedLongAt((_methodArray + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
					/* begin fetchPointer:ofObject: */
					return unsignedLongAt((_classDict + BaseHeaderSize) + ((sqInt) (((usqInt) (_i + SelectorStart) ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
				}
				_i += 1;
			}
		}
	}
	/* begin nilObject */
	return GIV(nilObj);
	/* end nilObject */
}
/*	Search for the stack pointer for theFP. This points to the hottest item on 
	the frame's stack. 
	DO NOT CALL THIS WITH theFP == localFP OR theFP == framePointer! */
/* StackInterpreter>>#findSPOf:on: */
static char * NoDbgRegParms
findSPOfon(char *_theFP, StackPage *_thePage)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_aFrame;
	char *_prevFrame;
	char *_startFrame;
	char *_theSP;

	assert(!(isFree(_thePage)));
	/* begin findSPOrNilOf:on:startingFrom: */
	_startFrame = (_thePage->headFP);
	if (_startFrame == _theFP) {
		if (((_thePage->headSP)) >= _startFrame) {
			_theSP = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
				 ? _theFP + FoxMFReceiver
				 : _theFP + FoxIFReceiver);
			goto l2;
		}
		_theSP = ((_thePage == GIV(stackPage))
			 ? (_thePage->headSP)
			 : ((_thePage->headSP)) + BytesPerWord);
		goto l2;
	}
	_aFrame = _startFrame;
	while (1) {
		_prevFrame = _aFrame;
		_aFrame = pointerForOop(unsignedLongAt(_aFrame + FoxSavedFP));
		if (!(_aFrame != 0)) 
			break;
		if (_theFP == _aFrame) {
			{
				assert(!(isBaseFrame(_prevFrame)));
				_theSP = (_prevFrame + (frameStackedReceiverOffset(_prevFrame))) + BytesPerWord;
			}
			goto l2;
		}
	}
	_theSP = null;
	l2:
	;
	/* end findSPOrNilOf:on:startingFrom: */
	if (_theSP) {
		return _theSP;
	}
	error("did not find theFP in stack page");
	return 0;
}
/*	Search for either an unwind-protect (activation of method with primitive 
	198) or homeContext along the sender chain, which ever is found first. 
	Return values: 
	0			home context was found on sender chain with no intervening 
	unwind-protects nilObj		home context could not be found => cannotReturn 
	context		the context of an intervening unwind-protect implies home context 
	was foundAlmost always (98%) the home is on the same page, in which case we know it 
	will be found. */
/* StackInterpreter>>#findUnwindThroughContext: */
static sqInt NoDbgRegParms
findUnwindThroughContext(sqInt _homeContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _callerContextOrNil;
	sqInt _ctxtOrNilOrZero;
	sqInt _onSamePage;
	sqInt _senderContext;
	char *_theFP;
	char *_theFPAbove;
	sqInt _theMethod;
	sqInt _theMethod2;
	StackPage *_thePage;
	char *_theSP;

	_onSamePage = (((((unsignedLongAt((_homeContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_homeContext)))) && (((assert((((char *) GIV(framePointer) ) >= (GIV(stackBasePlus1) - 1)) && (((char *) GIV(framePointer) ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(GIV(framePointer), GIV(stackBasePlus1), GIV(bytesPerPage)))) == (pageIndexFor(frameOfMarriedContext(_homeContext))));
	/* begin findMethodWithPrimitive:FromFP:UpToContext: */
	_theFP = GIV(framePointer);
	_theFPAbove = GIV(framePointer);
	do {
		if ((((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
			 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0)) && (_homeContext == (unsignedLongAt(_theFP + FoxThisContext)))) {
			_ctxtOrNilOrZero = 0;
			goto l5;
		}
		if (!(((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagIsBlockFlag) != 0
			 : (byteAt((_theFP + FoxIFrameFlags) + 3)) != 0))) {
			_theMethod2 = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
				 ? ((mframeHomeMethod(_theFP))->methodObject)
				 : unsignedLongAt(_theFP + FoxMethod));
			if ((primitiveIndexOfMethodheader(_theMethod2, methodHeaderOf(_theMethod2))) == 198) {
				if (_theFP == _theFPAbove) {
					_theSP = findSPOfon(_theFP, stackPageFor(_theFP));
				} else {
					{
						assert(!(isBaseFrame(_theFPAbove)));
						_theSP = (_theFPAbove + (frameStackedReceiverOffset(_theFPAbove))) + BytesPerWord;
					}
				}
				/* begin ensureFrameIsMarried:SP: */
				if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
					 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
					 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0)) {
					assert(isContext(frameContext(_theFP)));
					_ctxtOrNilOrZero = unsignedLongAt(_theFP + FoxThisContext);
					goto l5;
				}
				_ctxtOrNilOrZero = marryFrameSP(_theFP, _theSP);
				goto l5;
				/* end ensureFrameIsMarried:SP: */
			}
		}
		_theFPAbove = _theFP;
		_theFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP));
	} while (_theFP != 0);
	/* begin frameCallerContext: */
	assert(isBaseFrame(_theFPAbove));
	/* begin stackPageFor: */
	/* begin stackPageAt: */
	_thePage = stackPageAtpages((assert((((char *) _theFPAbove ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFPAbove ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFPAbove, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
	/* end stackPageAt: */
	/* end stackPageFor: */
	_callerContextOrNil = unsignedLongAt((_thePage->baseAddress));
	assert(addressCouldBeObj(_callerContextOrNil));
	assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
	_senderContext = _callerContextOrNil;
	/* end frameCallerContext: */
	if (!(((_senderContext & (tagMask())) == 0) && (((longAt(_senderContext)) & (classIndexMask())) == ClassMethodContextCompactIndex))) {
		/* begin nilObject */
		_ctxtOrNilOrZero = GIV(nilObj);
		goto l5;
		/* end nilObject */
	}
	_ctxtOrNilOrZero = findMethodWithPrimitiveFromContextUpToContext(198, _senderContext, _homeContext);
	l5:
	;
	/* end findMethodWithPrimitive:FromFP:UpToContext: */
	assert(!(_onSamePage && (_ctxtOrNilOrZero == (nilObject()))));
	if (_ctxtOrNilOrZero == 0) {
		/* begin fetchPointer:ofObject: */
		_theMethod = unsignedLongAt((_homeContext + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if ((primitiveIndexOfMethodheader(_theMethod, methodHeaderOf(_theMethod))) == 198) {
			return _homeContext;
		}
		return 0;
	}
	if (!(_onSamePage || (_ctxtOrNilOrZero == GIV(nilObj)))) {
		if ((findMethodWithPrimitiveFromContextUpToContext(0, _ctxtOrNilOrZero, _homeContext)) == GIV(nilObj)) {
			/* begin nilObject */
			return GIV(nilObj);
			/* end nilObject */
		}
	}
	return _ctxtOrNilOrZero;
}
/*	follow pointers in the current stack frame up to theSP. */
/* StackInterpreter>>#followForwardedFrameContents:stackPointer: */
static void NoDbgRegParms
followForwardedFrameContentsstackPointer(char *_theFP, char *_theSP)
{
	sqInt _iLimit;
	sqInt _oop;
	char *_ptr;
	sqInt _referent;

	for (_ptr = _theSP, _iLimit = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? _theFP + FoxMFReceiver
		 : _theFP + FoxIFReceiver); _ptr <= _iLimit; _ptr += BytesPerWord) {
		_oop = unsignedLongAt(_ptr);
		if (((_oop & (tagMask())) == 0) && (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			unsignedLongAtput(_ptr, followForwarded(_oop));
		}
	}
	for (_ptr = (_theFP + FoxCallerSavedIP) + BytesPerWord, _iLimit = _theFP + (frameStackedReceiverOffsetNumArgs(((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
		 : byteAt((_theFP + FoxIFrameFlags) + 1)))); _ptr <= _iLimit; _ptr += BytesPerWord) {
		_oop = unsignedLongAt(_ptr);
		if (((_oop & (tagMask())) == 0) && (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin followForwarded: */
			assert(isUnambiguouslyForwarder(_oop));
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
			while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
			}
			_oop = _referent;
			/* end followForwarded: */
			unsignedLongAtput(_ptr, _oop);
		}
	}
	if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagIsBlockFlag) != 0
		 : (byteAt((_theFP + FoxIFrameFlags) + 3)) != 0)) {
		assert(_oop == (unsignedLongAt(_theFP + (frameStackedReceiverOffset(_theFP)))));
		followForwardedObjectFieldstoDepth(_oop, 0);
	}
	assert(!(isForwarded(frameMethodObject(_theFP))));
	if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
		 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0)) {
		assert(!(isForwarded(frameContext(_theFP))));
	}
}
/*	Spur's become: is lazy, turning the becommed object into a forwarding 
	object to the other. 
	The read-barrier is minimised by arranging that forwarding pointers will 
	fail a method cache 
	probe, since notionally objects' internals are accessed only via sending 
	messages to them, 
	the exception is primitives that access the internals of the non-receiver 
	argument(s).  
	To avoid a read barrier on bytecode, literal and inst var fetch and 
	non-local return, we scan 
	the receivers (including the stacked receiver for non-local return) and 
	method references 
	in the stack zone and follow any forwarded ones. This is of course way 
	cheaper than 
	scanning all of memory as in the old become. */
/* StackInterpreter>>#followForwardingPointersInStackZone: */
static void NoDbgRegParms
followForwardingPointersInStackZone(sqInt _theBecomeEffectsFlags)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _anOop;
	char *_callerFP;
	sqInt _i;
	sqInt _newOop;
	sqInt _numArgs;
	sqInt _offset;
	usqInt _oop;
	sqInt _referent;
	sqInt _referent2;
	sqInt _referent3;
	sqInt _referent4;
	char *_theFP;
	usqInt _theIPPtr;
	StackPage *_thePage2;
	char *_theSP;
	char *_theSP2;

	if (GIV(stackPage) == 0) {
		assert(isFree(mostRecentlyUsedPage()));
		return;
	}
	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	_theSP2 = GIV(stackPointer);
	assert(_theSP2 < GIV(framePointer));
	assert((_theSP2 < ((GIV(stackPage)->baseAddress))) && (_theSP2 > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(GIV(stackPage)->headFP = GIV(framePointer));
		(GIV(stackPage)->headSP = _theSP2);
	}
	/* end setHeadFP:andSP:inPage: */
	assert(pageListIsWellFormed());
	/* end writeBackHeadFramePointers */
	if (_theBecomeEffectsFlags & BecameCompiledMethodFlag) {
		if (((long64At(GIV(method))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
			_theIPPtr = GIV(instructionPointer) - GIV(method);
			/* begin followForwarded: */
			assert(isUnambiguouslyForwarder(GIV(method)));
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((GIV(method) + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
			while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
			}
			GIV(method) = _referent;
			/* end followForwarded: */
			GIV(instructionPointer) = GIV(method) + _theIPPtr;
		}
		if (((GIV(newMethod) & (tagMask())) == 0) && (((long64At(GIV(newMethod))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin followForwarded: */
			assert(isUnambiguouslyForwarder(GIV(newMethod)));
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent2 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
			while (((_referent2 & (tagMask())) == 0) && (((long64At(_referent2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent2 = unsignedLongAt((_referent2 + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
			}
			GIV(newMethod) = _referent2;
			/* end followForwarded: */
		}
	}
	assert(GIV(stackPage) != 0);
	/* begin usedStackPagesDo: */
	/* begin allStackPagesDo: */
	for (_i = 0; _i < GIV(numStackPages); _i += 1) {
		/* begin stackPageAt: */
		_thePage2 = stackPageAtpages(_i, GIV(pages));
		/* end stackPageAt: */
		{
			if (!(((_thePage2->baseFP)) == 0)) {
				{
					assert(ifCurrentStackPageHasValidHeadPointers(_thePage2));
					_theFP = (_thePage2->headFP);
					_theIPPtr = ((_thePage2 == GIV(stackPage))
						 ? 0
						 : ((usqInt) ((_thePage2->headSP)) ));
					while (1) {
						assert(addressIsInPage(_thePage2, _theFP));
						assert((_theIPPtr == 0) || (addressIsInPage(_thePage2, ((void *) _theIPPtr ))));
						_oop = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
							 ? unsignedLongAt(_theFP + FoxMFReceiver)
							 : unsignedLongAt(_theFP + FoxIFReceiver));
						if (((_oop & (tagMask())) == 0) && (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
							/* begin frameReceiver:put: */
							/* begin followForwarded: */
							assert(isUnambiguouslyForwarder(_oop));
							/* begin fetchPointer:ofMaybeForwardedObject: */
							_referent4 = unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())));
							/* end fetchPointer:ofMaybeForwardedObject: */
							while (((_referent4 & (tagMask())) == 0) && (((long64At(_referent4)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
								/* begin fetchPointer:ofMaybeForwardedObject: */
								_referent4 = unsignedLongAt((_referent4 + BaseHeaderSize) + (0U << (shiftForWord())));
								/* end fetchPointer:ofMaybeForwardedObject: */
							}
							_anOop = _referent4;
							/* end followForwarded: */
							if (isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) ))) {
								longAtput(_theFP + FoxMFReceiver, _anOop);
							}
 else {
								unsignedLongAtput(_theFP + FoxIFReceiver, _anOop);
							}
							/* end frameReceiver:put: */
						}
						if (isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) ))) {
							assert(!(isForwarded(((mframeHomeMethod(_theFP))->methodObject))));
						} else {
							_oop = unsignedLongAt(_theFP + FoxMethod);
							if (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								/* begin followForwarded: */
								assert(isUnambiguouslyForwarder(_oop));
								/* begin fetchPointer:ofMaybeForwardedObject: */
								_referent3 = unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())));
								/* end fetchPointer:ofMaybeForwardedObject: */
								while (((_referent3 & (tagMask())) == 0) && (((long64At(_referent3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
									/* begin fetchPointer:ofMaybeForwardedObject: */
									_referent3 = unsignedLongAt((_referent3 + BaseHeaderSize) + (0U << (shiftForWord())));
									/* end fetchPointer:ofMaybeForwardedObject: */
								}
								_newOop = _referent3;
								/* end followForwarded: */
								_offset = _newOop - _oop;
								if ((_theIPPtr != 0) && ((unsignedLongAt(_theIPPtr)) > _oop)) {
									unsignedLongAtput(_theIPPtr, (unsignedLongAt(_theIPPtr)) + _offset);
								}
								unsignedLongAtput(_theFP + FoxMethod, (_oop = _newOop));
								{
									unsignedLongAtput(_theFP + FoxIFSavedIP, (unsignedLongAt(_theFP + FoxIFSavedIP)) + _offset);
								}
							}
						}
						if ((((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
							 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
							 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0)) && (isForwarded(unsignedLongAt(_theFP + FoxThisContext)))) {
							unsignedLongAtput(_theFP + FoxThisContext, followForwarded(unsignedLongAt(_theFP + FoxThisContext)));
						}
						/* begin frameStackedReceiverOffsetNumArgs: */
						_numArgs = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
							 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
							 : byteAt((_theFP + FoxIFrameFlags) + 1));
						_offset = (FoxCallerSavedIP + BytesPerWord) + ((sqInt) (((usqInt) _numArgs ) << (shiftForWord())) );
						/* end frameStackedReceiverOffsetNumArgs: */
						_oop = unsignedLongAt(_theFP + _offset);
						if (((_oop & (tagMask())) == 0) && (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
							unsignedLongAtput(_theFP + _offset, followForwarded(_oop));
						}
						if (!(((_callerFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP)))) != 0)) 
							break;
						_theIPPtr = ((usqInt) (_theFP + FoxCallerSavedIP) );
						_theFP = _callerFP;
					}
					_theSP = ((_thePage2->baseAddress)) - BytesPerWord;
					while (_theSP <= ((_thePage2->baseAddress))) {
						_oop = unsignedLongAt(_theSP);
						if (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
							unsignedLongAtput(_theSP, followForwarded(_oop));
						}
						_theSP += BytesPerWord;
					}
				}
			}
		}
	}
	/* end allStackPagesDo: */
	/* end usedStackPagesDo: */
}
/*	Force an interrupt check ASAP. 
	Must set the stack page's limit before stackLimit to avoid 
	a race condition if this is called from an interrupt handler. */
/* StackInterpreter>>#forceInterruptCheck */
sqInt
forceInterruptCheck(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	StackPage *_thePage;

	if (GIV(stackLimit) == 0) {
		return null;
	}
	_thePage = GIV(stackPage);
	if ((_thePage != null) && (_thePage != 0)) {
		(_thePage->stackLimit = ((char *) ((usqInt) -1 ) ));
	}
	/* begin allOnesAsCharStar */
	GIV(stackLimit) = ((char *) ((usqInt) -1 ) );
	/* end allOnesAsCharStar */
	sqLowLevelMFence();
	GIV(statForceInterruptCheck) += 1;
	return 0;
}
/*	The first word on the stack holds the base frame's caller context, which 
	is immediately above the stacked receiver. */
/* StackInterpreter>>#frameCallerContext: */
static sqInt NoDbgRegParms
frameCallerContext(char *_theFP)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _callerContextOrNil;
	StackPage *_thePage;

	assert(isBaseFrame(_theFP));
	/* begin stackPageFor: */
	/* begin stackPageAt: */
	_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
	/* end stackPageAt: */
	/* end stackPageFor: */
	_callerContextOrNil = unsignedLongAt((_thePage->baseAddress));
	assert(addressCouldBeObj(_callerContextOrNil));
	assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
	return _callerContextOrNil;
}
/* StackInterpreter>>#frameContext: */
static sqInt NoDbgRegParms
frameContext(char *_theFP)
{
	return unsignedLongAt(_theFP + FoxThisContext);
}
/* StackInterpreter>>#frameOfMarriedContext: */
static char * NoDbgRegParms
frameOfMarriedContext(sqInt _aContext)
{
	sqInt _senderOop;

	/* begin fetchPointer:ofObject: */
	_senderOop = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	return (assert(((_senderOop & 7) == 1)), pointerForOop(_senderOop - 1));
}
/*	Answer the offset in bytes from the a frame pointer to its stacked 
	receiver, given the argument count. The receiver of a message send or the 
	closure of 
	a block activation is always on the stack above any arguments and the 
	frame itself. See the diagram in StackInterpreter 
	class>>initializeFrameIndices.  */
/* StackInterpreter>>#frameStackedReceiverOffsetNumArgs: */
static sqInt NoDbgRegParms
frameStackedReceiverOffsetNumArgs(sqInt _numArgs)
{
	return (FoxCallerSavedIP + BytesPerWord) + ((sqInt) (((usqInt) _numArgs ) << (shiftForWord())) );
}
/*	Answer the offset in bytes from the the frame pointer to its stacked 
	receiver. The receiver of a message send or the closure of a block 
	activation is 
	always on the stack above any arguments and the frame itself. See the 
	diagram in StackInterpreter class>>initializeFrameIndices. */
/* StackInterpreter>>#frameStackedReceiverOffset: */
static sqInt NoDbgRegParms
frameStackedReceiverOffset(char *_theFP)
{
	sqInt _numArgs;

	/* begin frameStackedReceiverOffsetNumArgs: */
	_numArgs = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
		 : byteAt((_theFP + FoxIFrameFlags) + 1));
	return (FoxCallerSavedIP + BytesPerWord) + ((sqInt) (((usqInt) _numArgs ) << (shiftForWord())) );
	/* end frameStackedReceiverOffsetNumArgs: */
}
/*	Free any untraced stack pages. */
/* StackInterpreter>>#freeUntracedStackPages */
static void
freeUntracedStackPages(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	StackPage *_thePage2;

	/* begin usedStackPagesDo: */
	/* begin allStackPagesDo: */
	for (_i = 0; _i < GIV(numStackPages); _i += 1) {
		/* begin stackPageAt: */
		_thePage2 = stackPageAtpages(_i, GIV(pages));
		/* end stackPageAt: */
		{
			if (!(((_thePage2->baseFP)) == 0)) {
				{
					if (((_thePage2->trace)) == StackPageUnreached) {
						assert(noMarkedContextsOnPage(_thePage2));
						freeStackPage(_thePage2);
					}
					assert(((_thePage2->trace = StackPageTraceInvalid)) != 0);
				}
			}
		}
	}
	/* end allStackPagesDo: */
	/* end usedStackPagesDo: */
}
/*	Find an actual function pointer for this primitiveIndex. This is an 
	opportunity to specialise the prim for the relevant class (format for 
	example). Default for now is simply the entry in the base primitiveTable. */
/* StackInterpreter>>#functionPointerFor: */
void (*functionPointerForinClass(sqInt _primIdx))(void)

{
	return ((_primIdx > MaxPrimitiveIndex)
		 ? 0
		 : primitiveTable[_primIdx]);
}
/* StackInterpreter>>#getExternalSemaphoreWithIndex: */
sqInt
getExternalSemaphoreWithIndex(sqInt _index)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _sema;
	sqInt _xArray;

	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_xArray = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ExternalObjectsArray ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	assert(isArray(_xArray));
	/* begin fetchPointer:ofObject: */
	_sema = unsignedLongAt((_xArray + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(!(isOopForwarded(_sema)));
	assert(isSemaphoreOop(_sema));
	return _sema;
}
/* StackInterpreter>>#getNextWakeupUsecs */
usqLong
getNextWakeupUsecs(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(nextWakeupUsecs);
}
/*	For Alien FFI */
/* StackInterpreter>>#getStackPointer */
sqInt *
getStackPointer(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((sqInt *) GIV(stackPointer) );
}
/*	return the global session ID value */
/* StackInterpreter>>#getThisSessionID */
sqInt
getThisSessionID(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(globalSessionID);
}
/*	Handle a send fault that is due to a send using a forwarded selector. 
	Unforward the selector and follow the current method and special 
	selectors array to unforward the source of the forwarded selector. */
/* StackInterpreter>>#handleForwardedSelectorFaultFor: */
static sqInt NoDbgRegParms
handleForwardedSelectorFaultFor(sqInt _selectorOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _referent;

	assert(isOopForwarded(_selectorOop));
	followForwardedFieldsInCurrentMethod();
	/* begin followSpecialSelectors */
	followForwardedObjectFieldstoDepth(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) )), 0);
	/* end followSpecialSelectors */
	/* begin followForwarded: */
	assert(isUnambiguouslyForwarder(_selectorOop));
	/* begin fetchPointer:ofMaybeForwardedObject: */
	_referent = unsignedLongAt((_selectorOop + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofMaybeForwardedObject: */
	while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
	}
	return _referent;
	/* end followForwarded: */
}
/*	Handle a send fault that may be due to a send to a forwarded object. 
	Unforward the receiver on the stack and answer its actual class. */
/* StackInterpreter>>#handleForwardedSendFaultForTag: */
static sqInt NoDbgRegParms
handleForwardedSendFaultForTag(sqInt _classTag)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _rcvr;
	sqInt _referent;
	sqInt _tagBits;

	assert(isForwardedClassTag(_classTag));
	_rcvr = unsignedLongAt(GIV(stackPointer) + (GIV(argumentCount) * BytesPerWord));
	assert(isOopForwarded(_rcvr));
	/* begin followForwarded: */
	assert(isUnambiguouslyForwarder(_rcvr));
	/* begin fetchPointer:ofMaybeForwardedObject: */
	_referent = unsignedLongAt((_rcvr + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofMaybeForwardedObject: */
	while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
	}
	_rcvr = _referent;
	/* end followForwarded: */
	unsignedLongAtput(GIV(stackPointer) + (GIV(argumentCount) * BytesPerWord), _rcvr);
	followForwardedFrameContentsstackPointer(GIV(framePointer), GIV(stackPointer) + ((GIV(argumentCount) + 1) * BytesPerWord));
	if (isPointers(((isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))
		 ? unsignedLongAt(GIV(framePointer) + FoxMFReceiver)
		 : unsignedLongAt(GIV(framePointer) + FoxIFReceiver)))) {
		followForwardedObjectFieldstoDepth(((isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))
			 ? unsignedLongAt(GIV(framePointer) + FoxMFReceiver)
			 : unsignedLongAt(GIV(framePointer) + FoxIFReceiver)), 0);
	}
	return ((((_tagBits = _rcvr & (tagMask()))) != 0)
		 ? _tagBits
		 : (longAt(_rcvr)) & (classIndexMask()));
}
/*	Handle a special send fault that may be due to a special selector 
	send accessing a forwarded object. obj is forwarded. 
	Unforward stack contents and and inst vars and answer obj's target. */
/* StackInterpreter>>#handleSpecialSelectorSendFaultFor:fp:sp: */
static sqInt NoDbgRegParms
handleSpecialSelectorSendFaultForfpsp(sqInt _obj, char *_theFP, char *_theSP)
{
	sqInt _rcvr;
	sqInt _referent;

	assert(isOopForwarded(_obj));
	followForwardedFrameContentsstackPointer(_theFP, _theSP);
	_rcvr = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? unsignedLongAt(_theFP + FoxMFReceiver)
		 : unsignedLongAt(_theFP + FoxIFReceiver));
	if (((_rcvr & (tagMask())) == 0) && (((((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask())) <= 5)) {
		followForwardedObjectFieldstoDepth(_rcvr, 0);
	}
	/* begin followForwarded: */
	assert(isUnambiguouslyForwarder(_obj));
	/* begin fetchPointer:ofMaybeForwardedObject: */
	_referent = unsignedLongAt((_obj + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofMaybeForwardedObject: */
	while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
	}
	return _referent;
	/* end followForwarded: */
}
/*	Check for stack overflow, moving frames to another stack if so. 
	This should *only* be sent from checkForStackOverflow. */
/* StackInterpreter>>#handleStackOverflow */
static void NeverInline
handleStackOverflow(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _callerContextOrNil;
	char *_callerFP;
	char *_callerFP2;
	sqInt _inInterpreter;
	sqInt _lookupClassTag;
	StackPage *_lruOrFree;
	sqInt _methodHeader;
	sqInt _nArgs;
	StackPage *_newPage;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _objOop3;
	sqInt _ourContext;
	sqInt _overflowCount;
	char *_overflowLimitAddress;
	char *_savedFramePointer;
	char *_savedStackPointer;
	sqInt _shouldOverflowIndex;
	sqInt _source;
	char *_sp;
	sqInt _succeeded;
	sqInt _tagBits;
	char *_theFP;
	StackPage *_thePage;

	_nArgs = 0;
	_savedFramePointer = ((char *) 0 );
	_savedStackPointer = ((char *) 0 );
	assert(GIV(stackPointer) < ((GIV(stackPage)->realStackLimit)));
	/* begin maybeTraceStackOverflow */
	if (recordOverflowTrace()) {
		/* begin recordTrace:thing:source: */
		_source = ((isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))
			 ? TraceIsFromMachineCode
			 : TraceIsFromInterpreter);
		GIV(traceLog)[GIV(traceLogIndex)] = TraceStackOverflow;
		GIV(traceLog)[GIV(traceLogIndex) + 1] = TraceStackOverflow;
		GIV(traceLog)[GIV(traceLogIndex) + 2] = _source;
		GIV(traceLogIndex) = (GIV(traceLogIndex) + 3) % TraceBufferSize;
		/* end recordTrace:thing:source: */
	}
	if (recordPrimTrace()) {
		/* begin fastLogPrim: */
		GIV(primTraceLog)[GIV(primTraceLogIndex)] = TraceStackOverflow;
		primTraceLogIndex(GIV(primTraceLogIndex) + 1);
		/* end fastLogPrim: */
	}
	/* end maybeTraceStackOverflow */
	GIV(statStackOverflow) += 1;
	_theFP = GIV(framePointer);
	if (GIV(stackPage) == GIV(overflowedPage)) {
		_overflowLimitAddress = ((GIV(stackPage)->baseAddress)) - GIV(overflowLimit);
		_overflowCount = (GIV(extraFramesToMoveOnOverflow) += 1);
		while ((((_overflowCount -= 1)) >= 0) && ((((_callerFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP)))) < _overflowLimitAddress) && (!((unsignedLongAt(_callerFP + FoxSavedFP)) == 0)))) {
			_theFP = _callerFP;
		}
	} else {
		GIV(overflowedPage) = GIV(stackPage);
		GIV(extraFramesToMoveOnOverflow) = 0;
	}
	/* begin ensureCallerContext: */
	_callerFP2 = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP));
	if (_callerFP2 == 0) {
		/* begin frameCallerContext: */
		assert(isBaseFrame(_theFP));
		/* begin stackPageFor: */
		/* begin stackPageAt: */
		_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
		/* end stackPageAt: */
		/* end stackPageFor: */
		_callerContextOrNil = unsignedLongAt((_thePage->baseAddress));
		assert(addressCouldBeObj(_callerContextOrNil));
		assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
		goto l10;
		/* end frameCallerContext: */
	}
	/* begin ensureFrameIsMarried:SP: */
	if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_callerFP2 + FoxMethod)) )))
		 ? ((unsignedLongAt(_callerFP2 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
		 : (byteAt((_callerFP2 + FoxIFrameFlags) + 2)) != 0)) {
		assert(isContext(frameContext(_callerFP2)));
		unsignedLongAt(_callerFP2 + FoxThisContext);
		goto l10;
	}
	marryFrameSP(_callerFP2, (assert(!(isBaseFrame(_theFP))), (_theFP + (frameStackedReceiverOffset(_theFP))) + BytesPerWord));
	/* end ensureFrameIsMarried:SP: */
	l10:
	;
	/* end ensureCallerContext: */
	/* begin newStackPage */
	_lruOrFree = (GIV(mostRecentlyUsedPage)->nextPage);
	if (((_lruOrFree->baseFP)) == 0) {
		_newPage = _lruOrFree;
		goto l4;
	}
	divorceFramesIn(_lruOrFree);
	_newPage = _lruOrFree;
	l4:
	;
	/* end newStackPage */
	moveFramesInthroughtoPage(GIV(stackPage), _theFP, _newPage);
	/* begin setStackPageAndLimit: */
	assert(_newPage != 0);
	GIV(stackPage) = _newPage;
	if (GIV(stackLimit) != ((char *) ((usqInt) -1 ) )) {
		GIV(stackLimit) = (GIV(stackPage)->stackLimit);
	}
	markStackPageMostRecentlyUsed(_newPage);
	/* end setStackPageAndLimit: */
	/* begin setStackPointersFromPage: */
	GIV(stackPointer) = (_newPage->headSP);
	GIV(framePointer) = (_newPage->headFP);
	/* end setStackPointersFromPage: */
	{
		assert(validInstructionPointerinFrame(GIV(instructionPointer) + 1, GIV(framePointer)));
		assert((!(frameHasContext(GIV(framePointer)))) || (isContext(frameContext(GIV(framePointer)))));
	}
	if ((numSlotsOf(memoryActiveProcess())) < ProcessShouldOverflowIndex) {
		return;
	}
	/* begin fetchPointer:ofObject: */
	/* begin memoryActiveProcess */
	/* begin fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	_objOop3 = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	_objOop = unsignedLongAt((_objOop3 + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end memoryActiveProcess */
	_shouldOverflowIndex = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ProcessShouldOverflowIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_shouldOverflowIndex != GIV(trueObj)) {
		return;
	}
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorStackOverflow ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	if (GIV(messageSelector) == GIV(nilObj)) {
		return;
	}
	/* begin ensureFrameIsMarried:SP: */
	if (((isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))
		 ? ((unsignedLongAt(GIV(framePointer) + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
		 : (byteAt((GIV(framePointer) + FoxIFrameFlags) + 2)) != 0)) {
		assert(isContext(frameContext(GIV(framePointer))));
		_ourContext = unsignedLongAt(GIV(framePointer) + FoxThisContext);
		goto l7;
	}
	_ourContext = marryFrameSP(GIV(framePointer), GIV(stackPointer));
	l7:
	;
	/* end ensureFrameIsMarried:SP: */
	/* begin push: */
	unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _ourContext);
	GIV(stackPointer) = _sp;
	/* end push: */
	GIV(argumentCount) = 0;
	_lookupClassTag = ((((_tagBits = _ourContext & (tagMask()))) != 0)
		 ? _tagBits
		 : (longAt(_ourContext)) & (classIndexMask()));
	findNewMethodInClassTag(_lookupClassTag);
	/* begin executeNewMethod */
	/* begin executeNewMethod: */
	_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	/* begin executePrimitiveFromInterpreter:ifFail: */
	if (primitiveFunctionPointer != 0) {
		if (((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex) {
			executeQuickPrimitive();
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), _inInterpreter);
			/* end returnToExecutive: */
			goto l15;
		}
		/* begin slowPrimitiveResponse */
		if (recordPrimTrace()) {
			/* begin fastLogPrim: */
			GIV(primTraceLog)[GIV(primTraceLogIndex)] = GIV(messageSelector);
			primTraceLogIndex(GIV(primTraceLogIndex) + 1);
			/* end fastLogPrim: */
		}
		assert((remapBufferCount()) == 0);
		{
			_nArgs = GIV(argumentCount);
			_savedStackPointer = GIV(stackPointer);
			_savedFramePointer = GIV(framePointer);
		}
		/* begin initPrimCall */
		GIV(primFailCode) = 0;
		/* end initPrimCall */
		/* begin dispatchFunctionPointer: */
		primitiveFunctionPointer();
		/* end dispatchFunctionPointer: */
		assert(maybeLeakCheckExternalPrimCall(GIV(newMethod)));
		/* begin maybeRetryPrimitiveOnFailure */
		if (GIV(primFailCode)) {
			retryPrimitiveOnFailure();
		}
		/* end maybeRetryPrimitiveOnFailure */
		/* begin maybeFailForLastObjectOverwrite */
		if (checkAllocFiller) {
			if (((freeStart0()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart0())) != (freeStart0()))) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrWritePastObject;
				/* end primitiveFailFor: */
			}
		}
		/* end maybeFailForLastObjectOverwrite */
		if (!GIV(primFailCode) && ((GIV(framePointer) == _savedFramePointer) && (!(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))))) {
			if (GIV(stackPointer) != (_savedStackPointer + (_nArgs * BytesPerWord))) {
				flag("Would be nice to make this a message send of e.g. unbalancedPrimitive to the current process or context");
				failUnbalancedPrimitive();
				GIV(stackPointer) = _savedStackPointer;
			}
		}
		if (GIV(nextProfileTick) > 0) {
			checkProfileTick(GIV(newMethod));
		}
		_succeeded = !GIV(primFailCode);
		goto l11;
		l11:
		;
		/* end slowPrimitiveResponse */
		if (_succeeded) {
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), _inInterpreter);
			/* end returnToExecutive: */
			goto l15;
		}
	}
	{
		{
			/* begin fetchPointer:ofObject: */
			_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (!((assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0))) {
				if (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
					cogselector(GIV(newMethod), GIV(nilObj));
					/* begin fetchPointer:ofObject: */
					_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
				} else {
					maybeFlagMethodAsInterpreted(GIV(newMethod));
				}
			}
		}
		activateNewMethod();
	}
	l15:
	;
	/* end executePrimitiveFromInterpreter:ifFail: */
	/* end executeNewMethod: */
	/* end executeNewMethod */
}
/*	The stackPointer is below the stackLimit. This is either because of a 
	stack overflow or the setting of stackLimit to indicate a possible 
	interrupt. Check for stackOverflow and interrupts anddeal with each 
	appropriately. Answer if a context switch occurred. */
/* StackInterpreter>>#handleStackOverflowOrEventAllowContextSwitch: */
static sqInt NoDbgRegParms
handleStackOverflowOrEventAllowContextSwitch(sqInt _mayContextSwitch)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	int _isInterrupt;
	char *_theSP;

	_isInterrupt = GIV(stackLimit) != ((GIV(stackPage)->realStackLimit));
	if (_isInterrupt) {
		/* begin restoreStackLimit */
		(GIV(stackPage)->stackLimit = (GIV(stackPage)->realStackLimit));
		GIV(stackLimit) = (GIV(stackPage)->stackLimit);
		/* end restoreStackLimit */
	}
	/* begin checkForStackOverflow */
	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	_theSP = GIV(stackPointer);
	assert(_theSP < GIV(framePointer));
	assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(GIV(stackPage)->headFP = GIV(framePointer));
		(GIV(stackPage)->headSP = _theSP);
	}
	/* end setHeadFP:andSP:inPage: */
	assert(pageListIsWellFormed());
	/* end writeBackHeadFramePointers */
	if (GIV(stackPointer) < ((GIV(stackPage)->realStackLimit))) {
		handleStackOverflow();
	}
	/* end checkForStackOverflow */
	if (!_isInterrupt) {
		return 0;
	}
	return checkForEventsMayContextSwitch(_mayContextSwitch);
}
/* StackInterpreter>>#hasCheckAllocFiller */
sqInt
hasCheckAllocFiller(void)
{
	return checkAllocFiller();
}
/* StackInterpreter>>#hasProfileSemaphore */
sqInt
hasProfileSemaphore(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(profileSemaphore) != GIV(nilObj);
}
/*	This is a C implementation needed by ioSetMaxExtSemTableSize 
	and e.g. stackPageByteSize. */
/* StackInterpreter>>#highBit: */
usqInt
highBit(usqInt _anUnsignedValue)
{
	int _bitNo;
	usqInt _shifted;

	_shifted = _anUnsignedValue;
	_bitNo = 0;
	
#  if BytesPerWord > 4
	{
		if (!(_shifted < (1ULL << 32))) {
			_shifted = ((usqInt) _shifted ) >> 32;
			_bitNo += 32;
		}
	}
#  endif /* BytesPerWord > 4 */
	if (!(_shifted < (1U << 16))) {
		_shifted = ((usqInt) _shifted ) >> 16;
		_bitNo += 16;
	}
	if (!(_shifted < (1U << 8))) {
		_shifted = ((usqInt) _shifted ) >> 8;
		_bitNo += 8;
	}
	if (!(_shifted < (1U << 4))) {
		_shifted = ((usqInt) _shifted ) >> 4;
		_bitNo += 4;
	}
	if (!(_shifted < (1U << 2))) {
		_shifted = ((usqInt) _shifted ) >> 2;
		_bitNo += 2;
	}
	if (!(_shifted < (1U << 1))) {
		_shifted = ((usqInt) _shifted ) >> 1;
		_bitNo += 1;
	}
	return _bitNo + _shifted;
}
/*	If thePage is the stackPage and the stackPointer and/or the framePointer 
	are pointing within it, 
	answer if thePage's heapSP and headFP are equal to the stackPointer and 
	framePointer respectively. */
/* StackInterpreter>>#ifCurrentStackPageHasValidHeadPointers: */
static sqInt NoDbgRegParms
ifCurrentStackPageHasValidHeadPointers(StackPage *_thePage)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (_thePage == GIV(stackPage)) {
		if ((((_thePage->lastAddress)) < GIV(framePointer)) && (GIV(framePointer) < ((_thePage->baseAddress)))) {
			if (((_thePage->headFP)) != GIV(framePointer)) {
				return 0;
			}
		}
		if ((((_thePage->lastAddress)) < GIV(stackPointer)) && (GIV(stackPointer) < ((_thePage->baseAddress)))) {
			if (((_thePage->headSP)) != GIV(stackPointer)) {
				return 0;
			}
		}
	}
	return 1;
}
/*	<Integer> */
/* StackInterpreter>>#iframeIsBlockActivation: */
static sqInt NoDbgRegParms
iframeIsBlockActivation(char *_theFP)
{
	return (byteAt((_theFP + FoxIFrameFlags) + 3)) != 0;
}
/* StackInterpreter>>#iframeMethod: */
static usqInt NoDbgRegParms
iframeMethod(char *_theFP)
{
	return unsignedLongAt(_theFP + FoxMethod);
}
/* StackInterpreter>>#iframeReceiver: */
static sqInt NoDbgRegParms
iframeReceiver(char *_theFP)
{
	return unsignedLongAt(_theFP + FoxIFReceiver);
}
/*	Return the equivalent of  
	aClass includesBehavior: aSuperclass. 
	Note: written for efficiency and better inlining (only 1 temp) */
/* StackInterpreter>>#includesBehavior:ThatOf: */
sqInt
includesBehaviorThatOf(sqInt _aClass, sqInt _aSuperclass)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _objOop;
	sqInt _theClass;

	if (_aSuperclass == GIV(nilObj)) {
		return 0;
	}
	_theClass = _aClass;
	while (1) {
		if (_theClass == _aSuperclass) {
			return 1;
		}
		if (!(_theClass != GIV(nilObj))) 
			break;
		/* begin followField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop = unsignedLongAt((_theClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_objOop = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _theClass, _objOop);
		}
		_theClass = _objOop;
		/* end followField:ofObject: */
	}
	return 0;
}
/*	This method implements a simple method lookup cache. If an entry for the 
	given selector and classTag is 
	found in the cache, set the values of 'newMethod' and 
	'primitiveFunctionPointer' and answer true. Otherwise, 
	answer false.About the re-probe scheme: The hash is the low bits of the XOR of two 
	large addresses, minus their useless 
	lowest two bits. If a probe doesn't get a hit, the hash is shifted right 
	one bit to compute the next probe, 
	introducing a new randomish bit. The cache is probed CacheProbeMax times 
	before giving up.WARNING: Since the hash computation is based on the object addresses of 
	the class and selector, we must 
	rehash or flush when compacting storage. We've chosen to flush, since that 
	also saves the trouble of updating 
	the addresses of the objects in the cache.classTag is either a class object, if using NewObjectMemory, or a 
	classIndex, if using SpurMemoryManager. */
/* StackInterpreter>>#inlineLookupInMethodCacheSel:classTag: */
static sqInt NoDbgRegParms
inlineLookupInMethodCacheSelclassTag(sqInt _selector, sqInt _classTag)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _hash;
	sqInt _probe;

	/* begin methodCacheHashOf:with: */
	_hash = _selector ^ ((sqInt) (((usqInt) _classTag ) << 2) );
	/* end methodCacheHashOf:with: */
	_probe = _hash & MethodCacheMask;
	if (((GIV(methodCache)[_probe + MethodCacheSelector]) == _selector) && ((GIV(methodCache)[_probe + MethodCacheClass]) == _classTag)) {
		GIV(newMethod) = GIV(methodCache)[_probe + MethodCacheMethod];
		primitiveFunctionPointer = ((void (*)()) (GIV(methodCache)[_probe + MethodCachePrimFunction]) );
		return 1;
	}
	_probe = (((usqInt) _hash ) >> 1) & MethodCacheMask;
	if (((GIV(methodCache)[_probe + MethodCacheSelector]) == _selector) && ((GIV(methodCache)[_probe + MethodCacheClass]) == _classTag)) {
		GIV(newMethod) = GIV(methodCache)[_probe + MethodCacheMethod];
		primitiveFunctionPointer = ((void (*)()) (GIV(methodCache)[_probe + MethodCachePrimFunction]) );
		return 1;
	}
	_probe = (((usqInt) _hash ) >> 2) & MethodCacheMask;
	if (((GIV(methodCache)[_probe + MethodCacheSelector]) == _selector) && ((GIV(methodCache)[_probe + MethodCacheClass]) == _classTag)) {
		GIV(newMethod) = GIV(methodCache)[_probe + MethodCacheMethod];
		primitiveFunctionPointer = ((void (*)()) (GIV(methodCache)[_probe + MethodCachePrimFunction]) );
		return 1;
	}
	return 0;
}
/*	the vm has to convert aFilenameString via any canonicalization and 
	char-mapping and put the result in aCharBuffer. 
	Note the resolveAliases flag - this is an awful artefact of OSX and Apples 
	demented alias handling. When opening a file, the flag must be true, when 
	closing or renaming it must be false. Sigh. */
/* StackInterpreter>>#ioFilename:fromString:ofLength:resolveAliases: */
void
ioFilenamefromStringofLengthresolveAliases(char *_aCharBuffer, char *_aFilenameString, sqInt _filenameLength, sqInt aBoolean)
{
	sqGetFilenameFromString(_aCharBuffer, _aFilenameString, _filenameLength, aBoolean);
}
/*	A base frame (first frame in a stack page) is so marked by having a null 
	saved fp. */
/* StackInterpreter>>#isBaseFrame: */
static sqInt NoDbgRegParms
isBaseFrame(char *_theFP)
{
	return (unsignedLongAt(_theFP + FoxSavedFP)) == 0;
}
/* StackInterpreter>>#isBooleanObject: */
sqInt
isBooleanObject(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return (_oop == GIV(trueObj)) || (_oop == GIV(falseObj));
}
/* StackInterpreter>>#isFloatObject: */
sqInt
isFloatObject(sqInt _oop)
{
	sqInt _tagBits;

	return ((((_tagBits = _oop & (tagMask()))) != 0)
		 ? _tagBits == (smallFloatTag())
		 : ((longAt(_oop)) & (classIndexMask())) == ClassFloatCompactIndex);
}
/* StackInterpreter>>#isFrame:onPage: */
static sqInt NoDbgRegParms
isFrameonPage(char *_aFrame, StackPage *_aPage)
{
	char *_prevFP;
	char *_theFP;

	assert(!(isFree(_aPage)));
	_theFP = (_aPage->headFP);
	_prevFP = _theFP - BytesPerWord;
	while (1) {
		if (_theFP == _aFrame) {
			return 1;
		}
		if (!((_theFP > _prevFP) && (_theFP < ((_aPage->baseFP))))) 
			break;
		_prevFP = _theFP;
		/* begin frameCallerFP: */
		_theFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP));
		/* end frameCallerFP: */
	}
	return 0;
}
/*	Answer true if the oop is kind of Integer (Small or Large). */
/* StackInterpreter>>#isKindOfInteger: */
sqInt
isKindOfInteger(sqInt _oop)
{
	return (((_oop & 7) == 1)) || (((_oop & (tagMask())) == 0) && (((usqInt) (((longAt(_oop)) & (classIndexMask())) - ClassLargeNegativeIntegerCompactIndex) ) <= 1));
}
/* StackInterpreter>>#isLargeIntegerObject: */
sqInt
isLargeIntegerObject(sqInt _oop)
{
	/* begin isLargeIntegerInstance: */
	return ((_oop & (tagMask())) == 0) && (((usqInt) (((longAt(_oop)) & (classIndexMask())) - ClassLargeNegativeIntegerCompactIndex) ) <= 1);
	/* end isLargeIntegerInstance: */
}
/* StackInterpreter>>#isLargeNegativeIntegerObject: */
sqInt
isLargeNegativeIntegerObject(sqInt _oop)
{
	/* begin isInstanceOfClassLargeNegativeInteger: */
	return ((_oop & (tagMask())) == 0) && (((longAt(_oop)) & (classIndexMask())) == ClassLargeNegativeIntegerCompactIndex);
	/* end isInstanceOfClassLargeNegativeInteger: */
}
/* StackInterpreter>>#isLargePositiveIntegerObject: */
sqInt
isLargePositiveIntegerObject(sqInt _oop)
{
	/* begin isInstanceOfClassLargePositiveInteger: */
	return ((_oop & (tagMask())) == 0) && (((longAt(_oop)) & (classIndexMask())) == ClassLargePositiveIntegerCompactIndex);
	/* end isInstanceOfClassLargePositiveInteger: */
}
/*	Answer if the argument, which can be any object, is a live context. */
/* StackInterpreter>>#isLiveContext: */
static sqInt NoDbgRegParms
isLiveContext(sqInt _oop)
{
	assert(!(isOopForwarded(_oop)));
	if (!(((_oop & (tagMask())) == 0) && (((longAt(_oop)) & (classIndexMask())) == ClassMethodContextCompactIndex))) {
		return 0;
	}
	if (isNonImmediate(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) )))) {
		return (((unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ))) & 7) == 1);
	}
	return !(isWidowedContext(_oop));
}
/* StackInterpreter>>#isMarriedOrWidowedContext: */
static sqInt NoDbgRegParms
isMarriedOrWidowedContext(sqInt _aContext)
{
	return (((unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1);
}
/*	This virtual machine provides two primitives that executes arbitrary 
	primitives, one 
	for indexed primitivces and one for named primitives. These meta 
	primitives are used 
	in the debugger to execute primitives while simulating execution. Spur 
	needs to know 
	the accessor depth for a primitive so that failures due to forwarders can 
	be fixed up 
	and retried. This method identifies such meta primitives so that 
	metaAccessorDepth can be substituted when appropriate. */
/* StackInterpreter>>#isMetaPrimitiveIndex: */
static sqInt NoDbgRegParms
isMetaPrimitiveIndex(sqInt _primIndex)
{
	return (_primIndex == PrimNumberDoPrimitive) || (_primIndex == PrimNumberDoExternalCall);
}
/*	We save slots in the method cache by using the primitiveFunctionPointer 
	to hold either a function pointer or the index of a quick primitive. Since 
	quick primitive indices are small they can't be confused with function 
	addresses. */
/* StackInterpreter>>#isPrimitiveFunctionPointerAnIndex */
static sqInt
isPrimitiveFunctionPointerAnIndex(void)
{
	return ((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex;
}
/* StackInterpreter>>#isQuickPrimitiveIndex: */
sqInt
isQuickPrimitiveIndex(sqInt _anInteger)
{
	return (_anInteger >= 256) && (_anInteger <= 519);
}
/*	Reading the sender, instructionPointer and stackPointer inst vars of a 
	context must take 
	account of potentially married contexts and fetch the state from the 
	frame. method, 
	closureOrNil and receiver can safely be fetched from the context without 
	checking.  */
/* StackInterpreter>>#isReadMediatedContextInstVarIndex: */
sqInt
isReadMediatedContextInstVarIndex(sqInt _index)
{
	return _index <= StackPointerIndex;
}
/* StackInterpreter>>#isSingleContext: */
static sqInt NoDbgRegParms
isSingleContext(sqInt _aContext)
{
	sqInt _oop;

	/* begin isNonImmediate: */
	_oop = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
	return (_oop & (tagMask())) == 0;
	/* end isNonImmediate: */
}
/*	See if the argument is married to a live frame or not. i.e. see if there 
	is a matching 
	frame whose frameContext field is aOnceMarriedContext, or a forwarder to 
	it. If aOnceMarriedContext is not married to a live frame, turn it into a 
	bereaved single context. 
	This version is for use during scavenging when stack references may be 
	forwarded. Following what appear to be references to forwarded objects on 
	the stack is dangerous; 
	an instruction ponter may be correctly aligned and may point to bytes that 
	just happen 
	to look like a forwarder. So it is only safe to follow fields that we know 
	are frameContext 
	fields; hence the stack page is walked to check that aOnceMarriedContext 
	is pointing to 
	a live frame. This only has to happen during scavenging because after a 
	become: all 
	frameContext fields have been followed and so there is no need to follow 
	forwarders.  */
/* StackInterpreter>>#isWidowedContextDuringGC: */
static sqInt NoDbgRegParms
isWidowedContextDuringGC(sqInt _aOnceMarriedContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _anInteger;
	char *_maybeFrame;
	sqInt _maybeFrameCtxt;
	sqInt _referent;
	sqInt _senderOop;
	char *_shouldBeFrameCallerField;
	StackPage *_thePage;
	sqInt _valuePointer;
	sqInt _valuePointer2;

	assert((isContext(_aOnceMarriedContext)) && (isMarriedOrWidowedContext(_aOnceMarriedContext)));
	/* begin frameOfMarriedContext: */
	/* begin fetchPointer:ofObject: */
	_senderOop = unsignedLongAt((_aOnceMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	{
		assert(((_senderOop & 7) == 1));
		_maybeFrame = pointerForOop(_senderOop - 1);
	}
	/* end frameOfMarriedContext: */
	/* begin stackPageFor: */
	/* begin stackPageAt: */
	_thePage = stackPageAtpages((assert((((char *) _maybeFrame ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _maybeFrame ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_maybeFrame, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
	/* end stackPageAt: */
	/* end stackPageFor: */
	if (!((((_thePage->baseFP)) == 0) || (_maybeFrame < ((_thePage->headFP))))) {
		/* begin withoutSmallIntegerTags: */
		_anInteger = unsignedLongAt((_aOnceMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ));
		assert(((_anInteger & 7) == 1));
		_shouldBeFrameCallerField = pointerForOop(_anInteger - 1);
		/* end withoutSmallIntegerTags: */
		if (((pointerForOop(unsignedLongAt(_maybeFrame + FoxSavedFP))) == _shouldBeFrameCallerField) && (((isMachineCodeIP(((usqInt) (unsignedLongAt(_maybeFrame + FoxMethod)) )))
			 ? ((unsignedLongAt(_maybeFrame + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
			 : (byteAt((_maybeFrame + FoxIFrameFlags) + 2)) != 0))) {
			/* begin frameContext: */
			_maybeFrameCtxt = unsignedLongAt(_maybeFrame + FoxThisContext);
			/* end frameContext: */
			if ((isFrameonPage(_maybeFrame, _thePage)) && (((long64At(_maybeFrameCtxt)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin followForwarded: */
				assert(isUnambiguouslyForwarder(_maybeFrameCtxt));
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent = unsignedLongAt((_maybeFrameCtxt + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
				while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
				}
				_maybeFrameCtxt = _referent;
				/* end followForwarded: */
				/* begin setFrameContext:to: */
				unsignedLongAtput(_maybeFrame + FoxThisContext, _maybeFrameCtxt);
				/* end setFrameContext:to: */
			}
			if (_maybeFrameCtxt == _aOnceMarriedContext) {
				return 0;
			}
		}
	}
	/* begin markContextAsDead: */
	assert(isContext(_aOnceMarriedContext));
	{
		/* begin storePointerUnchecked:ofObject:withValue: */
		_valuePointer = GIV(nilObj);
		assert(!(isOopForwarded(_aOnceMarriedContext)));
		longAtput((_aOnceMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), _valuePointer);
		/* end storePointerUnchecked:ofObject:withValue: */
		/* begin storePointerUnchecked:ofObject:withValue: */
		_valuePointer2 = GIV(nilObj);
		assert(!(isOopForwarded(_aOnceMarriedContext)));
		longAtput((_aOnceMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), _valuePointer2);
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	/* end markContextAsDead: */
	return 1;
}
/*	See if the argument is married to a live frame or not. 
	If it is not, turn it into a bereaved single context. This version is safe 
	for use 
	only when no frameContext fields may be forwarded (as maybe the case 
	when scavenging). Post become: all frameContext fields are followed, and 
	hence nrmally no following of frameCOtext fields is necessary. But during 
	a scavenge one must use isWidowedContextDuringGC:. */
/* StackInterpreter>>#isWidowedContext: */
static sqInt NoDbgRegParms
isWidowedContext(sqInt _aOnceMarriedContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _anInteger;
	sqInt _senderOop;
	char *_shouldBeFrameCallerField;
	char *_theFrame;
	StackPage *_thePage;
	sqInt _valuePointer;
	sqInt _valuePointer2;

	assert((isContext(_aOnceMarriedContext)) && (isMarriedOrWidowedContext(_aOnceMarriedContext)));
	/* begin frameOfMarriedContext: */
	/* begin fetchPointer:ofObject: */
	_senderOop = unsignedLongAt((_aOnceMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	{
		assert(((_senderOop & 7) == 1));
		_theFrame = pointerForOop(_senderOop - 1);
	}
	/* end frameOfMarriedContext: */
	/* begin stackPageFor: */
	/* begin stackPageAt: */
	_thePage = stackPageAtpages((assert((((char *) _theFrame ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFrame ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFrame, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
	/* end stackPageAt: */
	/* end stackPageFor: */
	if (!((((_thePage->baseFP)) == 0) || (_theFrame < ((_thePage->headFP))))) {
		/* begin withoutSmallIntegerTags: */
		_anInteger = unsignedLongAt((_aOnceMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ));
		assert(((_anInteger & 7) == 1));
		_shouldBeFrameCallerField = pointerForOop(_anInteger - 1);
		/* end withoutSmallIntegerTags: */
		if (((pointerForOop(unsignedLongAt(_theFrame + FoxSavedFP))) == _shouldBeFrameCallerField) && (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFrame + FoxMethod)) )))
			 ? ((unsignedLongAt(_theFrame + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
			 : (byteAt((_theFrame + FoxIFrameFlags) + 2)) != 0))) {
			assert(!((isFrameonPage(_theFrame, _thePage)) && (isForwarded(frameContext(_theFrame)))));
			if ((unsignedLongAt(_theFrame + FoxThisContext)) == _aOnceMarriedContext) {
				return 0;
			}
		}
	}
	/* begin markContextAsDead: */
	assert(isContext(_aOnceMarriedContext));
	{
		/* begin storePointerUnchecked:ofObject:withValue: */
		_valuePointer = GIV(nilObj);
		assert(!(isOopForwarded(_aOnceMarriedContext)));
		longAtput((_aOnceMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), _valuePointer);
		/* end storePointerUnchecked:ofObject:withValue: */
		/* begin storePointerUnchecked:ofObject:withValue: */
		_valuePointer2 = GIV(nilObj);
		assert(!(isOopForwarded(_aOnceMarriedContext)));
		longAtput((_aOnceMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), _valuePointer2);
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	/* end markContextAsDead: */
	return 1;
}
/*	Wrining any inst vars of a context must take account of potentially 
	married contexts 
	and set the state in the frame. Inst vars in subclasses don't need 
	mediation; subclasses 
	can't marry. */
/* StackInterpreter>>#isWriteMediatedContextInstVarIndex: */
sqInt
isWriteMediatedContextInstVarIndex(sqInt _index)
{
	return _index <= ReceiverIndex;
}
/*	Support for external primitives. */
/* StackInterpreter>>#is:KindOfClass: */
sqInt
isKindOfClass(sqInt _oop, sqInt _aClass)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _objOop;
	sqInt _oopClass;
	sqInt _tagBits;

	/* begin fetchClassOf: */
	_oopClass = ((((_tagBits = _oop & (tagMask()))) != 0)
		 ? unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) ))
		 : fetchClassOfNonImm(_oop));
	/* end fetchClassOf: */
	while (!(_oopClass == GIV(nilObj))) {
		if (_oopClass == _aClass) {
			return 1;
		}
		/* begin followField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop = unsignedLongAt((_oopClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_objOop = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _oopClass, _objOop);
		}
		_oopClass = _objOop;
		/* end followField:ofObject: */
	}
	return 0;
}
/*	Support for external primitives. */
/* StackInterpreter>>#is:KindOf: */
sqInt
isKindOf(sqInt _oop, char *_className)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _objOop;
	sqInt _oopClass;
	sqInt _tagBits;

	/* begin fetchClassOf: */
	_oopClass = ((((_tagBits = _oop & (tagMask()))) != 0)
		 ? unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) ))
		 : fetchClassOfNonImm(_oop));
	/* end fetchClassOf: */
	while (!(_oopClass == GIV(nilObj))) {
		if (classNameOfIs(_oopClass, _className)) {
			return 1;
		}
		/* begin followField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop = unsignedLongAt((_oopClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_objOop = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _oopClass, _objOop);
		}
		_oopClass = _objOop;
		/* end followField:ofObject: */
	}
	return 0;
}
/*	Support for external primitives */
/* StackInterpreter>>#is:MemberOf: */
sqInt
isMemberOf(sqInt _oop, char *_className)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _oopClass;
	sqInt _tagBits;

	/* begin fetchClassOf: */
	_oopClass = ((((_tagBits = _oop & (tagMask()))) != 0)
		 ? unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) ))
		 : fetchClassOfNonImm(_oop));
	/* end fetchClassOf: */
	return classNameOfIs(_oopClass, _className);
}
/* StackInterpreter>>#lengthOfNameOfClass: */
static sqInt NoDbgRegParms
lengthOfNameOfClass(sqInt _classOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _fmt;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots22;
	usqInt _numSlots3;
	sqInt _objOop;

	/* begin numSlotsOf: */
	assert((classIndexOf(_classOop)) > (isForwardedObjectClassIndexPun()));
	_numSlots2 = byteAt(_classOop + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_classOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOf: */
	if (_numSlots == GIV(metaclassNumSlots)) {
		return lengthOfNameOfClass(unsignedLongAt((_classOop + BaseHeaderSize) + ((sqInt) (((usqInt) GIV(thisClassIndex) ) << (shiftForWord())) )));
	}
	if (_numSlots <= GIV(classNameIndex)) {
		return 0;
	}
	/* begin lengthOf: */
	_objOop = unsignedLongAt((_classOop + BaseHeaderSize) + ((sqInt) (((usqInt) GIV(classNameIndex) ) << (shiftForWord())) ));
	/* begin lengthOf:format: */
	_fmt = (((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOfAny: */
	_numSlots22 = byteAt(_objOop + 7);
	_numSlots3 = ((_numSlots22 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_objOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots22);
	/* end numSlotsOfAny: */
	if (_fmt <= 5) {
		return _numSlots3;
	}
	if (_fmt >= (firstByteFormat())) {
		return (_numSlots3 << (shiftForWord())) - (_fmt & 7);
	}
	if (_fmt >= (firstShortFormat())) {
		return (_numSlots3 << ((shiftForWord()) - 1)) - (_fmt & 3);
	}
	if (_fmt >= (firstLongFormat())) {
		return (_numSlots3 << ((shiftForWord()) - 2)) - (_fmt & 1);
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		return _numSlots3;
	}
	return 0;
	/* end lengthOf:format: */
	/* end lengthOf: */
}
/* StackInterpreter>>#literal:ofMethod: */
sqInt
literalofMethod(sqInt _offset, sqInt _methodPointer)
{
	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((_methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset + LiteralStart) ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/*	This entry point needs to be implemented for the interpreter proxy. 
	Since BitBlt is now a plugin we need to look up 
	BitBltPlugin:=loadBitBltFrom and call it. This entire mechanism should 
	eventually go away and be 
	replaced with a dynamic lookup from BitBltPlugin itself but for backward 
	compatibility this stub is provided */
/* StackInterpreter>>#loadBitBltFrom: */
sqInt
loadBitBltFrom(sqInt bb)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	void *_fn;

	_fn = ioLoadFunctionFrom("loadBitBltFrom", "BitBltPlugin");
	if (_fn == 0) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	return ((sqInt (*)(sqInt))_fn)(bb);
}
/* StackInterpreter>>#loadInitialContext */
void
loadInitialContext(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeContext;
	sqInt _activeProc;
	sqInt _objOop;
	sqInt _objOop2;

	runLeakCheckerFor(GCModeFull);
	/* begin memoryActiveProcess */
	/* begin fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	_activeProc = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end memoryActiveProcess */
	/* begin fetchPointer:ofObject: */
	_activeContext = unsignedLongAt((_activeProc + BaseHeaderSize) + ((sqInt) (((usqInt) SuspendedContextIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	marryContextInNewStackPageAndInitializeInterpreterRegisters(_activeContext);
}
/* StackInterpreter>>#longPrintOop: */
void
longPrintOop(sqInt _oop)
{
	sqInt _byte;
	int _bytecodesPerLine;
	sqInt _class;
	CogMethod *_cogMethod;
	int _column;
	unsigned short _field16;
	unsigned int _field32;
	usqLong _field64;
	sqInt _fieldOop;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _fmt3;
	sqInt _i;
	sqInt _iLimit;
	sqInt _index;
	sqInt _lastIndex;
	sqInt _len;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots22;
	usqInt _numSlots3;
	sqInt _startIP;

	if ((_oop & (tagMask())) || ((!(addressCouldBeObj(_oop))) || (((_oop & (8 - 1)) != 0) || ((((longAt(_oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) || (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))))) {
		printOop(_oop);
		return;
	}
	printHex(_oop);
	{
		_class = fetchClassOfNonImm(_oop);
		if (_class == null) {
			print(" has a nil class!!");
		} else {
			{
				print(": a(n) ");
				printNameOfClasscount(_class, 5);
				print(" (");
			}
			{
				printHexnp(compactClassIndexOf(_oop));
				print("=>");
			}
			{
				printHexnp(_class);
				print(")");
			}
		}
	}
	_fmt = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
	{
		print(" format ");
		printHexnp(_fmt);
	}
	if (_fmt > 5) {
		{
			print(" nbytes ");
			printNum(numBytesOf(_oop));
		}
	} else {
		if ((_fmt >= 2) && ((_fmt <= (weakArrayFormat())) || (_fmt >= (sixtyFourBitIndexableFormat())))) {
			/* begin lengthOf:format: */
			_fmt2 = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
			/* begin numSlotsOfAny: */
			_numSlots2 = byteAt(_oop + 7);
			_numSlots = ((_numSlots2 == (numSlotsMask()))
				 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_oop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
				 : _numSlots2);
			/* end numSlotsOfAny: */
			if (_fmt2 <= 5) {
				_len = _numSlots;
				goto l8;
			}
			if (_fmt2 >= (firstByteFormat())) {
				_len = (_numSlots << (shiftForWord())) - (_fmt2 & 7);
				goto l8;
			}
			if (_fmt2 >= (firstShortFormat())) {
				_len = (_numSlots << ((shiftForWord()) - 1)) - (_fmt2 & 3);
				goto l8;
			}
			if (_fmt2 >= (firstLongFormat())) {
				_len = (_numSlots << ((shiftForWord()) - 2)) - (_fmt2 & 1);
				goto l8;
			}
			if (_fmt2 == (sixtyFourBitIndexableFormat())) {
				_len = _numSlots;
				goto l8;
			}
			_len = 0;
			l8:
			;
			/* end lengthOf:format: */
			{
				print(" size ");
				printNum(_len - (fixedFieldsOfformatlength(_oop, _fmt, _len)));
			}
		}
	}
	printHeaderTypeOf(_oop);
	{
		print(" hash ");
		printHexnp((uint32AtPointer(_oop + 4)) & (identityHashHalfWordMask()));
	}
	/* begin cr */
	print("\n");
	/* end cr */
	if ((_fmt >= (firstByteFormat())) && (_fmt <= ((firstCompiledMethodFormat()) - 1))) {
		{
			printStringOf(_oop);
			/* begin cr */
			print("\n");
			/* end cr */
		}
		return;
	}
	if ((_fmt >= (firstLongFormat())) && (_fmt <= ((firstByteFormat()) - 1))) {
		for (_i = 0, _iLimit = ((((((usqInt) (numBytesOf(_oop)) ) >> 2) < 256) ? ((usqInt) (numBytesOf(_oop)) ) >> 2 : 256)) - 1; _i <= _iLimit; _i += 1) {
			/* begin fetchLong32:ofObject: */
			_field32 = ((sqInt) (long32At((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << 2) ))) );
			/* end fetchLong32:ofObject: */
			{
				/* begin space */
				printChar(' ');
				/* end space */
				printNum(_i);
				/* begin space */
				printChar(' ');
				/* end space */
				printHex(_field32);
				/* begin space */
				printChar(' ');
				/* end space */
				/* begin cr */
				print("\n");
				/* end cr */
			}
		}
		return;
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		for (_i = 0, _iLimit = ((((((usqInt) (numBytesOf(_oop)) ) >> 3) < 256) ? ((usqInt) (numBytesOf(_oop)) ) >> 3 : 256)) - 1; _i <= _iLimit; _i += 1) {
			/* begin fetchLong64:ofObject: */
			_field64 = long64At((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << 3) ));
			/* end fetchLong64:ofObject: */
			{
				/* begin space */
				printChar(' ');
				/* end space */
				printNum(_i);
				/* begin space */
				printChar(' ');
				/* end space */
				printHex(_field64);
				/* begin space */
				printChar(' ');
				/* end space */
				/* begin cr */
				print("\n");
				/* end cr */
			}
		}
		return;
	}
	if ((_fmt >= (firstShortFormat())) && (_fmt <= ((firstShortFormat()) + 1))) {
		for (_i = 0, _iLimit = ((((((usqInt) (numBytesOf(_oop)) ) >> 1) < 256) ? ((usqInt) (numBytesOf(_oop)) ) >> 1 : 256)) - 1; _i <= _iLimit; _i += 1) {
			/* begin fetchShort16:ofObject: */
			_field16 = shortAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << 1) ));
			/* end fetchShort16:ofObject: */
			{
				/* begin space */
				printChar(' ');
				/* end space */
				printNum(_i);
				/* begin space */
				printChar(' ');
				/* end space */
				printHex(_field16);
				/* begin space */
				printChar(' ');
				/* end space */
				/* begin cr */
				print("\n");
				/* end cr */
			}
		}
		return;
	}
	_startIP = (((lastPointerOf(_oop)) + BytesPerOop) - BaseHeaderSize) / BytesPerOop;
	_lastIndex = ((256 < _startIP) ? 256 : _startIP);
	if (_lastIndex > 0) {
		for (_i = 1; _i <= _lastIndex; _i += 1) {
			/* begin fetchPointer:ofObject: */
			_fieldOop = unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) (_i - 1) ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			{
				/* begin space */
				printChar(' ');
				/* end space */
				printNum(_i - 1);
				/* begin space */
				printChar(' ');
				/* end space */
				printHex(_fieldOop);
				/* begin space */
				printChar(' ');
				/* end space */
			}
			if ((_i == 1) && (((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()))) {
				/* begin printMethodHeaderOop: */
				if ((assert((((_fieldOop & 7) == 1)) || ((((usqInt) _fieldOop ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _fieldOop ) >= (minCogMethodAddress())))), (_fieldOop & (smallIntegerTag())) == 0)) {
					_cogMethod = methodFor(pointerForOop(_fieldOop));
					if (_cogMethod != 0) {
						{
							printHex(_fieldOop);
							/* begin space */
							printChar(' ');
							/* end space */
							printDecodeMethodHeaderOop((_cogMethod->methodHeader));
						}
						goto l20;
					}
				}
				printDecodeMethodHeaderOop(_fieldOop);
				goto l20;
				l20:
				;
				/* end printMethodHeaderOop: */
			} else {
				printOopShort(_fieldOop);
			}
			/* begin cr */
			print("\n");
			/* end cr */
		}
	}
	if (((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
		_startIP = (_startIP * BytesPerWord) + 1;
		/* begin lengthOf:format: */
		_fmt3 = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
		/* begin numSlotsOfAny: */
		_numSlots22 = byteAt(_oop + 7);
		_numSlots3 = ((_numSlots22 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_oop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots22);
		/* end numSlotsOfAny: */
		if (_fmt3 <= 5) {
			_lastIndex = _numSlots3;
			goto l18;
		}
		if (_fmt3 >= (firstByteFormat())) {
			_lastIndex = (_numSlots3 << (shiftForWord())) - (_fmt3 & 7);
			goto l18;
		}
		if (_fmt3 >= (firstShortFormat())) {
			_lastIndex = (_numSlots3 << ((shiftForWord()) - 1)) - (_fmt3 & 3);
			goto l18;
		}
		if (_fmt3 >= (firstLongFormat())) {
			_lastIndex = (_numSlots3 << ((shiftForWord()) - 2)) - (_fmt3 & 1);
			goto l18;
		}
		if (_fmt3 == (sixtyFourBitIndexableFormat())) {
			_lastIndex = _numSlots3;
			goto l18;
		}
		_lastIndex = 0;
		l18:
		;
		/* end lengthOf:format: */
		if ((_lastIndex - _startIP) > 100) {
			_lastIndex = _startIP + 100;
		}
		_bytecodesPerLine = 8;
		_column = 1;
		for (_index = _startIP; _index <= _lastIndex; _index += 1) {
			if (_column == 1) {
				vm_printf("0x%08" PRIxSQPTR ": ", (usqIntptr_t)(_oop+BaseHeaderSize+_index-1));
			}
			/* begin fetchByte:ofObject: */
			_byte = byteAt((_oop + BaseHeaderSize) + (_index - 1));
			/* end fetchByte:ofObject: */
			vm_printf(" %02x/%-3d", (int)_byte,(int)_byte);
			_column += 1;
			if (_column > _bytecodesPerLine) {
				_column = 1;
				/* begin cr */
				print("\n");
				/* end cr */
			}
		}
		if (!(_column == 1)) {
			/* begin cr */
			print("\n");
			/* end cr */
		}
	} else {
		if (_startIP > _lastIndex) {
			{
				print("...");
				/* begin cr */
				print("\n");
				/* end cr */
			}
		}
	}
}
/*	Answer the relevant long store temp bytecode, which indicates it has a 
	primitive error code. 
	234		11101010	i i i i i i i i	Store Temporary Variable #iiiiiiii 
	129 10000001 jjkkkkkk Store (Receiver Variable, Temporary Location, 
	Illegal, Literal Variable) [jj] #kkkkkk */
/* StackInterpreter>>#longStoreBytecodeForHeader: */
sqInt
longStoreBytecodeForHeader(sqInt methodHeader)
{
	return LongStoreBytecode;
}
/*	This method implements a simple method lookup cache. If an entry for the 
	given selector and classTag is found in the cache, set the values of 
	'newMethod' and 
	'primitiveFunctionPointer' and answer true. Otherwise, answer false. */
/* StackInterpreter>>#lookupInMethodCacheSel:classTag: */
static sqInt NoDbgRegParms
lookupInMethodCacheSelclassTag(sqInt _selector, sqInt _classTag)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _hash;
	sqInt _probe;

	/* begin inlineLookupInMethodCacheSel:classTag: */
	/* begin methodCacheHashOf:with: */
	_hash = _selector ^ ((sqInt) (((usqInt) _classTag ) << 2) );
	/* end methodCacheHashOf:with: */
	_probe = _hash & MethodCacheMask;
	if (((GIV(methodCache)[_probe + MethodCacheSelector]) == _selector) && ((GIV(methodCache)[_probe + MethodCacheClass]) == _classTag)) {
		GIV(newMethod) = GIV(methodCache)[_probe + MethodCacheMethod];
		primitiveFunctionPointer = ((void (*)()) (GIV(methodCache)[_probe + MethodCachePrimFunction]) );
		return 1;
	}
	_probe = (((usqInt) _hash ) >> 1) & MethodCacheMask;
	if (((GIV(methodCache)[_probe + MethodCacheSelector]) == _selector) && ((GIV(methodCache)[_probe + MethodCacheClass]) == _classTag)) {
		GIV(newMethod) = GIV(methodCache)[_probe + MethodCacheMethod];
		primitiveFunctionPointer = ((void (*)()) (GIV(methodCache)[_probe + MethodCachePrimFunction]) );
		return 1;
	}
	_probe = (((usqInt) _hash ) >> 2) & MethodCacheMask;
	if (((GIV(methodCache)[_probe + MethodCacheSelector]) == _selector) && ((GIV(methodCache)[_probe + MethodCacheClass]) == _classTag)) {
		GIV(newMethod) = GIV(methodCache)[_probe + MethodCacheMethod];
		primitiveFunctionPointer = ((void (*)()) (GIV(methodCache)[_probe + MethodCachePrimFunction]) );
		return 1;
	}
	return 0;
	/* end inlineLookupInMethodCacheSel:classTag: */
}
/* StackInterpreter>>#lookupMethodInClass: */
static sqInt NoDbgRegParms
lookupMethodInClass(sqInt _class)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _currentClass;
	sqInt _dictionary;
	sqInt _found;
	int _index;
	usqInt _length;
	sqInt _mask;
	sqInt _methodArray;
	sqInt _nextSelector;
	usqInt _numSlots;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _objOop3;
	sqInt _objOop32;
	sqInt _objOop4;
	sqInt _objOop5;
	sqInt _objOop6;
	sqInt _objOop7;
	sqInt _selector;
	sqInt _superClass;
	int _wrapAround;

	assert(addressCouldBeClassObj(_class));
	_currentClass = _class;
	while (_currentClass != GIV(nilObj)) {
		/* begin followObjField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop2 = unsignedLongAt((_currentClass + BaseHeaderSize) + ((sqInt) (((usqInt) MethodDictionaryIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert(isNonImmediate(_objOop2));
		if (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
			_objOop2 = fixFollowedFieldofObjectwithInitialValue(MethodDictionaryIndex, _currentClass, _objOop2);
		}
		_dictionary = _objOop2;
		/* end followObjField:ofObject: */
		if (_dictionary == GIV(nilObj)) {
			createActualMessageTo(_class);
			/* begin splObj: */
			/* begin fetchPointer:ofObject: */
			GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorCannotInterpret ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			/* end splObj: */
			/* begin sendBreakpoint:receiver: */
			_selector = GIV(messageSelector);
			sendBreakpointreceiver(firstFixedFieldOfMaybeImmediate(_selector), lengthOfMaybeImmediate(_selector), null);
			/* end sendBreakpoint:receiver: */
			/* begin followField:ofObject: */
			/* begin fetchPointer:ofObject: */
			_objOop = unsignedLongAt((_currentClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				_objOop = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _currentClass, _objOop);
			}
			_superClass = _objOop;
			/* end followField:ofObject: */
			if (_superClass == GIV(nilObj)) {
				error("cannotInterpret: cannot be send without a superclass");
			}
			return lookupMethodInClass(_superClass);
		}
		/* begin lookupMethodInDictionary: */
		/* begin numSlotsOf: */
		assert((classIndexOf(_dictionary)) > (isForwardedObjectClassIndexPun()));
		_numSlots = byteAt(_dictionary + 7);
		_length = ((_numSlots == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_dictionary - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots);
		/* end numSlotsOf: */
		_mask = (_length - SelectorStart) - 1;
		if (_mask <= GIV(methodDictLinearSearchLimit)) {
			_index = 0;
			while (_index <= _mask) {
				/* begin followField:ofObject: */
				/* begin fetchPointer:ofObject: */
				_objOop32 = unsignedLongAt((_dictionary + BaseHeaderSize) + ((sqInt) (((usqInt) (_index + SelectorStart) ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_objOop32 & (tagMask())) == 0) && (((long64At(_objOop32)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					_objOop32 = fixFollowedFieldofObjectwithInitialValue(_index + SelectorStart, _dictionary, _objOop32);
				}
				_nextSelector = _objOop32;
				/* end followField:ofObject: */
				if (_nextSelector == GIV(messageSelector)) {
					/* begin followObjField:ofObject: */
					/* begin fetchPointer:ofObject: */
					_objOop7 = unsignedLongAt((_dictionary + BaseHeaderSize) + ((sqInt) (((usqInt) MethodArrayIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					assert(isNonImmediate(_objOop7));
					if (((long64At(_objOop7)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
						_objOop7 = fixFollowedFieldofObjectwithInitialValue(MethodArrayIndex, _dictionary, _objOop7);
					}
					_methodArray = _objOop7;
					/* end followObjField:ofObject: */
					/* begin followField:ofObject: */
					/* begin fetchPointer:ofObject: */
					_objOop22 = unsignedLongAt((_methodArray + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (((_objOop22 & (tagMask())) == 0) && (((long64At(_objOop22)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						_objOop22 = fixFollowedFieldofObjectwithInitialValue(_index, _methodArray, _objOop22);
					}
					GIV(newMethod) = _objOop22;
					/* end followField:ofObject: */
					_found = 1;
					goto l23;
				}
				_index += 1;
			}
			_found = 0;
			goto l23;
		}
		_index = SelectorStart + (_mask & (((GIV(messageSelector) & (tagMask()))
			 ? GIV(messageSelector) >> 3
			 : (uint32AtPointer(GIV(messageSelector) + 4)) & (identityHashHalfWordMask()))));
		_wrapAround = 0;
		while (1) {
			/* begin followField:ofObject: */
			/* begin fetchPointer:ofObject: */
			_objOop6 = unsignedLongAt((_dictionary + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_objOop6 & (tagMask())) == 0) && (((long64At(_objOop6)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				_objOop6 = fixFollowedFieldofObjectwithInitialValue(_index, _dictionary, _objOop6);
			}
			_nextSelector = _objOop6;
			/* end followField:ofObject: */
			if (_nextSelector == GIV(nilObj)) {
				_found = 0;
				goto l23;
			}
			if (_nextSelector == GIV(messageSelector)) {
				/* begin followObjField:ofObject: */
				/* begin fetchPointer:ofObject: */
				_objOop4 = unsignedLongAt((_dictionary + BaseHeaderSize) + ((sqInt) (((usqInt) MethodArrayIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				assert(isNonImmediate(_objOop4));
				if (((long64At(_objOop4)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					_objOop4 = fixFollowedFieldofObjectwithInitialValue(MethodArrayIndex, _dictionary, _objOop4);
				}
				_methodArray = _objOop4;
				/* end followObjField:ofObject: */
				/* begin followField:ofObject: */
				/* begin fetchPointer:ofObject: */
				_objOop5 = unsignedLongAt((_methodArray + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - SelectorStart) ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_objOop5 & (tagMask())) == 0) && (((long64At(_objOop5)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					_objOop5 = fixFollowedFieldofObjectwithInitialValue(_index - SelectorStart, _methodArray, _objOop5);
				}
				GIV(newMethod) = _objOop5;
				/* end followField:ofObject: */
				_found = 1;
				goto l23;
			}
			_index += 1;
			if (_index == _length) {
				if (_wrapAround) {
					_found = 0;
					goto l23;
				}
				_wrapAround = 1;
				_index = SelectorStart;
			}
		}
		_found = 0;
		l23:
		;
		/* end lookupMethodInDictionary: */
		if (_found) {
			return _currentClass;
		}
		/* begin followField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop3 = unsignedLongAt((_currentClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_objOop3 & (tagMask())) == 0) && (((long64At(_objOop3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_objOop3 = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _currentClass, _objOop3);
		}
		_currentClass = _objOop3;
		/* end followField:ofObject: */
	}
	if (GIV(messageSelector) == (splObj(SelectorDoesNotUnderstand))) {
		error("Recursive not understood error encountered");
	}
	createActualMessageTo(_class);
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	GIV(messageSelector) = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SelectorDoesNotUnderstand ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	sendBreakpointreceiver(GIV(messageSelector) + BaseHeaderSize, lengthOfformat(GIV(messageSelector), (((usqInt) (longAt(GIV(messageSelector))) ) >> (formatShift())) & (formatMask())), null);
	return lookupMethodInClass(_class);
}
/*	Lookup messageSelector in class.  
	Answer 0 on success. 
	Answer the splObj: index for the error selector to use on failure 
	(MNU, CannotInterpret) */
/* StackInterpreter>>#lookupMethodWithoutMNUProcessingInClass: */
static sqInt NoDbgRegParms
lookupMethodWithoutMNUProcessingInClass(sqInt _class)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _currentClass;
	sqInt _dictionary;
	sqInt _found;
	int _index;
	usqInt _length;
	sqInt _mask;
	sqInt _methodArray;
	sqInt _nextSelector;
	usqInt _numSlots;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _objOop3;
	sqInt _objOop4;
	sqInt _objOop5;
	sqInt _objOop6;
	sqInt _objOop7;
	sqInt _objOop8;
	int _wrapAround;

	_currentClass = _class;
	while (_currentClass != GIV(nilObj)) {
		/* begin followObjField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop2 = unsignedLongAt((_currentClass + BaseHeaderSize) + ((sqInt) (((usqInt) MethodDictionaryIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert(isNonImmediate(_objOop2));
		if (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
			_objOop2 = fixFollowedFieldofObjectwithInitialValue(MethodDictionaryIndex, _currentClass, _objOop2);
		}
		_dictionary = _objOop2;
		/* end followObjField:ofObject: */
		if (_dictionary == GIV(nilObj)) {
			/* begin followField:ofObject: */
			/* begin fetchPointer:ofObject: */
			_objOop = unsignedLongAt((_currentClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				_objOop = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _currentClass, _objOop);
			}
			GIV(lkupClass) = _objOop;
			/* end followField:ofObject: */
			return SelectorCannotInterpret;
		}
		/* begin lookupMethodInDictionary: */
		/* begin numSlotsOf: */
		assert((classIndexOf(_dictionary)) > (isForwardedObjectClassIndexPun()));
		_numSlots = byteAt(_dictionary + 7);
		_length = ((_numSlots == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_dictionary - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots);
		/* end numSlotsOf: */
		_mask = (_length - SelectorStart) - 1;
		if (_mask <= GIV(methodDictLinearSearchLimit)) {
			_index = 0;
			while (_index <= _mask) {
				/* begin followField:ofObject: */
				/* begin fetchPointer:ofObject: */
				_objOop3 = unsignedLongAt((_dictionary + BaseHeaderSize) + ((sqInt) (((usqInt) (_index + SelectorStart) ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_objOop3 & (tagMask())) == 0) && (((long64At(_objOop3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					_objOop3 = fixFollowedFieldofObjectwithInitialValue(_index + SelectorStart, _dictionary, _objOop3);
				}
				_nextSelector = _objOop3;
				/* end followField:ofObject: */
				if (_nextSelector == GIV(messageSelector)) {
					/* begin followObjField:ofObject: */
					/* begin fetchPointer:ofObject: */
					_objOop7 = unsignedLongAt((_dictionary + BaseHeaderSize) + ((sqInt) (((usqInt) MethodArrayIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					assert(isNonImmediate(_objOop7));
					if (((long64At(_objOop7)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
						_objOop7 = fixFollowedFieldofObjectwithInitialValue(MethodArrayIndex, _dictionary, _objOop7);
					}
					_methodArray = _objOop7;
					/* end followObjField:ofObject: */
					/* begin followField:ofObject: */
					/* begin fetchPointer:ofObject: */
					_objOop22 = unsignedLongAt((_methodArray + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (((_objOop22 & (tagMask())) == 0) && (((long64At(_objOop22)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						_objOop22 = fixFollowedFieldofObjectwithInitialValue(_index, _methodArray, _objOop22);
					}
					GIV(newMethod) = _objOop22;
					/* end followField:ofObject: */
					_found = 1;
					goto l19;
				}
				_index += 1;
			}
			_found = 0;
			goto l19;
		}
		_index = SelectorStart + (_mask & (((GIV(messageSelector) & (tagMask()))
			 ? GIV(messageSelector) >> 3
			 : (uint32AtPointer(GIV(messageSelector) + 4)) & (identityHashHalfWordMask()))));
		_wrapAround = 0;
		while (1) {
			/* begin followField:ofObject: */
			/* begin fetchPointer:ofObject: */
			_objOop6 = unsignedLongAt((_dictionary + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_objOop6 & (tagMask())) == 0) && (((long64At(_objOop6)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				_objOop6 = fixFollowedFieldofObjectwithInitialValue(_index, _dictionary, _objOop6);
			}
			_nextSelector = _objOop6;
			/* end followField:ofObject: */
			if (_nextSelector == GIV(nilObj)) {
				_found = 0;
				goto l19;
			}
			if (_nextSelector == GIV(messageSelector)) {
				/* begin followObjField:ofObject: */
				/* begin fetchPointer:ofObject: */
				_objOop4 = unsignedLongAt((_dictionary + BaseHeaderSize) + ((sqInt) (((usqInt) MethodArrayIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				assert(isNonImmediate(_objOop4));
				if (((long64At(_objOop4)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					_objOop4 = fixFollowedFieldofObjectwithInitialValue(MethodArrayIndex, _dictionary, _objOop4);
				}
				_methodArray = _objOop4;
				/* end followObjField:ofObject: */
				/* begin followField:ofObject: */
				/* begin fetchPointer:ofObject: */
				_objOop5 = unsignedLongAt((_methodArray + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - SelectorStart) ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_objOop5 & (tagMask())) == 0) && (((long64At(_objOop5)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					_objOop5 = fixFollowedFieldofObjectwithInitialValue(_index - SelectorStart, _methodArray, _objOop5);
				}
				GIV(newMethod) = _objOop5;
				/* end followField:ofObject: */
				_found = 1;
				goto l19;
			}
			_index += 1;
			if (_index == _length) {
				if (_wrapAround) {
					_found = 0;
					goto l19;
				}
				_wrapAround = 1;
				_index = SelectorStart;
			}
		}
		_found = 0;
		l19:
		;
		/* end lookupMethodInDictionary: */
		if (_found) {
			addNewMethodToCache(_class);
			return 0;
		}
		/* begin followField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop8 = unsignedLongAt((_currentClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_objOop8 & (tagMask())) == 0) && (((long64At(_objOop8)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_objOop8 = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _currentClass, _objOop8);
		}
		_currentClass = _objOop8;
		/* end followField:ofObject: */
	}
	GIV(lkupClass) = _class;
	return SelectorDoesNotUnderstand;
}
/*	Lookup selector in class. Answer the method or nil. This is a debugging 
	routine. It does /not/ side-effect lookupClass or newMethod. */
/* StackInterpreter>>#lookupSelector:inClass: */
sqInt
lookupSelectorinClass(sqInt _selector, sqInt _class)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _currentClass;
	sqInt _dictionary;
	sqInt _index;
	usqInt _length;
	sqInt _mask;
	sqInt _meth;
	sqInt _methodArray;
	sqInt _nextSelector;
	usqInt _numSlots;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _objOop3;
	sqInt _objOop4;
	int _wrapAround;

	_currentClass = _class;
	while (_currentClass != GIV(nilObj)) {
		/* begin followObjField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop3 = unsignedLongAt((_currentClass + BaseHeaderSize) + ((sqInt) (((usqInt) MethodDictionaryIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert(isNonImmediate(_objOop3));
		if (((long64At(_objOop3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
			_objOop3 = fixFollowedFieldofObjectwithInitialValue(MethodDictionaryIndex, _currentClass, _objOop3);
		}
		_dictionary = _objOop3;
		/* end followObjField:ofObject: */
		if (_dictionary == GIV(nilObj)) {
			return null;
		}
		{
			/* begin lookupMethodFor:InDictionary: */
			/* begin numSlotsOf: */
			assert((classIndexOf(_dictionary)) > (isForwardedObjectClassIndexPun()));
			_numSlots = byteAt(_dictionary + 7);
			_length = ((_numSlots == (numSlotsMask()))
				 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_dictionary - BaseHeaderSize)) ) << 8) ) ) ) >> 8
				 : _numSlots);
			/* end numSlotsOf: */
			_mask = (_length - SelectorStart) - 1;
			_index = SelectorStart + (_mask & (((_selector & (tagMask()))
				 ? _selector >> 3
				 : (uint32AtPointer(_selector + 4)) & (identityHashHalfWordMask()))));
			_wrapAround = 0;
			while (1) {
				/* begin fetchPointer:ofObject: */
				_nextSelector = unsignedLongAt((_dictionary + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (_nextSelector == GIV(nilObj)) {
					_meth = null;
					goto l7;
				}
				if (((_nextSelector & (tagMask())) == 0) && (((long64At(_nextSelector)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					_nextSelector = fixFollowedFieldofObjectwithInitialValue(_index + SelectorStart, _dictionary, _nextSelector);
				}
				if (_nextSelector == _selector) {
					/* begin followObjField:ofObject: */
					/* begin fetchPointer:ofObject: */
					_objOop = unsignedLongAt((_dictionary + BaseHeaderSize) + ((sqInt) (((usqInt) MethodArrayIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					assert(isNonImmediate(_objOop));
					if (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
						_objOop = fixFollowedFieldofObjectwithInitialValue(MethodArrayIndex, _dictionary, _objOop);
					}
					_methodArray = _objOop;
					/* end followObjField:ofObject: */
					/* begin followField:ofObject: */
					/* begin fetchPointer:ofObject: */
					_objOop2 = unsignedLongAt((_methodArray + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - SelectorStart) ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (((_objOop2 & (tagMask())) == 0) && (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						_objOop2 = fixFollowedFieldofObjectwithInitialValue(_index - SelectorStart, _methodArray, _objOop2);
					}
					_meth = _objOop2;
					goto l7;
					/* end followField:ofObject: */
				}
				_index += 1;
				if (_index == _length) {
					if (_wrapAround) {
						_meth = null;
						goto l7;
					}
					_wrapAround = 1;
					_index = SelectorStart;
				}
			}
			_meth = null;
			l7:
			;
			/* end lookupMethodFor:InDictionary: */
			if (!(_meth == null)) {
				return _meth;
			}
		}
		/* begin followField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop4 = unsignedLongAt((_currentClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_objOop4 & (tagMask())) == 0) && (((long64At(_objOop4)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_objOop4 = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _currentClass, _objOop4);
		}
		_currentClass = _objOop4;
		/* end followField:ofObject: */
	}
	return null;
}
/*	 
	Allocate a new stack page, create a base frame for the argument context. 
	Return the allocated page. 
	 
	This method ignores (and destroys) the instructionPointer variable. 
	Callers must make sure that the instruction pointer is saved/stored in 
	suspended frames. 
	 
	Postconditions: 
	- The frame and context are married. 
	- The instruction pointer of the frame is the top of the stack and must be 
	popped by the caller when resuming 
	 */
/* StackInterpreter>>#makeBaseFrameFor: */
static StackPage * NoDbgRegParms
makeBaseFrameFor(sqInt _aContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	CogMethod * _cogMethod;
	CogMethod *_cogMethod2;
	sqInt _contextSavedIP;
	sqInt _contextSavedIP2;
	sqInt _header;
	sqInt _header2;
	sqInt _header3;
	sqInt _header4;
	sqInt _i;
	StackPage *_lruOrFree;
	sqInt _maybeClosure;
	sqInt _methodHeader;
	sqInt _numArgs;
	sqInt _object;
	sqInt _object2;
	sqInt _object22;
	sqInt _object3;
	sqInt _object4;
	sqInt _object5;
	sqInt _object6;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _objOop3;
	sqInt _objOop4;
	sqInt _oop;
	sqInt _oop2;
	StackPage *_page;
	sqInt _rawHeader;
	sqInt _rcvr;
	char *_sp;
	char *_sp2;
	char *_sp22;
	char *_sp23;
	char *_sp3;
	char *_sp32;
	char *_sp33;
	char *_sp4;
	char *_sp42;
	char *_sp5;
	char *_sp52;
	char *_sp6;
	char *_sp62;
	char *_sp7;
	char *_sp8;
	char *_sp9;
	sqInt _stackPtrIndex;
	sqInt _theInstructionPointer;
	sqInt _theInstructionPointer2;
	sqInt _theInstructionPointer3;
	sqInt _theIP;
	sqInt _theIP2;
	sqInt _theMethod;
	sqInt _theMethodPointer;
	char *_theSP;
	sqInt _valuePointer;
	sqInt _valuePointer2;
	sqInt _valuePointer3;
	sqInt _valuePointer4;
	int _yetToCompact;

	assert(isContext(_aContext));
	assert(isSingleContext(_aContext));
	assert(goodContextSize(_aContext));
	GIV(instructionPointer) = 0;
	/* begin newStackPage */
	_lruOrFree = (GIV(mostRecentlyUsedPage)->nextPage);
	if (((_lruOrFree->baseFP)) == 0) {
		_page = _lruOrFree;
		goto l7;
	}
	divorceFramesIn(_lruOrFree);
	_page = _lruOrFree;
	l7:
	;
	/* end newStackPage */
	GIV(stackPointer) = ((_page->baseAddress)) + BytesPerWord;
	/* begin push: */
	/* begin followObjField:ofObject: */
	/* begin fetchPointer:ofObject: */
	_objOop4 = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(isNonImmediate(_objOop4));
	if (((long64At(_objOop4)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		_objOop4 = fixFollowedFieldofObjectwithInitialValue(SenderIndex, _aContext, _objOop4);
	}
	_object3 = _objOop4;
	/* end followObjField:ofObject: */
	unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), _object3);
	GIV(stackPointer) = _sp3;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp4 = GIV(stackPointer) - BytesPerWord), _aContext);
	GIV(stackPointer) = _sp4;
	/* end push: */
	/* begin followField:ofObject: */
	/* begin fetchPointer:ofObject: */
	_objOop = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ReceiverIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		_objOop = fixFollowedFieldofObjectwithInitialValue(ReceiverIndex, _aContext, _objOop);
	}
	_rcvr = _objOop;
	/* end followField:ofObject: */
	/* begin followField:ofObject: */
	/* begin fetchPointer:ofObject: */
	_objOop2 = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ClosureIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_objOop2 & (tagMask())) == 0) && (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		_objOop2 = fixFollowedFieldofObjectwithInitialValue(ClosureIndex, _aContext, _objOop2);
	}
	_maybeClosure = _objOop2;
	/* end followField:ofObject: */
	/* begin push: */
	_object4 = ((_maybeClosure != GIV(nilObj))
		 ? _maybeClosure
		 : _rcvr);
	unsignedLongAtput((_sp5 = GIV(stackPointer) - BytesPerWord), _object4);
	GIV(stackPointer) = _sp5;
	/* end push: */
	/* begin followObjField:ofObject: */
	/* begin fetchPointer:ofObject: */
	_objOop3 = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(isNonImmediate(_objOop3));
	if (((long64At(_objOop3)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		_objOop3 = fixFollowedFieldofObjectwithInitialValue(MethodIndex, _aContext, _objOop3);
	}
	_theMethod = _objOop3;
	/* end followObjField:ofObject: */
	if (_maybeClosure != GIV(nilObj)) {
		/* begin quickFetchInteger:ofObject: */
		/* begin fetchPointer:ofObject: */
		_oop = unsignedLongAt((_maybeClosure + BaseHeaderSize) + ((sqInt) (((usqInt) FullClosureNumArgsIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert(((_oop & 7) == 1));
		_numArgs = _oop >> 3;
		/* end quickFetchInteger:ofObject: */
	} else {
		/* begin argumentCountOfMethodHeader: */
		/* begin methodHeaderOf: */
		assert(isCompiledMethod(_theMethod));
		/* begin fetchPointer:ofObject: */
		_header2 = unsignedLongAt((_theMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_header2 & 7) == 1)) {
			_header = _header2;
		} else {
			assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
			assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
			_header = ((((CogMethod *) _header2 ))->methodHeader);
		}
		/* end methodHeaderOf: */
		_numArgs = (((usqInt) _header ) >> MethodHeaderArgCountShift) & 15;
		/* end argumentCountOfMethodHeader: */
	}
	for (_i = 1; _i <= _numArgs; _i += 1) {
		/* begin push: */
		_object = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) (ReceiverIndex + _i) ) << (shiftForWord())) ));
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
		GIV(stackPointer) = _sp;
		/* end push: */
		/* begin storePointerUnchecked:ofObject:withValue: */
		_valuePointer = GIV(nilObj);
		assert(!(isOopForwarded(_aContext)));
		longAtput((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) (ReceiverIndex + _i) ) << (shiftForWord())) ), _valuePointer);
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	/* begin push: */
	_object5 = ceBaseFrameReturnPC();
	unsignedLongAtput((_sp6 = GIV(stackPointer) - BytesPerWord), _object5);
	GIV(stackPointer) = _sp6;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp7 = GIV(stackPointer) - BytesPerWord), 0);
	GIV(stackPointer) = _sp7;
	/* end push: */
	GIV(framePointer) = GIV(stackPointer);
	/* begin setupFrameFixedPart:withHeader:withContext:maybeClosure:withNumArgs:withReceiver: */
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_theMethod));
	/* begin fetchPointer:ofObject: */
	_header4 = unsignedLongAt((_theMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (!(((_header4 & 7) == 1))) {
		assert(((usqInt) _header4 ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header4 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
	}
	/* end methodHeaderOf: */
	_theMethodPointer = _theMethod;
	/* begin instructionPointerForBaseFrameContext: */
	_theIP2 = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ));
	assert(HasBeenReturnedFromMCPC < 0);
	_contextSavedIP = ((((_theIP2 & 7) == 1))
		 ? _theIP2 >> 3
		 : HasBeenReturnedFromMCPC);
	/* end instructionPointerForBaseFrameContext: */
	if (!(_contextSavedIP < 0)) {
		/* begin instructionPointerForBaseFrameContext: */
		_theIP = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ));
		assert(HasBeenReturnedFromMCPC < 0);
		_contextSavedIP2 = ((((_theIP & 7) == 1))
			 ? _theIP >> 3
			 : HasBeenReturnedFromMCPC);
		/* end instructionPointerForBaseFrameContext: */
		/* begin setupFrameFixedPartForNewMethodInterpreted:withHeader:withContext:isBlock:withNumArgs:withReceiver: */
		/* begin methodHeaderOf: */
		assert(isCompiledMethod(_theMethod));
		/* begin fetchPointer:ofObject: */
		_header3 = unsignedLongAt((_theMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_header3 & 7) == 1)) {
			_methodHeader = _header3;
		} else {
			assert(((usqInt) _header3 ) < ((GIV(memoryMap)->newSpaceStart)));
			assert((((((CogMethod *) _header3 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
			_methodHeader = ((((CogMethod *) _header3 ))->methodHeader);
		}
		/* end methodHeaderOf: */
		/* begin push: */
		unsignedLongAtput((_sp22 = GIV(stackPointer) - BytesPerWord), _theMethod);
		GIV(stackPointer) = _sp22;
		/* end push: */
		/* begin setMethod:methodHeader: */
		/* begin setMethod: */
		assert(((usqInt) _theMethod ) >= (startOfObjectMemory(getMemoryMap())));
		{
			GIV(method) = _theMethod;
			assert(isOopCompiledMethod(GIV(method)));
		}
		/* end setMethod: */
		assert((methodHeaderOf(GIV(method))) == _methodHeader);
		/* end setMethod:methodHeader: */
		/* begin push: */
		unsignedLongAtput((_sp32 = GIV(stackPointer) - BytesPerWord), _aContext);
		GIV(stackPointer) = _sp32;
		/* end push: */
		/* begin push: */
		/* begin encodeFrameFieldHasContext:isBlock:numArgs: */
		_object22 = ((VMBIGENDIAN)
			 ? ((1 + ((sqInt) (((usqInt) _numArgs ) << ((BytesPerWord * 8) - 8)) )) + (((_aContext != GIV(nilObj))
				 ? 1ULL << ((BytesPerWord * 8) - 16)
				 : 0))) + (((_maybeClosure != GIV(nilObj))
				 ? 1ULL << ((BytesPerWord * 8) - 24)
				 : 0))
			 : ((1 + ((sqInt) (((usqInt) _numArgs ) << 8) )) + (((_aContext != GIV(nilObj))
				 ? 1U << 16
				 : 0))) + (((_maybeClosure != GIV(nilObj))
				 ? 1U << 24
				 : 0)));
		/* end encodeFrameFieldHasContext:isBlock:numArgs: */
		unsignedLongAtput((_sp42 = GIV(stackPointer) - BytesPerWord), _object22);
		GIV(stackPointer) = _sp42;
		/* end push: */
		{
			/* begin push: */
			unsignedLongAtput((_sp62 = GIV(stackPointer) - BytesPerWord), 0);
			GIV(stackPointer) = _sp62;
			/* end push: */
		}
		/* begin push: */
		unsignedLongAtput((_sp52 = GIV(stackPointer) - BytesPerWord), _rcvr);
		GIV(stackPointer) = _sp52;
		/* end push: */
		/* end setupFrameFixedPartForNewMethodInterpreted:withHeader:withContext:isBlock:withNumArgs:withReceiver: */
		{
			assert((_contextSavedIP2 >= (((LiteralStart + (literalCountOf(_theMethod))) * BytesPerOop) + 1)) && (_contextSavedIP2 <= (lengthOf(_theMethod))));
			_theInstructionPointer2 = ((_theMethod + _contextSavedIP2) + BaseHeaderSize) - 2;
		}
		_theInstructionPointer = _theInstructionPointer2;
		goto l30;
	}
	/* begin ensureMethodIsCogged:maybeClosure: */
	/* begin fetchPointer:ofObject: */
	_rawHeader = unsignedLongAt((_theMethodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if ((assert((((_rawHeader & 7) == 1)) || ((((usqInt) _rawHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _rawHeader ) >= (minCogMethodAddress())))), (_rawHeader & (smallIntegerTag())) == 0)) {
		_cogMethod = ((CogMethod *) _rawHeader );
		goto l25;
	}
	_yetToCompact = 1;
	while (1) {
		if (_maybeClosure != GIV(nilObj)) {
			_cogMethod2 = cogFullBlockMethodnumCopied(_theMethodPointer, (numSlotsOf(_maybeClosure)) - FullClosureFirstCopiedValueIndex);
		}
 else {
			_cogMethod2 = cogselector(_theMethodPointer, GIV(nilObj));
		}
		if (!((_cogMethod2 == null) && (GIV(cogCompiledCodeCompactionCalledFor) && _yetToCompact))) 
			break;
		_yetToCompact = 0;
		commenceCogCompiledCodeCompaction();
	}
	if (!(asserta(_cogMethod2 != null))) {
		error("could not compile method that should have been compiled");
	}
	_cogMethod = _cogMethod2;
	l25:
	;
	/* end ensureMethodIsCogged:maybeClosure: */
	_theMethodPointer = ((sqInt) _cogMethod );
	assert((((signed) _contextSavedIP ) >> 16) >= -1);
	_theInstructionPointer3 = ((_contextSavedIP == HasBeenReturnedFromMCPC)
		 ? ceCannotResumePC()
		 : ((sqInt) _theMethodPointer ) - _contextSavedIP);
	/* begin push: */
	_object6 = (_theMethodPointer + MFMethodFlagHasContextFlag) + (((_maybeClosure != GIV(nilObj))
		 ? MFMethodFlagIsBlockFlag
		 : 0));
	unsignedLongAtput((_sp9 = GIV(stackPointer) - BytesPerWord), _object6);
	GIV(stackPointer) = _sp9;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp23 = GIV(stackPointer) - BytesPerWord), _aContext);
	GIV(stackPointer) = _sp23;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((_sp33 = GIV(stackPointer) - BytesPerWord), _rcvr);
	GIV(stackPointer) = _sp33;
	/* end push: */
	_theInstructionPointer = _theInstructionPointer3;
	l30:
	;
	/* end setupFrameFixedPart:withHeader:withContext:maybeClosure:withNumArgs:withReceiver: */
	/* begin quickFetchInteger:ofObject: */
	/* begin fetchPointer:ofObject: */
	_oop2 = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(((_oop2 & 7) == 1));
	_stackPtrIndex = _oop2 >> 3;
	/* end quickFetchInteger:ofObject: */
	assert((ReceiverIndex + _stackPtrIndex) < (lengthOf(_aContext)));
	for (_i = _numArgs + 1; _i <= _stackPtrIndex; _i += 1) {
		/* begin push: */
		_object2 = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) (ReceiverIndex + _i) ) << (shiftForWord())) ));
		unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _object2);
		GIV(stackPointer) = _sp2;
		/* end push: */
		/* begin storePointerUnchecked:ofObject:withValue: */
		_valuePointer2 = GIV(nilObj);
		assert(!(isOopForwarded(_aContext)));
		longAtput((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) (ReceiverIndex + _i) ) << (shiftForWord())) ), _valuePointer2);
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	/* begin push: */
	unsignedLongAtput((_sp8 = GIV(stackPointer) - BytesPerWord), _theInstructionPointer);
	GIV(stackPointer) = _sp8;
	/* end push: */
	/* begin setHeadFP:andSP:inPage: */
	_theSP = GIV(stackPointer);
	assert(_theSP < GIV(framePointer));
	assert((_theSP < ((_page->baseAddress))) && (_theSP > (((_page->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((_page->baseAddress))) && (GIV(framePointer) > (((_page->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(_page->headFP = GIV(framePointer));
		(_page->headSP = _theSP);
	}
	/* end setHeadFP:andSP:inPage: */
	(_page->baseFP = (_page->headFP));
	assert(frameHasContext((_page->baseFP)));
	assert((frameNumArgs((_page->baseFP))) == _numArgs);
	assert(contexthasValidInversePCMappingOfin(_aContext, _theInstructionPointer, (_page->baseFP)));
	/* begin storePointerUnchecked:ofObject:withValue: */
	{
		assert(((oopForPointer((_page->baseFP))) & (BytesPerWord - 1)) == 0);
		_valuePointer3 = (oopForPointer((_page->baseFP))) + (smallIntegerTag());
	}
	assert(!(isOopForwarded(_aContext)));
	longAtput((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), _valuePointer3);
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	{
		assert(((oopForPointer(0)) & (BytesPerWord - 1)) == 0);
		_valuePointer4 = (oopForPointer(0)) + (smallIntegerTag());
	}
	assert(!(isOopForwarded(_aContext)));
	longAtput((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), _valuePointer4);
	/* end storePointerUnchecked:ofObject:withValue: */
	assert((((fetchPointerofObject(SenderIndex, _aContext)) & 7) == 1));
	assert((frameOfMarriedContext(_aContext)) == ((_page->baseFP)));
	assert(validStackPageBaseFrame(_page));
	return _page;
}
/*	Convert married contexts to widowed contexts, and in the CoInterpreter, 
	map any machine code pcs to bytecode pcs, and then nil all slots beyond 
	top of stack, so that the context can be resumed on any VM. */
/* StackInterpreter>>#makeContextSnapshotSafe: */
static void NoDbgRegParms
makeContextSnapshotSafe(sqInt _ctxt)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _iLimit;
	sqInt _valuePointer;
	sqInt _valuePointer2;
	sqInt _valuePointer3;

	assert(isContext(_ctxt));
	if ((((unsignedLongAt((_ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
		/* begin markContextAsDead: */
		assert(isContext(_ctxt));
		{
			/* begin storePointerUnchecked:ofObject:withValue: */
			_valuePointer3 = GIV(nilObj);
			assert(!(isOopForwarded(_ctxt)));
			longAtput((_ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), _valuePointer3);
			/* end storePointerUnchecked:ofObject:withValue: */
			/* begin storePointerUnchecked:ofObject:withValue: */
			_valuePointer2 = GIV(nilObj);
			assert(!(isOopForwarded(_ctxt)));
			longAtput((_ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), _valuePointer2);
			/* end storePointerUnchecked:ofObject:withValue: */
		}
		/* end markContextAsDead: */
	} else {
		ensureContextHasBytecodePC(_ctxt);
	}
	for (_i = (fetchStackPointerOf(_ctxt)) + CtxtTempFrameStart, _iLimit = (numSlotsOf(_ctxt)) - 1; _i <= _iLimit; _i += 1) {
		/* begin storePointerUnchecked:ofObject:withValue: */
		_valuePointer = GIV(nilObj);
		assert(!(isOopForwarded(_ctxt)));
		longAtput((_ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _valuePointer);
		/* end storePointerUnchecked:ofObject:withValue: */
	}
}
/*	make a Point xValue@yValue. 
	We know both will be integers so no value nor root checking is needed */
/* StackInterpreter>>#makePointwithxValue:yValue: */
usqInt
makePointwithxValueyValue(sqInt _xValue, sqInt _yValue)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classFormat;
	sqInt _classIndex;
	sqInt _classObj;
	usqInt _newObj;
	usqInt _numBytes;
	sqInt _numSlots;
	sqInt _objFormat;
	usqInt _pointResult;

	/* begin eeInstantiateSmallClass:numSlots: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassPoint ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	_numSlots = YIndex + 1;
	assert((rawHashBitsOf(_classObj)) != 0);
	/* begin eeInstantiateSmallClassIndex:format:numSlots: */
	_classIndex = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask());
	/* begin instSpecOfClassFormat: */
	_classFormat = (unsignedLongAt((_classObj + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	_objFormat = (((usqInt) _classFormat ) >> (fixedFieldsFieldWidth())) & (formatMask());
	/* end instSpecOfClassFormat: */
	assert((_numSlots >= 0) && ((_classIndex != 0) && ((classAtIndex(_classIndex)) != GIV(nilObj))));
	assert((((_objFormat < (firstByteFormat()))
		 ? _objFormat
		 : _objFormat & (byteFormatMask()))) == (instSpecOfClass(classAtIndex(_classIndex))));
	/* begin allocateSmallNewSpaceSlots:format:classIndex: */
	assert(_numSlots < (numSlotsMask()));
	_newObj = GIV(freeStart);
	_numBytes = BaseHeaderSize + (((_numSlots < 1)
		 ? 8
		 : _numSlots * BytesPerOop));
	assert((_numBytes % (allocationUnit())) == 0);
	assert((_newObj % (allocationUnit())) == 0);
	if ((GIV(freeStart) + _numBytes) > GIV(scavengeThreshold)) {
		if (!GIV(needGCFlag)) {
			/* begin scheduleScavenge */
			GIV(needGCFlag) = 1;
			forceInterruptCheck();
			/* end scheduleScavenge */
		}
		if ((GIV(freeStart) + _numBytes) > (((eden()).limit))) {
			error("no room in eden for allocateSmallNewSpaceSlots:format:classIndex:");
			_pointResult = 0;
			goto l4;
		}
	}
	long64Atput(_newObj, ((((usqLong) _numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) _objFormat ) << (formatShift())) )) + _classIndex);
	GIV(freeStart) += _numBytes;
	_pointResult = _newObj;
	/* end allocateSmallNewSpaceSlots:format:classIndex: */
	/* end eeInstantiateSmallClassIndex:format:numSlots: */
	l4:
	;
	/* end eeInstantiateSmallClass:numSlots: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	assert(!(isOopForwarded(_pointResult)));
	longAtput((_pointResult + BaseHeaderSize) + ((sqInt) (((usqInt) XIndex ) << (shiftForWord())) ), ((((usqInt) _xValue ) << 3) | 1));
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	assert(!(isOopForwarded(_pointResult)));
	longAtput((_pointResult + BaseHeaderSize) + ((sqInt) (((usqInt) YIndex ) << (shiftForWord())) ), ((((usqInt) _yValue ) << 3) | 1));
	/* end storePointerUnchecked:ofObject:withValue: */
	return _pointResult;
}
/*	Map all oops in the interpreter's state to their new values  
	during garbage collection or a become: operation.Assume: All traced variables contain valid oops. */
/* StackInterpreter>>#mapInterpreterOops */
static void
mapInterpreterOops(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	int _mapInstructionPointer;
	usqInt _oop;
	sqInt _theGCMode;

	mapStackPages();
	/* begin mapMachineCode: */
	_theGCMode = GIV(gcMode);
	mapObjectReferencesInMachineCode(_theGCMode);
	/* end mapMachineCode: */
	/* begin mapTraceLogs */
	mapTraceLog();
	mapPrimTraceLog();
	/* end mapTraceLogs */
	/* begin mapVMRegisters */
	if (shouldRemapObj(GIV(method))) {
		if ((_mapInstructionPointer = ((usqInt) GIV(instructionPointer) ) > GIV(method))) {
			GIV(instructionPointer) -= GIV(method);
		}
		GIV(method) = remapObj(GIV(method));
		if (_mapInstructionPointer) {
			GIV(instructionPointer) += GIV(method);
		}
	}
	if (((GIV(newMethod) & (tagMask())) == 0) && (shouldRemapObj(GIV(newMethod)))) {
		GIV(newMethod) = remapObj(GIV(newMethod));
	}
	/* end mapVMRegisters */
	/* begin mapProfileState */
	if (shouldRemapObj(GIV(profileProcess))) {
		GIV(profileProcess) = remapObj(GIV(profileProcess));
	}
	if (shouldRemapObj(GIV(profileMethod))) {
		GIV(profileMethod) = remapObj(GIV(profileMethod));
	}
	if (shouldRemapObj(GIV(profileSemaphore))) {
		GIV(profileSemaphore) = remapObj(GIV(profileSemaphore));
	}
	sqLowLevelMFence();
	if (GIV(longRunningPrimitiveCheckMethod)) {
		if (GIV(longRunningPrimitiveCheckSequenceNumber) == GIV(statCheckForEvents)) {
			GIV(longRunningPrimitiveCheckMethod) = GIV(newMethod);
		} else {
			if (shouldRemapObj(GIV(longRunningPrimitiveCheckMethod))) {
				GIV(longRunningPrimitiveCheckMethod) = remapObj(GIV(longRunningPrimitiveCheckMethod));
			}
		}
		sqLowLevelMFence();
	}
	if (GIV(longRunningPrimitiveCheckSemaphore)) {
		if (shouldRemapObj(GIV(longRunningPrimitiveCheckSemaphore))) {
			GIV(longRunningPrimitiveCheckSemaphore) = remapObj(GIV(longRunningPrimitiveCheckSemaphore));
		}
	}
	/* end mapProfileState */
	/* begin remapCallbackState */
	for (_i = 1; _i <= GIV(jmpDepth); _i += 1) {
		_oop = GIV(suspendedCallbacks)[_i];
		if (((_oop & (tagMask())) == 0) && (shouldRemapObj(_oop))) {
			GIV(suspendedCallbacks)[_i] = remapObj(_oop);
		}
		_oop = GIV(suspendedMethods)[_i];
		if (shouldRemapObj(_oop)) {
			GIV(suspendedMethods)[_i] = remapObj(_oop);
		}
	}
	/* end remapCallbackState */
	if ((GIV(tempOop) != 0) && (((GIV(tempOop) & (tagMask())) == 0) && (shouldRemapObj(GIV(tempOop))))) {
		GIV(tempOop) = remapObj(GIV(tempOop));
	}
	if ((GIV(tempOop2) != 0) && (((GIV(tempOop2) & (tagMask())) == 0) && (shouldRemapObj(GIV(tempOop2))))) {
		GIV(tempOop2) = remapObj(GIV(tempOop2));
	}
}
/* StackInterpreter>>#mapStackPages */
static void NeverInline
mapStackPages(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char * _baseFrameArgumentSP2;
	char * _baseFrameFP;
	char * _callerFP;
	char * _currentSP;
	sqInt _delta;
	char *_frameRcvrOffset;
	sqInt _frameSavedInstructionPointerLocation;
	sqInt _i;
	usqInt _methodOopBeforeRemapping;
	int _numLivePages;
	sqInt _oop2;
	sqInt _oop3;
	sqInt _remappedMethodOop;
	sqInt _theFP2;
	char *_theFP3;
	sqInt _theIP;
	char *_theIPPtr;
	StackPage *_thePage2;
	char * _theSP2;

	_numLivePages = 0;
	/* begin usedStackPagesDo: */
	/* begin allStackPagesDo: */
	for (_i = 0; _i < GIV(numStackPages); _i += 1) {
		/* begin stackPageAt: */
		_thePage2 = stackPageAtpages(_i, GIV(pages));
		/* end stackPageAt: */
		{
			if (!(((_thePage2->baseFP)) == 0)) {
				{
					assert(ifCurrentStackPageHasValidHeadPointers(_thePage2));
					_numLivePages += 1;
					if (_thePage2 == GIV(stackPage)) {
						/* begin savedInstructioPointerLocation: */
						_theFP2 = ((sqInt) ((_thePage2->headFP)) );
						_theIPPtr = (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP2 + FoxMethod)) ))) || ((unsignedLongAt(_theFP2 + FoxIFSavedIP)) == 0))
							 ? 0
							 : _theFP2 + FoxIFSavedIP);
						/* end savedInstructioPointerLocation: */
					} else {
						_theIPPtr = (_thePage2->headSP);
					}
					/* begin framesInPage:do: */
					_theSP2 = (_thePage2->headSP);
					_theFP3 = (_thePage2->headFP);
					if (!(_thePage2 == GIV(stackPage))) {
						_theSP2 += BytesPerWord;
					}
					while (1) {
						{
							assert(addressIsInPage(_thePage2, _theFP3));
							assert(addressIsInPage(_thePage2, _theSP2));
							assert((_theIPPtr == 0) || (addressIsInPage(_thePage2, _theIPPtr)));
							/* begin frameStackValuesWithFP:withSP:do: */
							_currentSP = ((char *) _theSP2 );
							_frameRcvrOffset = ((isMachineCodeIP(((usqInt) (unsignedLongAt(((char *) _theFP3 ) + FoxMethod)) )))
								 ? ((char *) _theFP3 ) + FoxMFReceiver
								 : ((char *) _theFP3 ) + FoxIFReceiver);
							while (_currentSP <= _frameRcvrOffset) {
								_oop2 = unsignedLongAt(_currentSP);
								{
									if (((_oop2 & (tagMask())) == 0) && (shouldRemapObj(_oop2))) {
										unsignedLongAtput(_currentSP, remapObj(_oop2));
									}
								}
								_currentSP += BytesPerWord;
							}
							/* end frameStackValuesWithFP:withSP:do: */
							if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP3 + FoxMethod)) )))
								 ? ((unsignedLongAt(_theFP3 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
								 : (byteAt((_theFP3 + FoxIFrameFlags) + 2)) != 0)) {
								if (shouldRemapObj(unsignedLongAt(_theFP3 + FoxThisContext))) {
									unsignedLongAtput(_theFP3 + FoxThisContext, remapObj(unsignedLongAt(_theFP3 + FoxThisContext)));
								}
								if (!(GIV(gcPhaseInProgress) == SlidingCompactionInProgress)) {
									assert((isMarriedOrWidowedContext(frameContext(_theFP3))) && ((frameOfMarriedContext(frameContext(_theFP3))) == _theFP3));
								}
							}
							if (!(isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP3 + FoxMethod)) )))) {
								if (shouldRemapObj(unsignedLongAt(_theFP3 + FoxMethod))) {
									/* begin iframeMethod: */
									_methodOopBeforeRemapping = unsignedLongAt(((char *) _theFP3 ) + FoxMethod);
									/* end iframeMethod: */
									_remappedMethodOop = remapObj(_methodOopBeforeRemapping);
									_delta = _methodOopBeforeRemapping - _remappedMethodOop;
									unsignedLongAtput(_theFP3 + FoxMethod, _remappedMethodOop);
									if (_theIPPtr != 0) {
										/* begin remapInstructionPointerInFrame:inSavedInstructionPointerLocation:byRemapDelta: */
										_frameSavedInstructionPointerLocation = _theIPPtr;
										_theIP = unsignedLongAt(_theIPPtr);
										if (_theIP == (ceReturnToInterpreterPC())) {
											_frameSavedInstructionPointerLocation = _theFP3 + FoxIFSavedIP;
										}
										{
											sqInt _theIP2;

											_theIP2 = unsignedLongAt(_frameSavedInstructionPointerLocation);
											unsignedLongAtput(_frameSavedInstructionPointerLocation, _theIP2 - _delta);
										}
										/* end remapInstructionPointerInFrame:inSavedInstructionPointerLocation:byRemapDelta: */
									}
								}
							}
							_theIPPtr = _theFP3 + FoxCallerSavedIP;
						}
						if (!(((_callerFP = pointerForOop(unsignedLongAt(_theFP3 + FoxSavedFP)))) != 0)) 
							break;
						_theSP2 = (_theFP3 + FoxCallerSavedIP) + BytesPerWord;
						_theFP3 = _callerFP;
					}
					_baseFrameFP = _theFP3;
					/* end framesInPage:do: */
					/* begin baseFrameArguments:inPage:do: */
					_baseFrameArgumentSP2 = (_baseFrameFP + FoxCallerSavedIP) + BytesPerWord;
					while (_baseFrameArgumentSP2 <= ((_thePage2->baseAddress))) {
						_oop3 = unsignedLongAt(_baseFrameArgumentSP2);
						{
							if (((_oop3 & (tagMask())) == 0) && (shouldRemapObj(_oop3))) {
								unsignedLongAtput(_baseFrameArgumentSP2, remapObj(_oop3));
							}
						}
						_baseFrameArgumentSP2 += BytesPerWord;
					}
					/* end baseFrameArguments:inPage:do: */
				}
			}
		}
	}
	/* end allStackPagesDo: */
	/* end usedStackPagesDo: */
	/* begin recordLivePagesOnMapping: */
	GIV(statNumMaps) += 1;
	GIV(statPageCountWhenMappingSum) += _numLivePages;
	GIV(statMaxPageCountWhenMapping) = ((GIV(statMaxPageCountWhenMapping) < _numLivePages) ? _numLivePages : GIV(statMaxPageCountWhenMapping));
	/* end recordLivePagesOnMapping: */
}
/*	GC of pages. Throwing away all stack pages on full GC is simple but 
	dangerous because it causes us to allocate lots of contexts immediately 
	before a GC. 
	Reclaiming pages whose top context is not referenced is poor because it 
	would take N incrementalGCs to reclaim N unused pages. Only the page whose 
	top context is not referred to by the bottom context of any other page 
	would be 
	reclaimed. Not until the next GC would the page whose top contect is the 
	previously reclaimed page's base frame's bottom context be reclaimed. 
	 
	Better is to not mark stack pages until their contexts are encountered. We 
	can eagerly trace the active page and the page reachable from its bottom 
	context if any, and so on. Other pages can be marked when we encounter a 
	married context. */
/* StackInterpreter>>#markAndTraceStackPages: */
static sqInt NoDbgRegParms
markAndTraceStackPages(sqInt _fullGCFlag)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _callerContextOrNil;
	sqInt _context;
	sqInt _i;
	void *_pointer;
	sqInt _senderOop;
	char *_theFP;
	StackPage *_thePage;
	StackPage *_thePage2;
	StackPage *_thePage22;

	if (!_fullGCFlag) {
		/* begin usedStackPagesDo: */
		/* begin allStackPagesDo: */
		for (_i = 0; _i < GIV(numStackPages); _i += 1) {
			/* begin stackPageAt: */
			_thePage22 = stackPageAtpages(_i, GIV(pages));
			/* end stackPageAt: */
			{
				if (!(((_thePage22->baseFP)) == 0)) {
					{
						markAndTraceStackPage(_thePage22);
					}
				}
			}
		}
		/* end allStackPagesDo: */
		/* end usedStackPagesDo: */
		return null;
	}
	if (GIV(stackPage) == 0) {
		return null;
	}
	_thePage = GIV(stackPage);
	do {
		markAndTraceStackPage(_thePage);
		/* begin frameCallerContext: */
		_theFP = (_thePage->baseFP);
		assert(isBaseFrame(_theFP));
		/* begin stackPageFor: */
		/* begin stackPageAt: */
		_thePage2 = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
		/* end stackPageAt: */
		/* end stackPageFor: */
		_callerContextOrNil = unsignedLongAt((_thePage2->baseAddress));
		assert(addressCouldBeObj(_callerContextOrNil));
		assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
		_context = _callerContextOrNil;
		/* end frameCallerContext: */
		if ((((_context & (tagMask())) == 0) && (((longAt(_context)) & (classIndexMask())) == ClassMethodContextCompactIndex)) && (((((unsignedLongAt((_context + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (((((unsignedLongAt((_context + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_context)))))) {
			/* begin stackPageFor: */
			/* begin frameOfMarriedContext: */
			/* begin fetchPointer:ofObject: */
			_senderOop = unsignedLongAt((_context + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			{
				assert(((_senderOop & 7) == 1));
				_pointer = pointerForOop(_senderOop - 1);
			}
			/* end frameOfMarriedContext: */
			/* begin stackPageAt: */
			_thePage = stackPageAtpages((assert((((char *) _pointer ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _pointer ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_pointer, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
			/* end stackPageAt: */
			/* end stackPageFor: */
			assert(!(isFree(_thePage)));
		}
	} while (((_thePage->trace)) < StackPageTraced);
	return 0;
}
/* StackInterpreter>>#markAndTraceStackPage: */
static void NoDbgRegParms
markAndTraceStackPage(StackPage *_thePage)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	CogMethod *_aCogMethod;
	char *_callerFP;
	char *_frameRcvrOffset;
	sqInt _oop;
	sqInt _referent;
	sqInt _referent2;
	char *_theFP;
	char *_theSP;

	assert(!(isFree(_thePage)));
	assert(ifCurrentStackPageHasValidHeadPointers(_thePage));
	assert(((_thePage->trace)) != StackPageTraced);
	(_thePage->trace = StackPageTraced);
	_theSP = (_thePage->headSP);
	_theFP = (_thePage->headFP);
	if (!(_thePage == GIV(stackPage))) {
		_theSP += BytesPerWord;
	}
	while (1) {
		_frameRcvrOffset = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? _theFP + FoxMFReceiver
			 : _theFP + FoxIFReceiver);
		while (_theSP <= _frameRcvrOffset) {
			_oop = unsignedLongAt(_theSP);
			if (((_oop & (tagMask())) == 0) && (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin followForwarded: */
				assert(isUnambiguouslyForwarder(_oop));
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent = unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
				while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
				}
				_oop = _referent;
				/* end followForwarded: */
				unsignedLongAtput(_theSP, _oop);
			}
			if (!(_oop & (tagMask()))) {
				markAndTrace(_oop);
			}
			_theSP += BytesPerWord;
		}
		if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
			 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0)) {
			assert(isContext(frameContext(_theFP)));
			markAndTrace(unsignedLongAt(_theFP + FoxThisContext));
		}
		/* begin markAndTraceMethodInFrame: */
		if (isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) ))) {
			/* begin markAndTraceMachineCodeMethod: */
			_aCogMethod = ((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) );
			markAndTrace((_aCogMethod->methodObject));
			/* end markAndTraceMachineCodeMethod: */
		} else {
			{
				markAndTrace(unsignedLongAt(_theFP + FoxMethod));
			}
		}
		/* end markAndTraceMethodInFrame: */
		if (!(((_callerFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP)))) != 0)) 
			break;
		_theSP = (_theFP + FoxCallerSavedIP) + BytesPerWord;
		_theFP = _callerFP;
	}
	_theSP = (_theFP + FoxCallerSavedIP) + BytesPerWord;
	while (_theSP <= ((_thePage->baseAddress))) {
		_oop = unsignedLongAt(_theSP);
		if (((_oop & (tagMask())) == 0) && (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin followForwarded: */
			assert(isUnambiguouslyForwarder(_oop));
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent2 = unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
			while (((_referent2 & (tagMask())) == 0) && (((long64At(_referent2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent2 = unsignedLongAt((_referent2 + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
			}
			_oop = _referent2;
			/* end followForwarded: */
			unsignedLongAtput(_theSP, _oop);
		}
		if (!(_oop & (tagMask()))) {
			markAndTrace(_oop);
		}
		_theSP += BytesPerWord;
	}
}
/*	Trace any untraced pages */
/* StackInterpreter>>#markAndTraceUntracedReachableStackPages */
static void
markAndTraceUntracedReachableStackPages(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	int _foundToBeTracedPage;
	sqInt _i;
	StackPage *_thePage2;

	do {
		_foundToBeTracedPage = 0;
		/* begin usedStackPagesDo: */
		/* begin allStackPagesDo: */
		for (_i = 0; _i < GIV(numStackPages); _i += 1) {
			/* begin stackPageAt: */
			_thePage2 = stackPageAtpages(_i, GIV(pages));
			/* end stackPageAt: */
			{
				if (!(((_thePage2->baseFP)) == 0)) {
					{
						if (((_thePage2->trace)) == StackPageReachedButUntraced) {
							_foundToBeTracedPage = 1;
							markAndTraceStackPage(_thePage2);
						}
					}
				}
			}
		}
		/* end allStackPagesDo: */
		/* end usedStackPagesDo: */
	} while (_foundToBeTracedPage);
}
/*	This is a helper for primitiveObjectPointsTo so it *does not* check the 
	frameContext field because that is an implicit self-reference not present 
	in the state . */
/* StackInterpreter>>#marriedContext:pointsTo:stackDeltaForCurrentFrame: */
static sqInt NoDbgRegParms
marriedContextpointsTostackDeltaForCurrentFrame(sqInt _spouseContext, sqInt _anOop, sqInt _stackDeltaForCurrentFrame)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_rcvrOffset;
	sqInt _senderOop;
	char *_theFP;
	StackPage *_thePage;
	char *_theSP;

	/* begin frameOfMarriedContext: */
	/* begin fetchPointer:ofObject: */
	_senderOop = unsignedLongAt((_spouseContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	{
		assert(((_senderOop & 7) == 1));
		_theFP = pointerForOop(_senderOop - 1);
	}
	/* end frameOfMarriedContext: */
	if (_theFP == GIV(framePointer)) {
		_theSP = GIV(stackPointer) + (_stackDeltaForCurrentFrame * BytesPerWord);
	} else {
		/* begin stackPageFor: */
		/* begin stackPageAt: */
		_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
		/* end stackPageAt: */
		/* end stackPageFor: */
		_theSP = findSPOfon(_theFP, _thePage);
	}
	if (((_anOop & 7) == 1)) {
		if ((_anOop == (((((((usqInt) ((((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? _theFP + FoxMFReceiver
			 : _theFP + FoxIFReceiver)) - _theSP) ) >> (shiftForWord())) + (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
			 : byteAt((_theFP + FoxIFrameFlags) + 1)))) << 3) | 1))) || (_anOop == (instVarofContext(InstructionPointerIndex, _spouseContext)))) {
			return 1;
		}
	} else {
		if (_anOop == (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((mframeHomeMethod(_theFP))->methodObject)
			 : unsignedLongAt(_theFP + FoxMethod)))) {
			return 1;
		}
		if ((unsignedLongAt(_theFP + FoxSavedFP)) == 0) {
			if (_anOop == (frameCallerContext(_theFP))) {
				return 1;
			}
		}
 else {
			if ((frameHasContext(pointerForOop(unsignedLongAt(_theFP + FoxSavedFP)))) && (_anOop == (frameContext(pointerForOop(unsignedLongAt(_theFP + FoxSavedFP)))))) {
				return 1;
			}
		}
	}
	_rcvrOffset = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? _theFP + FoxMFReceiver
		 : _theFP + FoxIFReceiver);
	while (_theSP <= _rcvrOffset) {
		if (_anOop == (unsignedLongAt(_theSP))) {
			return 1;
		}
		_theSP += BytesPerWord;
	}
	_theSP = (_theFP + FoxCallerSavedIP) + BytesPerWord;
	_rcvrOffset = _theFP + (frameStackedReceiverOffset(_theFP));
	while (_theSP <= _rcvrOffset) {
		if (_anOop == (unsignedLongAt(_theSP))) {
			return 1;
		}
		_theSP += BytesPerWord;
	}
	return 0;
}
/*	Establish aContext at the base of a new stackPage, make the stackPage the 
	active one and set-up the interreter registers. This is used to boot the 
	system and bring it back after a snapshot. */
/* StackInterpreter>>#marryContextInNewStackPageAndInitializeInterpreterRegisters: */
static void NoDbgRegParms
marryContextInNewStackPageAndInitializeInterpreterRegisters(sqInt _aContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aMethodObj;
	StackPage *_newPage;
	sqInt _top;

	assert(GIV(stackPage) == 0);
	_newPage = makeBaseFrameFor(_aContext);
	/* begin setStackPageAndLimit: */
	assert(_newPage != 0);
	GIV(stackPage) = _newPage;
	if (GIV(stackLimit) != ((char *) ((usqInt) -1 ) )) {
		GIV(stackLimit) = (GIV(stackPage)->stackLimit);
	}
	markStackPageMostRecentlyUsed(_newPage);
	/* end setStackPageAndLimit: */
	/* begin setStackPointersFromPage: */
	GIV(stackPointer) = (_newPage->headSP);
	GIV(framePointer) = (_newPage->headFP);
	/* end setStackPointersFromPage: */
	/* begin setMethod: */
	_aMethodObj = unsignedLongAt(((GIV(stackPage)->headFP)) + FoxMethod);
	assert(((usqInt) _aMethodObj ) >= (startOfObjectMemory(getMemoryMap())));
	{
		GIV(method) = _aMethodObj;
		assert(isOopCompiledMethod(GIV(method)));
	}
	/* end setMethod: */
	/* begin popStack */
	_top = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	GIV(instructionPointer) = _top;
	/* end popStack */
}
/*	Marry an unmarried frame. This means creating a spouse context 
	initialized with a subset of the frame's state (state through the last 
	argument) that references the frame. */
/* StackInterpreter>>#marryFrame:SP: */
static sqInt NoDbgRegParms
marryFrameSP(char *_theFP, char *_theSP)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _closureOrNil;
	sqInt _frameNumArgs;
	sqInt _frameNumArgs2;
	sqInt _header;
	sqInt _i;
	sqInt _methodFieldOrObj;
	sqInt _methodHeader;
	sqInt _methodObj;
	sqInt _numArgs;
	sqInt _numSlots;
	usqInt _numStack;
	sqInt _theContext;
	char *_value;
	sqInt _valuePointer;
	sqInt _valuePointer3;
	sqInt _valuePointer4;
	sqInt _valuePointer5;
	sqInt _valuePointer6;
	sqInt _valuePointer7;

	/* begin marryFrame:SP:copyTemps: */
	assert(!(frameHasContext(_theFP)));
	if (isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) ))) {
		assert(!(isBaseFrame(_theFP)));
		/* begin frameMethodField: */
		_methodFieldOrObj = unsignedLongAt(_theFP + FoxMethod);
		/* end frameMethodField: */
		longAtput(_theFP + FoxMethod, _methodFieldOrObj + MFMethodFlagHasContextFlag);
	} else {
		/* begin setIFrameHasContext: */
		byteAtput((_theFP + FoxIFrameFlags) + 2, 1);
		/* end setIFrameHasContext: */
	}
	assert(addressCouldBeOop(longAt(_theSP)));
	/* begin methodHeaderOf: */
	_methodObj = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((mframeHomeMethod(_theFP))->methodObject)
		 : unsignedLongAt(_theFP + FoxMethod));
	assert(isCompiledMethod(_methodObj));
	/* begin fetchPointer:ofObject: */
	_header = unsignedLongAt((_methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header & 7) == 1)) {
		_methodHeader = _header;
	} else {
		assert(((usqInt) _header ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_methodHeader = ((((CogMethod *) _header ))->methodHeader);
	}
	/* end methodHeaderOf: */
	_numArgs = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
		 : byteAt((_theFP + FoxIFrameFlags) + 1));
	if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagIsBlockFlag) != 0
		 : (byteAt((_theFP + FoxIFrameFlags) + 3)) != 0)) {
		_closureOrNil = unsignedLongAt(_theFP + (frameStackedReceiverOffset(_theFP)));
	} else {
		/* begin nilObject */
		_closureOrNil = GIV(nilObj);
		/* end nilObject */
	}
	_numSlots = (((_methodHeader & LargeContextBit) != 0)
		 ? LargeContextSlots
		 : SmallContextSlots);
	_numStack = (((usqInt) ((((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? _theFP + FoxMFReceiver
		 : _theFP + FoxIFReceiver)) - _theSP) ) >> (shiftForWord())) + (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
		 : byteAt((_theFP + FoxIFrameFlags) + 1)));
	_theContext = allocateNewSpaceSlotsformatclassIndex(_numSlots, indexablePointersFormat(), ClassMethodContextCompactIndex);
	/* begin setFrameContext:to: */
	unsignedLongAtput(_theFP + FoxThisContext, _theContext);
	/* end setFrameContext:to: */
	assert((_numStack + ReceiverIndex) <= _numSlots);
	/* begin storePointerUnchecked:ofObject:withValue: */
	{
		assert(((oopForPointer(_theFP)) & (BytesPerWord - 1)) == 0);
		_valuePointer4 = (oopForPointer(_theFP)) + (smallIntegerTag());
	}
	assert(!(isOopForwarded(_theContext)));
	longAtput((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), _valuePointer4);
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	/* begin withSmallIntegerTags: */
	_value = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP));
	assert(((oopForPointer(_value)) & (BytesPerWord - 1)) == 0);
	_valuePointer5 = (oopForPointer(_value)) + (smallIntegerTag());
	/* end withSmallIntegerTags: */
	assert(!(isOopForwarded(_theContext)));
	longAtput((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), _valuePointer5);
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	assert(!(isOopForwarded(_theContext)));
	longAtput((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ), ((_numStack << 3) | 1));
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	_valuePointer6 = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((mframeHomeMethod(_theFP))->methodObject)
		 : unsignedLongAt(_theFP + FoxMethod));
	assert(!(isOopForwarded(_theContext)));
	longAtput((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ), _valuePointer6);
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	assert(!(isOopForwarded(_theContext)));
	longAtput((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) ClosureIndex ) << (shiftForWord())) ), _closureOrNil);
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	_valuePointer7 = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? unsignedLongAt(_theFP + FoxMFReceiver)
		 : unsignedLongAt(_theFP + FoxIFReceiver));
	assert(!(isOopForwarded(_theContext)));
	longAtput((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) ReceiverIndex ) << (shiftForWord())) ), _valuePointer7);
	/* end storePointerUnchecked:ofObject:withValue: */
	for (_i = 1; _i <= _numArgs; _i += 1) {
		/* begin storePointerUnchecked:ofObject:withValue: */
		if (isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) ))) {
			_valuePointer = (((_i - 1) < ((_frameNumArgs = ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs))))
				 ? unsignedLongAt((_theFP + FoxCallerSavedIP) + ((_frameNumArgs - (_i - 1)) * BytesPerWord))
				 : unsignedLongAt(((((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
					 ? _theFP + FoxMFReceiver
					 : _theFP + FoxIFReceiver)) - BytesPerWord) + ((_frameNumArgs - (_i - 1)) * BytesPerWord)));
		} else {
			{
				_valuePointer = (((_i - 1) < ((_frameNumArgs2 = byteAt((_theFP + FoxIFrameFlags) + 1))))
					 ? unsignedLongAt((_theFP + FoxCallerSavedIP) + ((_frameNumArgs2 - (_i - 1)) * BytesPerWord))
					 : unsignedLongAt(((_theFP + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs2 - (_i - 1)) * BytesPerWord)));
			}
		}
		assert(!(isOopForwarded(_theContext)));
		longAtput((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) (ReceiverIndex + _i) ) << (shiftForWord())) ), _valuePointer);
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	for (_i = _numArgs + 1; _i <= _numStack; _i += 1) {
		/* begin storePointerUnchecked:ofObject:withValue: */
		_valuePointer3 = GIV(nilObj);
		assert(!(isOopForwarded(_theContext)));
		longAtput((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) (ReceiverIndex + _i) ) << (shiftForWord())) ), _valuePointer3);
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	assert(frameHasContext(_theFP));
	assert((frameOfMarriedContext(_theContext)) == _theFP);
	assert((_numStack + ReceiverIndex) < (lengthOf(_theContext)));
	return _theContext;
	/* end marryFrame:SP:copyTemps: */
}
/*	Assert-only check for leaks after external prim calls if checkForLeaks 
	includes the GCCheckPrimCall flag. 
	This is ionly really useful from a low-level C debugger, hence no 
	accessors for checkedPluginName. */
/* StackInterpreter>>#maybeLeakCheckExternalPrimCall: */
static sqInt NoDbgRegParms
maybeLeakCheckExternalPrimCall(sqInt _aMethodObj)
{
	if ((checkForLeaks & GCCheckPrimCall) && (((primitiveIndexOfMethodheader(_aMethodObj, methodHeaderOf(_aMethodObj))) == PrimNumberExternalCall) && (checkedPluginName == (fetchPointerofObject(0, literalofMethod(0, _aMethodObj)))))) {
		runLeakCheckerFor(GCCheckPrimCall);
	}
	return 1;
}
/*	Answer the selector of a method, assuming its penultimate literal is 
	either a symbol or a pointer object whose first slot references the method 
	and whose second slot is a symbol (i.e. an AdditionalMethodState). If a 
	Symbol can't be found answer nil. This isn't satisfactory, as it puts a 
	lot of information 
	into the VM, but it is needed for adequate crash debugging at Cadence. 
	With full blocks as of 9/2016 the last literal of a CompiledBlock is a 
	back pointer 
	to the enclosing block or compiled method. */
/* StackInterpreter>>#maybeSelectorOfMethod: */
sqInt
maybeSelectorOfMethod(sqInt _methodObj)
{
	sqInt _maybeSelector;
	sqInt _offset;
	sqInt _offset2;
	sqInt _penultimateLiteral;
	sqInt _ultimateLiteral;

	assert(isOopCompiledMethod(_methodObj));
	{
		assert(isOopCompiledMethod(_methodObj));
		/* begin literal:ofMethod: */
		_offset = (literalCountOf(_methodObj)) - 1;
		/* begin fetchPointer:ofObject: */
		_ultimateLiteral = unsignedLongAt((_methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset + LiteralStart) ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end literal:ofMethod: */
	}
	if (((_ultimateLiteral & (tagMask())) == 0) && (((((usqInt) (longAt(_ultimateLiteral)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()))) {
		return maybeSelectorOfMethod(_ultimateLiteral);
	}
	{
		assert(isOopCompiledMethod(_methodObj));
		/* begin literal:ofMethod: */
		_offset2 = (literalCountOf(_methodObj)) - 2;
		/* begin fetchPointer:ofObject: */
		_penultimateLiteral = unsignedLongAt((_methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset2 + LiteralStart) ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end literal:ofMethod: */
	}
	if (((_penultimateLiteral & (tagMask())) == 0) && (isPureBitsFormat((((usqInt) (longAt(_penultimateLiteral)) ) >> (formatShift())) & (formatMask())))) {
		return (((fetchClassTagOfNonImm(_penultimateLiteral)) == (fetchClassTagOfNonImm(splObj(SelectorDoesNotUnderstand))))
			 ? _penultimateLiteral
			 : 0);
	}
	return (((((_penultimateLiteral & (tagMask())) == 0) && (((((usqInt) (longAt(_penultimateLiteral)) ) >> (formatShift())) & (formatMask())) <= 5)) && (((numSlotsOf(_penultimateLiteral)) >= 2) && (((unsignedLongAt((_penultimateLiteral + BaseHeaderSize) + (0U << (shiftForWord())))) == _methodObj) && (((_maybeSelector = unsignedLongAt((_penultimateLiteral + BaseHeaderSize) + (1U << (shiftForWord())))), (((_maybeSelector & (tagMask())) == 0) && (isPureBitsFormat((((usqInt) (longAt(_maybeSelector)) ) >> (formatShift())) & (formatMask())))) && ((fetchClassTagOfNonImm(_maybeSelector)) == (fetchClassTagOfNonImm(splObj(SelectorDoesNotUnderstand)))))))))
		 ? _maybeSelector
		 : 0);
}
/* StackInterpreter>>#methodArgumentCount */
sqInt
methodArgumentCount(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(argumentCount);
}
/* StackInterpreter>>#methodClassAssociationOf: */
sqInt
methodClassAssociationOf(sqInt _methodPointer)
{
	sqInt _offset;

	/* begin literal:ofMethod: */
	_offset = (literalCountOfMethodHeader(methodHeaderOf(_methodPointer))) - 1;
	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((_methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset + LiteralStart) ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end literal:ofMethod: */
}
/*	Answer the method class of a method which is the value of an Association 
	in the last literal, 
	or answer nil if there isn't one. 
	Using a read barrier here simplifies the become implementation and costs 
	very little 
	because the class index and ValueIndex of the association almost certainly 
	share a cache line. */
/* StackInterpreter>>#methodClassOf: */
sqInt
methodClassOf(sqInt _methodPointer)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _literal;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _offset;

	/* begin followLiteral:ofMethod: */
	_offset = (literalCountOfMethodHeader(methodHeaderOf(_methodPointer))) - 1;
	/* begin followField:ofObject: */
	/* begin fetchPointer:ofObject: */
	_objOop2 = unsignedLongAt((_methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset + LiteralStart) ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_objOop2 & (tagMask())) == 0) && (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		_objOop2 = fixFollowedFieldofObjectwithInitialValue(_offset + LiteralStart, _methodPointer, _objOop2);
	}
	_literal = _objOop2;
	/* end followField:ofObject: */
	/* end followLiteral:ofMethod: */
	return (((_literal != GIV(nilObj)) && (((_literal & (tagMask())) == 0) && (((((usqInt) (longAt(_literal)) ) >> (formatShift())) & (formatMask())) <= 5)))
		 ? (assert((numSlotsOf(_literal)) > ValueIndex), /* begin followField:ofObject: */ /* begin fetchPointer:ofObject: */ (_objOop = unsignedLongAt((_literal + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ))) /* end fetchPointer:ofObject: */, ((((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))
			 ? (_objOop = fixFollowedFieldofObjectwithInitialValue(ValueIndex, _literal, _objOop))
			 : 0), _objOop /* end followField:ofObject: */)
		 : (/* begin nilObject */ GIV(nilObj) /* end nilObject */));
}
/*	Note: We now have 10 bits of primitive index, but they are in two places 
	for temporary backward compatibility. The time to unpack is negligible, 
	since the derived primitive function pointer is stored in the method 
	cache.  */
/* StackInterpreter>>#methodHeaderHasPrimitive: */
static sqInt NoDbgRegParms
methodHeaderHasPrimitive(sqInt _methodHeader)
{
	/* begin alternateHeaderHasPrimitiveFlag: */
	return _methodHeader & AlternateHeaderHasPrimFlag;
	/* end alternateHeaderHasPrimitiveFlag: */
}
/* StackInterpreter>>#methodPrimitiveIndex */
sqInt
methodPrimitiveIndex(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _firstBytecode;
	sqInt _header;
	sqInt _methodHeader;

	if (!((addressCouldBeObj(GIV(newMethod))) && (((((usqInt) (longAt(GIV(newMethod))) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())))) {
		return -1;
	}
	/* begin primitiveIndexOfMethod:header: */
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(GIV(newMethod)));
	/* begin fetchPointer:ofObject: */
	_header = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header & 7) == 1)) {
		_methodHeader = _header;
	} else {
		assert(((usqInt) _header ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_methodHeader = ((((CogMethod *) _header ))->methodHeader);
	}
	/* end methodHeaderOf: */
	return ((_methodHeader & AlternateHeaderHasPrimFlag)
		 ? ((_firstBytecode = (GIV(newMethod) + ((LiteralStart + ((_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) * BytesPerOop)) + BaseHeaderSize), (byteAt(_firstBytecode + 1)) + ((sqInt) (((usqInt) (byteAt(_firstBytecode + 2)) ) << 8) ))
		 : 0);
	/* end primitiveIndexOfMethod:header: */
}
/*	Sets the return value for a method. In the CoInterpreter we replace the 
	cumbersome primResult machinery. */
/* StackInterpreter>>#methodReturnBool: */
sqInt
methodReturnBool(sqInt _boolean)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_sp;

	/* begin pop:thenPushBool: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((_boolean)
		 ? GIV(trueObj)
		 : GIV(falseObj)));
	GIV(stackPointer) = _sp;
	/* end pop:thenPushBool: */
	return 0;
}
/*	Sets the return value for a method. */
/* StackInterpreter>>#methodReturnFloat: */
sqInt
methodReturnFloat(double _aFloat)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _nItems;
	char *_sp;

	/* begin pop:thenPushFloat: */
	_nItems = GIV(argumentCount) + 1;
	unsignedLongAtput((_sp = GIV(stackPointer) + ((_nItems - 1) * BytesPerWord)), floatObjectOf(_aFloat));
	GIV(stackPointer) = _sp;
	/* end pop:thenPushFloat: */
	return 0;
}
/*	Sets the return value for a method. In the CoInterpreter we replace the 
	cumbersome primResult machinery. */
/* StackInterpreter>>#methodReturnInteger: */
sqInt
methodReturnInteger(sqInt _integer)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_sp;

	/* begin pop:thenPushInteger: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _integer ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPushInteger: */
	return 0;
}
/*	Sets the return value for a method */
/* StackInterpreter>>#methodReturnReceiver */
sqInt
methodReturnReceiver(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin pop: */
	GIV(stackPointer) += GIV(argumentCount) * BytesPerWord;
	/* end pop: */
	return 0;
}
/*	Sets the return value for a method. */
/* StackInterpreter>>#methodReturnString: */
sqInt
methodReturnString(char *_aCString)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _oop;
	char *_sp;

	/* begin pop:thenPush: */
	_oop = stringForCString(_aCString);
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	return 0;
}
/*	Sets the return value for a method. In the CoInterpreter we replace the 
	cumbersome primResult machinery. */
/* StackInterpreter>>#methodReturnValue: */
sqInt
methodReturnValue(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_sp;

	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	return 0;
}
/*	The module with the given name was just unloaded.  
	Make sure we have no dangling references. */
/* StackInterpreter>>#moduleUnloaded: */
EXPORT(void)
moduleUnloaded(char *aModuleName)
{
}
/*	Move frames from the hot end of oldPage through to theFP to newPage. 
	This has the effect of making theFP a base frame which can be stored into. 
	Answer theFP's new location. */
/* StackInterpreter>>#moveFramesIn:through:toPage: */
static char * NoDbgRegParms
moveFramesInthroughtoPage(StackPage *_oldPage, char *_theFP, StackPage *_newPage)
{
	char *_callerFP;
	sqInt _callerIP;
	sqInt _callerIP2;
	int _delta;
	char *_fpInNewPage;
	char *_newFP;
	char *_newSP;
	sqInt _numArgs;
	char *_offsetCallerFP;
	char *_source;
	sqInt _stackedReceiverOffset;
	sqInt _theContext;
	char *_theFP2;
	char *_theSP;
	sqInt _valuePointer;
	sqInt _valuePointer2;

	assert(!(isBaseFrame(_theFP)));
	assert(validStackPageBaseFrames());
	/* begin frameCallerFP: */
	_callerFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP));
	/* end frameCallerFP: */
	assert(frameHasContext(_callerFP));
	assert(isContext(frameContext(_callerFP)));
	{
		/* begin ensureFrameIsMarried:SP: */
		_theSP = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? _theFP + FoxMFReceiver
			 : _theFP + FoxIFReceiver);
		if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
			 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0)) {
			assert(isContext(frameContext(_theFP)));
			_theContext = unsignedLongAt(_theFP + FoxThisContext);
			goto l8;
		}
		_theContext = marryFrameSP(_theFP, _theSP);
		l8:
		;
		/* end ensureFrameIsMarried:SP: */
	}
	{
		unsignedLongAtput((_newSP = (_newPage->baseAddress)), unsignedLongAt(_callerFP + FoxThisContext));
		unsignedLongAtput((_newSP -= BytesPerWord), _theContext);
	}
	/* begin frameStackedReceiverOffset: */
	/* begin frameStackedReceiverOffsetNumArgs: */
	_numArgs = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
		 : byteAt((_theFP + FoxIFrameFlags) + 1));
	_stackedReceiverOffset = (FoxCallerSavedIP + BytesPerWord) + ((sqInt) (((usqInt) _numArgs ) << (shiftForWord())) );
	/* end frameStackedReceiverOffsetNumArgs: */
	/* end frameStackedReceiverOffset: */
	for (_source = _theFP + _stackedReceiverOffset; _source >= ((_oldPage->headSP)); _source += -BytesPerWord) {
		_newSP -= BytesPerWord;
		unsignedLongAtput(_newSP, unsignedLongAt(_source));
	}
	_delta = _newSP - ((_oldPage->headSP));
	_newFP = (((_newPage->baseAddress)) - _stackedReceiverOffset) - (2 * BytesPerWord);
	/* begin setHeadFP:andSP:inPage: */
	_theFP2 = ((_oldPage->headFP)) + _delta;
	assert(_newSP < _theFP2);
	assert((_newSP < ((_newPage->baseAddress))) && (_newSP > (((_newPage->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((_theFP2 < ((_newPage->baseAddress))) && (_theFP2 > (((_newPage->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(_newPage->headFP = _theFP2);
		(_newPage->headSP = _newSP);
	}
	/* end setHeadFP:andSP:inPage: */
	(_newPage->baseFP = _newFP);
	/* begin getCallerIPFromFP:callerFP: */
	{
		_callerIP2 = oopForPointer(pointerForOop(unsignedLongAt(_theFP + FoxCallerSavedIP)));
	}
	if (((usqInt) _callerIP2 ) < (startOfObjectMemory(getMemoryMap()))) {
		_callerIP = _callerIP2;
		goto l10;
	}
	/* begin iframeSavedIP:put: */
	assert(!(isMachineCodeFrame(((char *) _callerFP ))));
	unsignedLongAtput(((char *) _callerFP ) + FoxIFSavedIP, _callerIP2);
	/* end iframeSavedIP:put: */
	_callerIP = ceReturnToInterpreterPC();
	l10:
	;
	/* end getCallerIPFromFP:callerFP: */
	longAtput(_theFP + _stackedReceiverOffset, _callerIP);
	assert((_callerFP < ((_oldPage->baseAddress))) && (_callerFP > (((_oldPage->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(_oldPage->headFP = _callerFP);
		(_oldPage->headSP = _theFP + _stackedReceiverOffset);
	}
	{
		longAtput(_newFP + FoxCallerSavedIP, ceBaseFrameReturnPC());
		longAtput(_newFP + FoxSavedFP, 0);
	}
	_fpInNewPage = (_newPage->headFP);
	do {
		/* begin frameCallerFP: */
		_offsetCallerFP = pointerForOop(unsignedLongAt(_fpInNewPage + FoxSavedFP));
		/* end frameCallerFP: */
		if (_offsetCallerFP != 0) {
			_offsetCallerFP += _delta;
		}
		longAtput(_fpInNewPage + FoxSavedFP, oopForPointer(_offsetCallerFP));
		if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_fpInNewPage + FoxMethod)) )))
			 ? ((unsignedLongAt(_fpInNewPage + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
			 : (byteAt((_fpInNewPage + FoxIFrameFlags) + 2)) != 0)) {
			/* begin frameContext: */
			_theContext = unsignedLongAt(_fpInNewPage + FoxThisContext);
			/* end frameContext: */
			/* begin storePointerUnchecked:ofObject:withValue: */
			{
				assert(((oopForPointer(_fpInNewPage)) & (BytesPerWord - 1)) == 0);
				_valuePointer = (oopForPointer(_fpInNewPage)) + (smallIntegerTag());
			}
			assert(!(isOopForwarded(_theContext)));
			longAtput((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), _valuePointer);
			/* end storePointerUnchecked:ofObject:withValue: */
			/* begin storePointerUnchecked:ofObject:withValue: */
			{
				assert(((oopForPointer(_offsetCallerFP)) & (BytesPerWord - 1)) == 0);
				_valuePointer2 = (oopForPointer(_offsetCallerFP)) + (smallIntegerTag());
			}
			assert(!(isOopForwarded(_theContext)));
			longAtput((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), _valuePointer2);
			/* end storePointerUnchecked:ofObject:withValue: */
		}
		_fpInNewPage = _offsetCallerFP;
	} while (_fpInNewPage != 0);
	assert(validStackPageBaseFrames());
	return _newFP;
}
/*	Brain-damaged nameOfClass: for C VM. Does *not* answer Foo class for 
	metaclasses. Use e.g. classIsMeta: to avoid being fooled. */
/* StackInterpreter>>#nameOfClass: */
static char * NoDbgRegParms
nameOfClass(sqInt _classOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _maybeNameOop;
	sqInt _maybeThisClassOop;
	usqInt _numSlots;
	usqInt _numSlots2;

	/* begin numSlotsOf: */
	assert((classIndexOf(_classOop)) > (isForwardedObjectClassIndexPun()));
	_numSlots2 = byteAt(_classOop + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_classOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOf: */
	if (_numSlots == GIV(metaclassNumSlots)) {
		/* begin fetchPointer:ofObject: */
		_maybeThisClassOop = unsignedLongAt((_classOop + BaseHeaderSize) + ((sqInt) (((usqInt) GIV(thisClassIndex) ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (addressCouldBeClassObj(_maybeThisClassOop)) {
			return nameOfClass(unsignedLongAt((_classOop + BaseHeaderSize) + ((sqInt) (((usqInt) GIV(thisClassIndex) ) << (shiftForWord())) )));
		}
		return "bad class";
	}
	if (!((_numSlots > GIV(classNameIndex)) && (((_maybeNameOop = unsignedLongAt((_classOop + BaseHeaderSize) + ((sqInt) (((usqInt) GIV(classNameIndex) ) << (shiftForWord())) ))), ((_maybeNameOop & (tagMask())) == 0) && (((((usqInt) (longAt(_maybeNameOop)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())))))) {
		return "bad class";
	}
	return firstIndexableField(_maybeNameOop);
}
/* StackInterpreter>>#noInlineTemporary:in: */
static sqInt NoDbgRegParms
noInlineTemporaryin(sqInt _offset, char *_theFP)
{
	sqInt _frameNumArgs;
	sqInt _frameNumArgs2;

	return ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((_offset < ((_frameNumArgs = ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs))))
			 ? unsignedLongAt((_theFP + FoxCallerSavedIP) + ((_frameNumArgs - _offset) * BytesPerWord))
			 : unsignedLongAt(((((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
				 ? _theFP + FoxMFReceiver
				 : _theFP + FoxIFReceiver)) - BytesPerWord) + ((_frameNumArgs - _offset) * BytesPerWord)))
		 : ((_offset < ((_frameNumArgs2 = byteAt((_theFP + FoxIFrameFlags) + 1))))
			 ? unsignedLongAt((_theFP + FoxCallerSavedIP) + ((_frameNumArgs2 - _offset) * BytesPerWord))
			 : unsignedLongAt(((_theFP + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs2 - _offset) * BytesPerWord))));
}
/*	Answer true if there are no marked contexts on thePage. */
/* StackInterpreter>>#noMarkedContextsOnPage: */
static sqInt NoDbgRegParms
noMarkedContextsOnPage(StackPage *_thePage)
{
	char *_theFP;

	assert(!(isFree(_thePage)));
	_theFP = (_thePage->headFP);
	do {
		if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
			 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0)) {
			assert(isContext(frameContext(_theFP)));
			if (isMarked(unsignedLongAt(_theFP + FoxThisContext))) {
				return 0;
			}
		}
	} while (((_theFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP)))) != 0);
	return 1;
}
/* StackInterpreter>>#numStkPages */
static sqInt
numStkPages(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return GIV(numStackPages);
}
/*	Answer if objOop looks like a class object. WIth Spur be lenient if the 
	object doesn't 
	yet have a hash (i.e. is not yet in the classTable), and accept forwarding 
	pointers.  */
/* StackInterpreter>>#objCouldBeClassObj: */
sqInt
objCouldBeClassObj(sqInt _objOop)
{
	sqInt _fieldOop;

	return (((((usqInt) (longAt(_objOop)) ) >> (formatShift())) & (formatMask())) <= 5) && (((numSlotsOfAny(_objOop)) > InstanceSpecificationIndex) && (((_fieldOop = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ))), ((addressCouldBeObj(_fieldOop)) && ((((((usqInt) (longAt(_fieldOop)) ) >> (formatShift())) & (formatMask())) <= 5) || ((((_fieldOop & (tagMask())) == 0) && (((long64At(_fieldOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) && (isPointers(followForwarded(_fieldOop)))))) && (((_fieldOop = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) MethodDictionaryIndex ) << (shiftForWord())) ))), ((addressCouldBeObj(_fieldOop)) && ((((((usqInt) (longAt(_fieldOop)) ) >> (formatShift())) & (formatMask())) <= 5) || ((((_fieldOop & (tagMask())) == 0) && (((long64At(_fieldOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) && (isPointers(followForwarded(_fieldOop)))))) && ((((unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) & 7) == 1)))))));
}
/* StackInterpreter>>#penultimateLiteralOf: */
sqInt
penultimateLiteralOf(sqInt _aMethodOop)
{
	sqInt _offset;

	assert(isOopCompiledMethod(_aMethodOop));
	/* begin literal:ofMethod: */
	_offset = (literalCountOfMethodHeader(methodHeaderOf(_aMethodOop))) - 2;
	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((_aMethodOop + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset + LiteralStart) ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end literal:ofMethod: */
}
/*	In the StackInterpreter stacks grow down. */
/* StackInterpreter>>#popStack */
sqInt
popStack(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _top;

	_top = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	return _top;
}
/*	In the StackInterpreter stacks grow down. */
/* StackInterpreter>>#pop: */
sqInt
pop(sqInt _nItems)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	GIV(stackPointer) += _nItems * BytesPerWord;
	return null;
}
/*	In the StackInterpreter stacks grow down. */
/* StackInterpreter>>#pop:thenPush: */
void
popthenPush(sqInt _nItems, sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_sp;

	unsignedLongAtput((_sp = GIV(stackPointer) + ((_nItems - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
}
/*	integerValue is interpreted as POSITIVE, e.g. as the result of Bitmap>at:. 
	N.B. Returning in each arm separately enables Slang inlining. 
	/Don't/ return the ifTrue:ifFalse: unless Slang inlining of conditionals 
	is fixed. */
/* StackInterpreter>>#positive32BitIntegerFor: */
sqInt
positive32BitIntegerFor(unsigned int _integerValue)
{
	{
		return (((((usqInt) _integerValue ) & 0xFFFFFFFFU) << 3) | 1);
	}
}
/*	Answer a Large Positive Integer object for the given integer value. N.B. 
	will *not* cause a GC. */
/* StackInterpreter>>#positive64BitIntegerFor: */
sqInt
positive64BitIntegerFor(usqLong _integerValue)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _newLargeInteger;
	usqInt _newObj;
	usqInt _numBytes;
	sqInt _numSlots;
	sqInt _objFormat;
	int _sz;
	sqLong _value;

	{
		if (_integerValue <= MaxSmallInteger) {
			return ((_integerValue << 3) | 1);
		}
		_sz = 8;
	}
	/* begin eeInstantiateSmallClassIndex:format:numSlots: */
	_objFormat = (firstByteFormat()) + ((8 - _sz) & (BytesPerWord - 1));
	_numSlots = 8 / BytesPerOop;
	assert((_numSlots >= 0) && ((classAtIndex(ClassLargePositiveIntegerCompactIndex)) != GIV(nilObj)));
	assert((((_objFormat < (firstByteFormat()))
		 ? _objFormat
		 : _objFormat & (byteFormatMask()))) == (instSpecOfClass(classAtIndex(ClassLargePositiveIntegerCompactIndex))));
	/* begin allocateSmallNewSpaceSlots:format:classIndex: */
	assert(_numSlots < (numSlotsMask()));
	_newObj = GIV(freeStart);
	_numBytes = BaseHeaderSize + (((_numSlots < 1)
		 ? 8
		 : _numSlots * BytesPerOop));
	assert((_numBytes % (allocationUnit())) == 0);
	assert((_newObj % (allocationUnit())) == 0);
	if ((GIV(freeStart) + _numBytes) > GIV(scavengeThreshold)) {
		if (!GIV(needGCFlag)) {
			/* begin scheduleScavenge */
			GIV(needGCFlag) = 1;
			forceInterruptCheck();
			/* end scheduleScavenge */
		}
		if ((GIV(freeStart) + _numBytes) > (((eden()).limit))) {
			error("no room in eden for allocateSmallNewSpaceSlots:format:classIndex:");
			_newLargeInteger = 0;
			goto l3;
		}
	}
	long64Atput(_newObj, ((((usqLong) _numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) _objFormat ) << (formatShift())) )) + ClassLargePositiveIntegerCompactIndex);
	GIV(freeStart) += _numBytes;
	_newLargeInteger = _newObj;
	/* end allocateSmallNewSpaceSlots:format:classIndex: */
	l3:
	;
	/* end eeInstantiateSmallClassIndex:format:numSlots: */
	/* begin storeLong64:ofObject:withValue: */
	_value = SQ_SWAP_8_BYTES_IF_BIGENDIAN(_integerValue);
	long64Atput((_newLargeInteger + BaseHeaderSize) + (0U << 3), _value);
	/* end storeLong64:ofObject:withValue: */
	return _newLargeInteger;
}
/* StackInterpreter>>#positiveMachineIntegerFor: */
static sqInt NoDbgRegParms
positiveMachineIntegerFor(usqIntptr_t _value)
{
	sqInt _resultObj;

	{
		_resultObj = positive64BitIntegerFor(_value);
	}
	return _resultObj;
}
/*	Primitive. Compare two word or byte indexed objects for equality. 
	This version uses memcmp for comparison. 
	It is specialized for equality and thus it performs an unordered 
	comparison, not caring about element order. 
	This can be used for: 
	- ByteArray 
	- ByteString 
	- FloatArray 
	... */
/* StackInterpreter>>#primitiveCompareBytes */
EXPORT(void)
primitiveCompareBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _arg1;
	sqInt _arg2;
	sqInt _boolean;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _len1;
	sqInt _len2;
	usqInt _numBytes;
	usqInt _numBytes2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _oop;
	sqInt _oop2;
	sqInt _result;
	char *_sp;
	char *_sp2;
	char *_sp3;
	sqInt _tagBits;
	sqInt _tagBits2;

	if (GIV(argumentCount) < 1) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	_arg1 = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_arg2 = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	if (_arg1 == _arg2) {
		{
			/* begin pop:thenPush: */
			_oop = GIV(trueObj);
			unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oop);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
			return;
		}
	}
	if ((instSpecOfClass(((((_tagBits = _arg1 & (tagMask()))) != 0)
		 ? unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) ))
		 : fetchClassOfNonImm(_arg1)))) != (instSpecOfClass(((((_tagBits2 = _arg2 & (tagMask()))) != 0)
		 ? unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits2 ) << (shiftForWord())) ))
		 : fetchClassOfNonImm(_arg2))))) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	if (!(((_arg1 & (tagMask())) == 0) && (isPureBitsFormat((((usqInt) (longAt(_arg1)) ) >> (formatShift())) & (formatMask()))))) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	/* begin byteSizeOf: */
	if (_arg1 & (tagMask())) {
		_len1 = 0;
		goto l5;
	}
	/* begin numBytesOf: */
	_fmt = (((usqInt) (longAt(_arg1)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_arg1)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_arg1 + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_arg1 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt >= (firstByteFormat())) {
		_len1 = _numBytes - (_fmt & 7);
		goto l5;
	}
	if (_fmt <= (sixtyFourBitIndexableFormat())) {
		_len1 = _numBytes;
		goto l5;
	}
	if (_fmt >= (firstShortFormat())) {
		_len1 = _numBytes - ((sqInt) (((usqInt) (_fmt & 3) ) << 1) );
		goto l5;
	}
	_len1 = _numBytes - ((sqInt) (((usqInt) (_fmt & 1) ) << 2) );
	/* end numBytesOf: */
	l5:
	;
	/* end byteSizeOf: */
	/* begin byteSizeOf: */
	if (_arg2 & (tagMask())) {
		_len2 = 0;
		goto l7;
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_arg2)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_arg2)) > (isForwardedObjectClassIndexPun()));
	_numSlots2 = byteAt(_arg2 + 7);
	_numBytes2 = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_arg2 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOf: */
	_numBytes2 = _numBytes2 << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_len2 = _numBytes2 - (_fmt2 & 7);
		goto l7;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_len2 = _numBytes2;
		goto l7;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_len2 = _numBytes2 - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l7;
	}
	_len2 = _numBytes2 - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	/* end numBytesOf: */
	l7:
	;
	/* end byteSizeOf: */
	if (!(_len1 == _len2)) {
		{
			/* begin pop:thenPush: */
			_oop2 = GIV(falseObj);
			unsignedLongAtput((_sp2 = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _oop2);
			GIV(stackPointer) = _sp2;
			/* end pop:thenPush: */
			return;
		}
	}
	_result = memcmp(firstIndexableField(_arg1), firstIndexableField(_arg2), _len1);
	if (_result == 0) {
		/* begin trueObject */
		_boolean = GIV(trueObj);
		/* end trueObject */
	} else {
		/* begin falseObject */
		_boolean = GIV(falseObj);
		/* end falseObject */
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp3 = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _boolean);
	GIV(stackPointer) = _sp3;
	/* end pop:thenPush: */
}
/*	Attempt to enter a CriticalSection/Mutex. If not owned, set the owner to 
	the current 
	process and answer false. If owned by the current process answer true. 
	Otherwise suspend the process. Answer if the receiver is owned by the 
	current process. */
/* StackInterpreter>>#primitiveEnterCriticalSection */
static void
primitiveEnterCriticalSection(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeProc;
	sqInt _criticalSection;
	sqInt _inInterpreter;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _oop;
	sqInt _oop2;
	sqInt _oop3;
	sqInt _owningProcess;
	sqInt _owningProcessIndex;
	char *_sp;
	char *_sp2;
	char *_sp3;

	if (GIV(argumentCount) > 0) {
		_criticalSection = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
		_activeProc = unsignedLongAt(GIV(stackPointer));
	} else {
		_criticalSection = unsignedLongAt(GIV(stackPointer));
		/* begin memoryActiveProcess */
		/* begin fetchPointer:ofObject: */
		/* begin fetchPointer:ofObject: */
		/* begin splObj: */
		/* begin fetchPointer:ofObject: */
		_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		_activeProc = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end memoryActiveProcess */
	}
	_owningProcessIndex = ExcessSignalsIndex;
	/* begin fetchPointer:ofObject: */
	_owningProcess = unsignedLongAt((_criticalSection + BaseHeaderSize) + ((sqInt) (((usqInt) _owningProcessIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_owningProcess == GIV(nilObj)) {
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_criticalSection)));
		if (((_criticalSection & (tagMask())) == 0) && ((_criticalSection & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_activeProc & (tagMask())) == 0) && (((_activeProc & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_activeProc >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_criticalSection)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _criticalSection);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_criticalSection)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l6;
		}
		if (_activeProc & (tagMask())) {
			goto l6;
		}
		if (!(_criticalSection >= 0x20000000000LL)) {
			goto l6;
		}
		if (_activeProc >= 0x20000000000LL) {
			goto l6;
		}
		if ((_activeProc >= GIV(nilObj)) && (_activeProc <= GIV(trueObj))) {
			goto l6;
		}
		if (!(_activeProc >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l6;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _criticalSection);
		l6:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_criticalSection + BaseHeaderSize) + ((sqInt) (((usqInt) _owningProcessIndex ) << (shiftForWord())) ), _activeProc);
		/* end storePointer:ofObject:withValue: */
		{
			/* begin pop:thenPush: */
			_oop = GIV(falseObj);
			unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
			return;
		}
	}
	if (_owningProcess == _activeProc) {
		{
			/* begin pop:thenPush: */
			_oop2 = GIV(trueObj);
			unsignedLongAtput((_sp2 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop2);
			GIV(stackPointer) = _sp2;
			/* end pop:thenPush: */
			return;
		}
	}
	/* begin pop:thenPush: */
	_oop3 = GIV(falseObj);
	unsignedLongAtput((_sp3 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop3);
	GIV(stackPointer) = _sp3;
	/* end pop:thenPush: */
	_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	addLastLinktoList(_activeProc, _criticalSection);
	transferTofrom(wakeHighestPriority(), CSEnterCriticalSection);
	/* begin forProcessPrimitiveReturnToExecutivePostContextSwitch: */
	if (GIV(nextProfileTick) > 0) {
		checkProfileTick(GIV(newMethod));
	}
	returnToExecutivepostContextSwitch(_inInterpreter, 1);
	/* end forProcessPrimitiveReturnToExecutivePostContextSwitch: */
}
/*	Exit the critical section. 
	This may change the active process as a result. */
/* StackInterpreter>>#primitiveExitCriticalSection */
static void
primitiveExitCriticalSection(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _criticalSection;
	sqInt _inInterpreter;
	sqInt _owningProcess;
	sqInt _owningProcessIndex;
	sqInt _valuePointer;

	_criticalSection = unsignedLongAt(GIV(stackPointer));
	_owningProcessIndex = ExcessSignalsIndex;
	if ((assert(!(isForwarded(_criticalSection))), (unsignedLongAt((_criticalSection + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ))) == GIV(nilObj))) {
		/* begin storePointerUnchecked:ofObject:withValue: */
		_valuePointer = GIV(nilObj);
		assert(!(isOopForwarded(_criticalSection)));
		longAtput((_criticalSection + BaseHeaderSize) + ((sqInt) (((usqInt) _owningProcessIndex ) << (shiftForWord())) ), _valuePointer);
		/* end storePointerUnchecked:ofObject:withValue: */
	} else {
		_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
		_owningProcess = removeFirstLinkOfList(_criticalSection);
		/* begin storePointerUnchecked:ofObject:withValue: */
		assert(!(isOopForwarded(_criticalSection)));
		longAtput((_criticalSection + BaseHeaderSize) + ((sqInt) (((usqInt) _owningProcessIndex ) << (shiftForWord())) ), _owningProcess);
		/* end storePointerUnchecked:ofObject:withValue: */
		if (resumepreemptedYieldingIffrom(_owningProcess, GIV(preemptionYields), CSExitCriticalSection)) {
			/* begin forProcessPrimitiveReturnToExecutivePostContextSwitch: */
			if (GIV(nextProfileTick) > 0) {
				checkProfileTick(GIV(newMethod));
			}
			returnToExecutivepostContextSwitch(_inInterpreter, 1);
			/* end forProcessPrimitiveReturnToExecutivePostContextSwitch: */
		}
	}
}
/* StackInterpreter>>#primitiveFloat64ArrayAdd */
static void
primitiveFloat64ArrayAdd(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _arg1;
	sqInt _arg2;
	usqInt _arraySize;
	sqInt _i;
	usqInt _numSlots;
	sqInt _res;
	char *_sp;
	double _tmp;

	_arg1 = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	_arg2 = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	_res = unsignedLongAt(GIV(stackPointer));
	/* begin numSlotsOf: */
	assert((classIndexOf(_res)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_res + 7);
	_arraySize = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_res - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	if (!(((_arg1 & (tagMask())) == 0) && ((!(((long64At(_arg1)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) && (((((usqInt) (longAt(_arg1)) ) >> (formatShift())) & (formatMask())) == (sixtyFourBitIndexableFormat()))))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			return;
		}
	}
	if (!(((_arg2 & (tagMask())) == 0) && ((!(((long64At(_arg2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) && (((((usqInt) (longAt(_arg2)) ) >> (formatShift())) & (formatMask())) == (sixtyFourBitIndexableFormat()))))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			return;
		}
	}
	if (!(((_res & (tagMask())) == 0) && ((!(((long64At(_res)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) && (((((usqInt) (longAt(_res)) ) >> (formatShift())) & (formatMask())) == (sixtyFourBitIndexableFormat()))))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			return;
		}
	}
	for (_i = 0; _i < _arraySize; _i += 1) {
		_tmp = (fetchFloat64ofObject(_i, _arg1)) + (fetchFloat64ofObject(_i, _arg2));
		/* begin storeFloat64:ofObject:withValue: */
		float64Atput((_res + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << 3) ), _tmp);
		/* end storeFloat64:ofObject:withValue: */
	}
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + ((4 - 1) * BytesPerWord)), _res);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
	} else {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		/* end primitiveFailFor: */
	}
}
/*	Note: With the Squeak V3 format we now have 10 bits of primitive index, 
	but they are 
	in two places for temporary backward compatibility. The time to unpack is 
	negligible, since the derived primitive function pointer is stored in the 
	method cache. With the 
	Spur format we assume a 3-byte CallPrimitive with a little-endian 16-bit 
	primitive index. */
/* StackInterpreter>>#primitiveIndexOfMethod:header: */
sqInt
primitiveIndexOfMethodheader(sqInt _theMethod, sqInt _methodHeader)
{
	sqInt _firstBytecode;

	return ((_methodHeader & AlternateHeaderHasPrimFlag)
		 ? ((_firstBytecode = (_theMethod + ((LiteralStart + ((_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) * BytesPerOop)) + BaseHeaderSize), (byteAt(_firstBytecode + 1)) + ((sqInt) (((usqInt) (byteAt(_firstBytecode + 2)) ) << 8) ))
		 : 0);
}
/* StackInterpreter>>#primitiveIndexOf: */
sqInt
primitiveIndexOf(sqInt _methodPointer)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _firstBytecode;
	sqInt _header;
	sqInt _methodHeader;

	/* begin primitiveIndexOfMethod:header: */
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_methodPointer));
	/* begin fetchPointer:ofObject: */
	_header = unsignedLongAt((_methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header & 7) == 1)) {
		_methodHeader = _header;
	} else {
		assert(((usqInt) _header ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_methodHeader = ((((CogMethod *) _header ))->methodHeader);
	}
	/* end methodHeaderOf: */
	return ((_methodHeader & AlternateHeaderHasPrimFlag)
		 ? ((_firstBytecode = (_methodPointer + ((LiteralStart + ((_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) * BytesPerOop)) + BaseHeaderSize), (byteAt(_firstBytecode + 1)) + ((sqInt) (((usqInt) (byteAt(_firstBytecode + 2)) ) << 8) ))
		 : 0);
	/* end primitiveIndexOfMethod:header: */
}
/*	Put this process on the scheduler's lists thus allowing it to proceed next 
	time there is 
	a chance for processes of it's priority level. It must go to the back of 
	its run queue so 
	as not to preempt any already running processes at this level. If the 
	process's priority 
	is higher than the current process, preempt the current process. */
/* StackInterpreter>>#primitiveResume */
static void
primitiveResume(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _inInterpreter;
	sqInt _proc;

	_proc = unsignedLongAt(GIV(stackPointer));
	if (!(isContext(followFieldofObject(SuspendedContextIndex, _proc)))) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	if (resumepreemptedYieldingIffrom(_proc, GIV(preemptionYields), CSResume)) {
		/* begin forProcessPrimitiveReturnToExecutivePostContextSwitch: */
		if (GIV(nextProfileTick) > 0) {
			checkProfileTick(GIV(newMethod));
		}
		returnToExecutivepostContextSwitch(_inInterpreter, 1);
		/* end forProcessPrimitiveReturnToExecutivePostContextSwitch: */
	}
}
/*	Primitive. Suspend the receiver, aProcess such that it can be executed 
	again by sending #resume. If the given process is not currently running, 
	take it off 
	its corresponding list. The primitive returns the list the receiver was 
	previously on. */
/* StackInterpreter>>#primitiveSuspend */
static void
primitiveSuspend(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _firstLink;
	sqInt _inInterpreter;
	sqInt _lastLink;
	sqInt _myList;
	sqInt _nextLink;
	sqInt _oop;
	sqInt _process;
	sqInt _referent;
	char *_sp;
	char *_sp2;
	sqInt _tempLink;
	sqInt _valuePointer;

	_process = unsignedLongAt(GIV(stackPointer));
	if (_process == (memoryActiveProcess())) {
		/* begin pop:thenPush: */
		_oop = GIV(nilObj);
		unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), _oop);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
		_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
		transferTofrom(wakeHighestPriority(), CSSuspend);
		{
			/* begin forProcessPrimitiveReturnToExecutivePostContextSwitch: */
			if (GIV(nextProfileTick) > 0) {
				checkProfileTick(GIV(newMethod));
			}
			returnToExecutivepostContextSwitch(_inInterpreter, 1);
			/* end forProcessPrimitiveReturnToExecutivePostContextSwitch: */
			return;
		}
	}
	/* begin fetchPointer:ofObject: */
	_myList = unsignedLongAt((_process + BaseHeaderSize) + ((sqInt) (((usqInt) MyListIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_myList == GIV(nilObj)) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadReceiver;
			/* end primitiveFailFor: */
			return;
		}
	}
	if (((long64At(_myList)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(_myList));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_myList + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		_myList = _referent;
		/* end followForwarded: */
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_process)));
		if (((_process & (tagMask())) == 0) && ((_process & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_myList & (tagMask())) == 0) && (((_myList & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_myList >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_process)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _process);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_process)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l8;
		}
		if (_myList & (tagMask())) {
			goto l8;
		}
		if (!(_process >= 0x20000000000LL)) {
			goto l8;
		}
		if (_myList >= 0x20000000000LL) {
			goto l8;
		}
		if ((_myList >= GIV(nilObj)) && (_myList <= GIV(trueObj))) {
			goto l8;
		}
		if (!(_myList >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l8;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _process);
		l8:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_process + BaseHeaderSize) + ((sqInt) (((usqInt) MyListIndex ) << (shiftForWord())) ), _myList);
		/* end storePointer:ofObject:withValue: */
	}
	/* begin removeProcess:fromList: */
	assert(!(isForwarded(_process)));
	assert(!(isForwarded(_myList)));
	/* begin fetchPointer:ofObject: */
	_firstLink = unsignedLongAt((_myList + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	_lastLink = unsignedLongAt((_myList + BaseHeaderSize) + ((sqInt) (((usqInt) LastLinkIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(!(isForwarded(_firstLink)));
	assert(!(isForwarded(_lastLink)));
	if (_process == _firstLink) {
		/* begin fetchPointer:ofObject: */
		_nextLink = unsignedLongAt((_process + BaseHeaderSize) + ((sqInt) (((usqInt) NextLinkIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert(!(isForwarded(_nextLink)));
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_myList)));
		if (((_myList & (tagMask())) == 0) && ((_myList & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_nextLink & (tagMask())) == 0) && (((_nextLink & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_nextLink >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_myList)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _myList);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_myList)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l26;
		}
		if (_nextLink & (tagMask())) {
			goto l26;
		}
		if (!(_myList >= 0x20000000000LL)) {
			goto l26;
		}
		if (_nextLink >= 0x20000000000LL) {
			goto l26;
		}
		if ((_nextLink >= GIV(nilObj)) && (_nextLink <= GIV(trueObj))) {
			goto l26;
		}
		if (!(_nextLink >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l26;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _myList);
		l26:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_myList + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ), _nextLink);
		/* end storePointer:ofObject:withValue: */
		if (_process == _lastLink) {
			/* begin storePointerUnchecked:ofObject:withValue: */
			_valuePointer = GIV(nilObj);
			assert(!(isOopForwarded(_myList)));
			longAtput((_myList + BaseHeaderSize) + ((sqInt) (((usqInt) LastLinkIndex ) << (shiftForWord())) ), _valuePointer);
			/* end storePointerUnchecked:ofObject:withValue: */
		}
	} else {
		_tempLink = _firstLink;
		while (1) {
			assert(!(isForwarded(_tempLink)));
			if (_tempLink == GIV(nilObj)) {
				/* begin primitiveFail */
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
				/* end primitiveFail */
				goto l27;
			}
			/* begin fetchPointer:ofObject: */
			_nextLink = unsignedLongAt((_tempLink + BaseHeaderSize) + ((sqInt) (((usqInt) NextLinkIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (_nextLink == _process) 
				break;
			/* begin fetchPointer:ofObject: */
			_tempLink = unsignedLongAt((_tempLink + BaseHeaderSize) + ((sqInt) (((usqInt) NextLinkIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
		}
		/* begin fetchPointer:ofObject: */
		_nextLink = unsignedLongAt((_process + BaseHeaderSize) + ((sqInt) (((usqInt) NextLinkIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_tempLink)));
		if (((_tempLink & (tagMask())) == 0) && ((_tempLink & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_nextLink & (tagMask())) == 0) && (((_nextLink & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_nextLink >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_tempLink)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _tempLink);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_tempLink)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l13;
		}
		if (_nextLink & (tagMask())) {
			goto l13;
		}
		if (!(_tempLink >= 0x20000000000LL)) {
			goto l13;
		}
		if (_nextLink >= 0x20000000000LL) {
			goto l13;
		}
		if ((_nextLink >= GIV(nilObj)) && (_nextLink <= GIV(trueObj))) {
			goto l13;
		}
		if (!(_nextLink >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l13;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _tempLink);
		l13:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_tempLink + BaseHeaderSize) + ((sqInt) (((usqInt) NextLinkIndex ) << (shiftForWord())) ), _nextLink);
		/* end storePointer:ofObject:withValue: */
		if (_process == _lastLink) {
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(_myList)));
			if (((_myList & (tagMask())) == 0) && ((_myList & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((_tempLink & (tagMask())) == 0) && (((_tempLink & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_tempLink >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(_myList)) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), _myList);
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(_myList)) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l23;
			}
			if (_tempLink & (tagMask())) {
				goto l23;
			}
			if (!(_myList >= 0x20000000000LL)) {
				goto l23;
			}
			if (_tempLink >= 0x20000000000LL) {
				goto l23;
			}
			if ((_tempLink >= GIV(nilObj)) && (_tempLink <= GIV(trueObj))) {
				goto l23;
			}
			if (!(_tempLink >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l23;
			}
			remember(getFromPermToNewSpaceRememberedSet(), _myList);
			l23:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((_myList + BaseHeaderSize) + ((sqInt) (((usqInt) LastLinkIndex ) << (shiftForWord())) ), _tempLink);
			/* end storePointer:ofObject:withValue: */
		}
	}
	/* begin storePointer:ofObject:withValue: */
	assert(!(isForwarded(_process)));
	if (((_process & (tagMask())) == 0) && ((_process & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((GIV(nilObj) & (tagMask())) == 0) && (((GIV(nilObj) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (GIV(nilObj) >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_process)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _process);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(_process)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l15;
	}
	if (GIV(nilObj) & (tagMask())) {
		goto l15;
	}
	if (!(_process >= 0x20000000000LL)) {
		goto l15;
	}
	if (GIV(nilObj) >= 0x20000000000LL) {
		goto l15;
	}
	if ((GIV(nilObj) >= GIV(nilObj)) && (GIV(nilObj) <= GIV(trueObj))) {
		goto l15;
	}
	if (!(GIV(nilObj) >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l15;
	}
	remember(getFromPermToNewSpaceRememberedSet(), _process);
	l15:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((_process + BaseHeaderSize) + ((sqInt) (((usqInt) NextLinkIndex ) << (shiftForWord())) ), GIV(nilObj));
	/* end storePointer:ofObject:withValue: */
	l27:
	;
	/* end removeProcess:fromList: */
	if (!GIV(primFailCode)) {
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_process)));
		if (((_process & (tagMask())) == 0) && ((_process & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((GIV(nilObj) & (tagMask())) == 0) && (((GIV(nilObj) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (GIV(nilObj) >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_process)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _process);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_process)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l10;
		}
		if (GIV(nilObj) & (tagMask())) {
			goto l10;
		}
		if (!(_process >= 0x20000000000LL)) {
			goto l10;
		}
		if (GIV(nilObj) >= 0x20000000000LL) {
			goto l10;
		}
		if ((GIV(nilObj) >= GIV(nilObj)) && (GIV(nilObj) <= GIV(trueObj))) {
			goto l10;
		}
		if (!(GIV(nilObj) >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l10;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _process);
		l10:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_process + BaseHeaderSize) + ((sqInt) (((usqInt) MyListIndex ) << (shiftForWord())) ), GIV(nilObj));
		/* end storePointer:ofObject:withValue: */
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp2 = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), _myList);
		GIV(stackPointer) = _sp2;
		/* end pop:thenPush: */
	}
}
/*	primitively do the equivalent of Process>>yield */
/* StackInterpreter>>#primitiveYield */
static void
primitiveYield(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeProc;
	sqInt _inInterpreter;
	sqInt _objOop;
	sqInt _oop;
	sqInt _priority;
	sqInt _processList;
	sqInt _processLists;
	sqInt _scheduler;

	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	_scheduler = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	_activeProc = unsignedLongAt((_scheduler + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* begin quickFetchInteger:ofObject: */
	/* begin fetchPointer:ofObject: */
	_oop = unsignedLongAt((_activeProc + BaseHeaderSize) + ((sqInt) (((usqInt) PriorityIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(((_oop & 7) == 1));
	_priority = _oop >> 3;
	/* end quickFetchInteger:ofObject: */
	/* begin fetchPointer:ofObject: */
	_processLists = unsignedLongAt((_scheduler + BaseHeaderSize) + ((sqInt) (((usqInt) ProcessListsIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	_processList = unsignedLongAt((_processLists + BaseHeaderSize) + ((sqInt) (((usqInt) (_priority - 1) ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if ((assert(!(isForwarded(_processList))), (unsignedLongAt((_processList + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ))) == GIV(nilObj))) {
		{
			return;
		}
	}
	_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	addLastLinktoList(_activeProc, _processList);
	transferTofrom(wakeHighestPriority(), CSYield);
	/* begin forProcessPrimitiveReturnToExecutivePostContextSwitch: */
	if (GIV(nextProfileTick) > 0) {
		checkProfileTick(GIV(newMethod));
	}
	returnToExecutivepostContextSwitch(_inInterpreter, 1);
	/* end forProcessPrimitiveReturnToExecutivePostContextSwitch: */
}
/* StackInterpreter>>#printActivationNameForSelector:startClass: */
static void NoDbgRegParms
printActivationNameForSelectorstartClass(sqInt _aSelector, sqInt _startClass)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classDict;
	usqInt _classDictSize;
	sqInt _currClass;
	sqInt _i;
	sqInt _methClass;
	usqInt _numSlots;
	sqInt _objOop;

	if (addressCouldBeObj(_startClass)) {
		/* begin findClassForSelector:lookupClass:do: */
		_currClass = _startClass;
		do {
			/* begin fetchPointer:ofObject: */
			_classDict = unsignedLongAt((_currClass + BaseHeaderSize) + ((sqInt) (((usqInt) MethodDictionaryIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			/* begin numSlotsOf: */
			assert((classIndexOf(_classDict)) > (isForwardedObjectClassIndexPun()));
			_numSlots = byteAt(_classDict + 7);
			_classDictSize = ((_numSlots == (numSlotsMask()))
				 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_classDict - BaseHeaderSize)) ) << 8) ) ) ) >> 8
				 : _numSlots);
			/* end numSlotsOf: */
			_i = SelectorStart;
			while (_i < _classDictSize) {
				if (_aSelector == (unsignedLongAt((_classDict + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )))) {
					{
						_methClass = _currClass;
					}
					goto l6;
				}
				_i += 1;
			}
			/* begin followField:ofObject: */
			/* begin fetchPointer:ofObject: */
			_objOop = unsignedLongAt((_currClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				_objOop = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _currClass, _objOop);
			}
			_currClass = _objOop;
			/* end followField:ofObject: */
		} while (!(_currClass == GIV(nilObj)));
		{
			_methClass = null;
		}
		l6:
		;
		/* end findClassForSelector:lookupClass:do: */
		if ((_methClass == null) || (_startClass == _methClass)) {
			printNameOfClasscount(_methClass, 5);
			printChar('>');
			if (!_methClass) {
				printStringOf(splObj(SelectorDoesNotUnderstand));
				print(" ");
			}
		} else {
			printNameOfClasscount(_startClass, 5);
			printChar('(');
			printNameOfClasscount(_methClass, 5);
			printChar(')');
			printChar('>');
		}
	} else {
		print("INVALID CLASS");
	}
	if ((_aSelector & (tagMask())) || (addressCouldBeObj(_aSelector))) {
		if (((_aSelector & (tagMask())) == 0) && (((((usqInt) (longAt(_aSelector)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat()))) {
			printStringOf(_aSelector);
		}
 else {
			printOopShort(_aSelector);
		}
	} else {
		print("INVALID SELECTOR");
	}
}
/* StackInterpreter>>#printActivationNameFor:receiver:isBlock:firstTemporary: */
static void NoDbgRegParms
printActivationNameForreceiverisBlockfirstTemporary(sqInt _aMethod, sqInt _anObject, sqInt _isBlock, sqInt _maybeMessage)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classObj;
	sqInt _methClass;
	sqInt _methodSel;
	sqInt _rclass;
	sqInt _tagBits;
	sqInt _tagBits2;

	if (_isBlock) {
		print("[] in ");
	}
	/* begin findClassOfMethod:forReceiver: */
	if (((_anObject & (tagMask())) || (addressCouldBeObj(_anObject))) && (!(((_anObject & (tagMask())) == 0) && (((long64At(_anObject)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)))) {
		_rclass = findClassContainingMethodstartingAt(_aMethod, ((((_tagBits2 = _anObject & (tagMask()))) != 0)
			 ? unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits2 ) << (shiftForWord())) ))
			 : fetchClassOfNonImm(_anObject)));
		if (_rclass != GIV(nilObj)) {
			_methClass = _rclass;
			goto l3;
		}
	}
	if (!((addressCouldBeObj(_aMethod)) && (((((usqInt) (longAt(_aMethod)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())))) {
		/* begin nilObject */
		_methClass = GIV(nilObj);
		goto l3;
		/* end nilObject */
	}
	_methClass = findClassContainingMethodstartingAt(_aMethod, safeMethodClassOf(_aMethod));
	l3:
	;
	/* end findClassOfMethod:forReceiver: */
	_methodSel = findSelectorOfMethod(_aMethod);
	if (((_anObject & (tagMask())) || (addressCouldBeObj(_anObject))) && ((!(((_anObject & (tagMask())) == 0) && (((long64At(_anObject)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))) && (addressCouldBeClassObj((_classObj = ((((_tagBits = _anObject & (tagMask()))) != 0)
		 ? unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) ))
		 : fetchClassOfNonImm(_anObject))))))) {
		if ((_classObj == _methClass) || ((_methClass == null) || (_methClass == GIV(nilObj)))) {
			printNameOfClasscount(_classObj, 5);
		} else {
			printNameOfClasscount(_classObj, 5);
			print("(");
			printNameOfClasscount(_methClass, 5);
			print(")");
		}
	} else {
		print("INVALID RECEIVER");
	}
	print(">");
	if ((_methodSel & (tagMask())) || (addressCouldBeObj(_methodSel))) {
		if (_methodSel == GIV(nilObj)) {
			print("(nil)");
		}
 else {
			printStringOf(_methodSel);
		}
	} else {
		print("INVALID SELECTOR");
	}
	if ((_methodSel == (splObj(SelectorDoesNotUnderstand))) && ((addressCouldBeObj(_maybeMessage)) && ((fetchClassOfNonImm(_maybeMessage)) == (splObj(ClassMessage))))) {
		/* begin fetchPointer:ofObject: */
		_methodSel = unsignedLongAt((_maybeMessage + BaseHeaderSize) + ((sqInt) (((usqInt) MessageSelectorIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		print(" ");
		printStringOf(_methodSel);
	}
}
/* StackInterpreter>>#printAllPermanentObjects */
void
printAllPermanentObjects(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _currentObject;
	sqInt _followingWord;
	usqInt _followingWordAddress;

	{
		print("Permanent Objects");
		/* begin cr */
		print("\n");
		/* end cr */
	}
	{
		print("-----------------");
		/* begin cr */
		print("\n");
		/* end cr */
		/* begin cr */
		print("\n");
		/* end cr */
	}
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				{
					longPrintOop(_currentObject);
					/* begin cr */
					print("\n");
					/* end cr */
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_currentObject = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
}
/*	Print all the stacks of all running processes, including those that are 
	currently suspended. */
/* StackInterpreter>>#printAllStacks */
void
printAllStacks(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _classIdx;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	usqInt _limit;
	sqInt _limit2;
	sqInt _mutexClass;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots3;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _objOop3;
	sqInt _objOop4;
	sqInt _objOop5;
	usqInt _p;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;
	sqInt _pri;
	sqInt _proc;
	sqInt _processList;
	sqInt _schedLists;
	sqInt _semaphoreClass;
	sqInt _tagBits;

	/* begin memoryActiveProcess */
	/* begin fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	_objOop3 = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	_proc = unsignedLongAt((_objOop3 + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end memoryActiveProcess */
	{
		printNameOfClasscount(((((_tagBits = _proc & (tagMask()))) != 0)
			 ? unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) ))
			 : fetchClassOfNonImm(_proc)), 5);
		/* begin space */
		printChar(' ');
		/* end space */
		printHex(_proc);
	}
	{
		print(" priority ");
		printNum(quickFetchIntegerofObject(PriorityIndex, _proc));
		/* begin cr */
		print("\n");
		/* end cr */
	}
	printCallStackFP(GIV(framePointer));
	/* begin fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_objOop4 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	_objOop = unsignedLongAt((_objOop4 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	_schedLists = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ProcessListsIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (GIV(highestRunnableProcessPriority) == 0) {
		/* begin numSlotsOf: */
		assert((classIndexOf(_schedLists)) > (isForwardedObjectClassIndexPun()));
		_numSlots = byteAt(_schedLists + 7);
		_p = ((_numSlots == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_schedLists - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots);
		/* end numSlotsOf: */
	} else {
		_p = GIV(highestRunnableProcessPriority);
	}
	for (_pri = _p - 1; _pri >= 0; _pri += -1) {
		/* begin fetchPointer:ofObject: */
		_processList = unsignedLongAt((_schedLists + BaseHeaderSize) + ((sqInt) (((usqInt) _pri ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (!((assert(!(isForwarded(_processList))), (unsignedLongAt((_processList + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ))) == GIV(nilObj)))) {
			{
				/* begin cr */
				print("\n");
				/* end cr */
				print("processes at priority ");
				printNum(_pri + 1);
			}
			printProcsOnList(_processList);
		}
	}
	{
		/* begin cr */
		print("\n");
		/* end cr */
		print("suspended processes");
	}
	/* begin fetchPointer:ofObject: */
	_semaphoreClass = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassSemaphore ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	_mutexClass = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassMutex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	_semaphoreClass = ((!(_semaphoreClass == GIV(nilObj)))
		 ? (assert((rawHashBitsOf(_semaphoreClass)) != 0), (uint32AtPointer(_semaphoreClass + 4)) & (identityHashHalfWordMask()))
		 : 0);
	_mutexClass = ((!(_mutexClass == GIV(nilObj)))
		 ? (assert((rawHashBitsOf(_mutexClass)) != 0), (uint32AtPointer(_mutexClass + 4)) & (identityHashHalfWordMask()))
		 : 0);
	/* begin allHeapEntitiesDo: */
	/* begin allOldSpaceEntitiesDo: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop22 = GIV(nilObj);
	while (1) {
		assert((_objOop22 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop22)) != 0);
		{
			/* begin classIndexOf: */
			_classIdx = (longAt(_objOop22)) & (classIndexMask());
			/* end classIndexOf: */
			if (((_semaphoreClass != null) && (_classIdx == _semaphoreClass)) || ((_mutexClass != null) && (_classIdx == _mutexClass))) {
				printProcsOnList(_objOop22);
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop22 = _limit2;
			goto l18;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l18:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceEntitiesDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots3 = byteAt(_address + 7);
	_objOop5 = ((_numSlots3 == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop5, _limit)) {
		{
			/* begin classIndexOf: */
			_classIdx = (longAt(_objOop5)) & (classIndexMask());
			/* end classIndexOf: */
			if (((_semaphoreClass != null) && (_classIdx == _semaphoreClass)) || ((_mutexClass != null) && (_classIdx == _mutexClass))) {
				printProcsOnList(_objOop5);
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop5;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop5);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop5 = _limit;
			goto l17;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop5 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l17:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop5 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop5, GIV(freeStart))) {
		{
			/* begin classIndexOf: */
			_classIdx = (longAt(_objOop5)) & (classIndexMask());
			/* end classIndexOf: */
			if (((_semaphoreClass != null) && (_classIdx == _semaphoreClass)) || ((_mutexClass != null) && (_classIdx == _mutexClass))) {
				printProcsOnList(_objOop5);
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop5;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop5);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop5 = GIV(freeStart);
			goto l20;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop5 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l20:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				/* begin classIndexOf: */
				_classIdx = (longAt(_currentObject)) & (classIndexMask());
				/* end classIndexOf: */
				if (((_semaphoreClass != null) && (_classIdx == _semaphoreClass)) || ((_mutexClass != null) && (_classIdx == _mutexClass))) {
					printProcsOnList(_currentObject);
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l21;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l21:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allHeapEntitiesDo: */
}
/* StackInterpreter>>#printCallStack */
void
printCallStack(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin resetStackPrintedCount */
	GIV(printedStackFrames) = (GIV(maxStackMessagePrinted) = 0);
	/* end resetStackPrintedCount */
	if (GIV(framePointer) == null) {
		printCallStackOf(fetchPointerofObject(SuspendedContextIndex, memoryActiveProcess()));
	}
 else {
		printCallStackFP(GIV(framePointer));
	}
}
/* StackInterpreter>>#printCallStackFP: */
static sqInt NoDbgRegParms
printCallStackFP(char *_theFP)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _context;

	/* begin resetStackPrintedCount */
	GIV(printedStackFrames) = (GIV(maxStackMessagePrinted) = 0);
	/* end resetStackPrintedCount */
	_context = shortReversePrintFrameAndCallers(_theFP);
	while (!(_context == GIV(nilObj))) {
		if ((((unsignedLongAt((_context + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
			if (!(checkIsStillMarriedContextcurrentFP(_context, GIV(framePointer)))) {
				shortPrintContext(_context);
				return null;
			}
			_context = shortReversePrintFrameAndCallers(frameOfMarriedContext(_context));
		} else {
			_context = printContextCallStackOf(_context);
		}
	}
	return 0;
}
/* StackInterpreter>>#printCallStackOf: */
sqInt
printCallStackOf(sqInt _aContextOrProcessOrFrame)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _context;

	/* begin resetStackPrintedCount */
	GIV(printedStackFrames) = (GIV(maxStackMessagePrinted) = 0);
	/* end resetStackPrintedCount */
	if (((((usqInt) _aContextOrProcessOrFrame ) & (BytesPerWord - 1)) == 0) && ((((usqInt) _aContextOrProcessOrFrame ) >= ((usqInt) (GIV(stackBasePlus1) - 1) )) && (((usqInt) _aContextOrProcessOrFrame ) <= ((usqInt) GIV(pages) )))) {
		return printCallStackFP(((char *) _aContextOrProcessOrFrame ));
	}
	if (couldBeProcess(_aContextOrProcessOrFrame)) {
		return printCallStackOf(unsignedLongAt((_aContextOrProcessOrFrame + BaseHeaderSize) + ((sqInt) (((usqInt) SuspendedContextIndex ) << (shiftForWord())) )));
	}
	_context = _aContextOrProcessOrFrame;
	while (!(_context == GIV(nilObj))) {
		if ((((unsignedLongAt((_context + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
			if (!(checkIsStillMarriedContextcurrentFP(_context, GIV(framePointer)))) {
				shortPrintContext(_context);
				return null;
			}
			_context = shortReversePrintFrameAndCallers(frameOfMarriedContext(_context));
		} else {
			_context = printContextCallStackOf(_context);
		}
	}
	return 0;
}
/* StackInterpreter>>#printCallStackOf:currentFP: */
static sqInt NoDbgRegParms
printCallStackOfcurrentFP(sqInt _aContext, char *_currFP)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _callerContextOrNil;
	sqInt _ctxt;
	sqInt _referent;
	sqInt _senderOop;
	char *_theFP;
	StackPage *_thePage;
	StackPage *_thePage2;

	/* begin resetStackPrintedCount */
	GIV(printedStackFrames) = (GIV(maxStackMessagePrinted) = 0);
	/* end resetStackPrintedCount */
	_ctxt = _aContext;
	while (!(_ctxt == GIV(nilObj))) {
		if ((((unsignedLongAt((_ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
			/* begin frameOfMarriedContext: */
			/* begin fetchPointer:ofObject: */
			_senderOop = unsignedLongAt((_ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			{
				assert(((_senderOop & 7) == 1));
				_theFP = pointerForOop(_senderOop - 1);
			}
			/* end frameOfMarriedContext: */
			if (checkIsStillMarriedContextcurrentFP(_ctxt, _currFP)) {
				/* begin stackPageFor: */
				/* begin stackPageAt: */
				_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
				/* end stackPageAt: */
				/* end stackPageFor: */
				if (((_thePage->baseFP)) == 0) {
					{
						/* begin printHexPtr: */
						printHex(oopForPointer(_theFP));
						/* end printHexPtr: */
						print(" is on a free page?!");
						/* begin cr */
						print("\n");
						/* end cr */
					}
					return null;
				}
				shortPrintFrameAndCallers(_theFP);
				_theFP = (_thePage->baseFP);
				/* begin frameCallerContext: */
				assert(isBaseFrame(_theFP));
				/* begin stackPageFor: */
				/* begin stackPageAt: */
				_thePage2 = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
				/* end stackPageAt: */
				/* end stackPageFor: */
				_callerContextOrNil = unsignedLongAt((_thePage2->baseAddress));
				assert(addressCouldBeObj(_callerContextOrNil));
				assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
				_ctxt = _callerContextOrNil;
				/* end frameCallerContext: */
				if (((long64At(_ctxt)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					/* begin followForwarded: */
					assert(isUnambiguouslyForwarder(_ctxt));
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent = unsignedLongAt((_ctxt + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
					while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
					}
					_ctxt = _referent;
					/* end followForwarded: */
				}
			} else {
				{
					print("widowed caller frame ");
					/* begin printHexPtr: */
					printHex(oopForPointer(_theFP));
					/* end printHexPtr: */
					/* begin cr */
					print("\n");
					/* end cr */
				}
				return null;
			}
		} else {
			shortPrintContext(_ctxt);
			/* begin fetchPointer:ofObject: */
			_ctxt = unsignedLongAt((_ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
		}
	}
	return 0;
}
/*	For testing in Smalltalk, this method should be overridden in a subclass. */
/* StackInterpreter>>#printChar: */
void
printChar(sqInt _aByte)
{
	vm_printf("%c", _aByte);
}
/*	Print the call stack of aContext until it links to a frame. */
/* StackInterpreter>>#printContextCallStackOf: */
static sqInt NoDbgRegParms
printContextCallStackOf(sqInt _aContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _ctxt;

	_ctxt = _aContext;
	while (!((_ctxt == GIV(nilObj)) || ((((unsignedLongAt((_ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)))) {
		shortPrintContext(_ctxt);
		/* begin fetchPointer:ofObject: */
		_ctxt = unsignedLongAt((_ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
	}
	return _ctxt;
}
/* StackInterpreter>>#printContext: */
void
printContext(sqInt _aContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _ip;
	sqInt _meth;
	sqInt _sender;
	sqInt _sp;

	shortPrintContext(_aContext);
	/* begin fetchPointer:ofObject: */
	_sender = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	_ip = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_sender & 7) == 1)) {
		if (checkIsStillMarriedContextcurrentFP(_aContext, GIV(framePointer))) {
			{
				print("married (assuming framePointer valid)");
				/* begin cr */
				print("\n");
				/* end cr */
			}
		}
 else {
			{
				print("widowed (assuming framePointer valid)");
				/* begin cr */
				print("\n");
				/* end cr */
			}
		}
		{
			print("sender   ");
			printNum(_sender);
			print(" (");
			/* begin printHexPtr: */
			printHex(oopForPointer((assert(((_sender & 7) == 1)), pointerForOop(_sender - 1))));
			/* end printHexPtr: */
			printChar(')');
			/* begin cr */
			print("\n");
			/* end cr */
		}
		{
			print("ip       ");
			printNum(_ip);
			print(" (");
			/* begin printHexPtr: */
			printHex(oopForPointer((assert(((_ip & 7) == 1)), pointerForOop(_ip - 1))));
			/* end printHexPtr: */
			printChar(')');
			/* begin cr */
			print("\n");
			/* end cr */
		}
	} else {
		{
			print("sender   ");
			shortPrintOop(_sender);
		}
		print("ip       ");
		if (_ip == GIV(nilObj)) {
			shortPrintOop(_ip);
		} else {
			{
				printNum(_ip);
				print(" (");
				printNum(_ip >> 3);
				/* begin space */
				printChar(' ');
				/* end space */
				printHex(_ip >> 3);
				printChar(')');
				/* begin cr */
				print("\n");
				/* end cr */
			}
		}
	}
	/* begin fetchPointer:ofObject: */
	_sp = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	_sp = ((_sp < ((lengthOfformat(_aContext, (((usqInt) (longAt(_aContext)) ) >> (formatShift())) & (formatMask()))) - ReceiverIndex)) ? _sp : (lengthOfformat(_aContext, (((usqInt) (longAt(_aContext)) ) >> (formatShift())) & (formatMask()))) - ReceiverIndex);
	{
		print("sp       ");
		printNum(_sp);
		print(" (");
		printNum(_sp >> 3);
		printChar(')');
		/* begin cr */
		print("\n");
		/* end cr */
	}
	{
		print("method   ");
		/* begin printMethodFieldForPrintContext: */
		_meth = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ));
		shortPrintOop(_meth);
		if ((assert(isNonImmediate(_meth)), isCogMethodReference(unsignedLongAt((_meth + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ))))) {
			{
				/* begin space */
				printChar(' ');
				/* end space */
				printHexnp(cogMethodOf(_meth));
			}
		}
		/* end printMethodFieldForPrintContext: */
	}
	{
		print("closure  ");
		shortPrintOop(unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ClosureIndex ) << (shiftForWord())) )));
	}
	{
		print("receiver ");
		shortPrintOop(unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ReceiverIndex ) << (shiftForWord())) )));
	}
	_sp = _sp >> 3;
	for (_i = 1; _i <= _sp; _i += 1) {
		{
			print("       ");
			printNum(_i);
			/* begin space */
			printChar(' ');
			/* end space */
			shortPrintOop(unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) (ReceiverIndex + _i) ) << (shiftForWord())) )));
		}
	}
}
/* StackInterpreter>>#printDecodeMethodHeaderOop: */
static void NoDbgRegParms
printDecodeMethodHeaderOop(sqInt _methodHeaderOop)
{
	printOopShort(_methodHeaderOop);
	if (methodHeaderHasPrimitive(_methodHeaderOop)) {
		print(" hasPrim");
	}
	if ((_methodHeaderOop & LargeContextBit) != 0) {
		print(" largeFrame");
	}
	{
		print(" nLits ");
		printNum((assert(((_methodHeaderOop & 7) == 1)), (_methodHeaderOop >> 3) & AlternateHeaderNumLiteralsMask));
		print(" nArgs ");
		printNum((((usqInt) _methodHeaderOop ) >> MethodHeaderArgCountShift) & 15);
		print(" nTemps ");
		printNum((((usqInt) _methodHeaderOop ) >> MethodHeaderTempCountShift) & 0x3F);
	}
}
/* StackInterpreter>>#printExternalHeadFrame */
void
printExternalHeadFrame(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	printFrameWithSP(GIV(framePointer), GIV(stackPointer));
}
/* StackInterpreter>>#printFrameAndCallers:SP:short: */
static sqInt NoDbgRegParms
printFrameAndCallersSPshort(char *_theFP, char *_theSP, sqInt _printShort)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (!(((((usqInt) _theFP ) & (BytesPerWord - 1)) == 0) && ((((usqInt) _theFP ) >= ((usqInt) (GIV(stackBasePlus1) - 1) )) && (((usqInt) _theFP ) <= ((usqInt) GIV(pages) ))))) {
		return null;
	}
	if (!((unsignedLongAt(_theFP + FoxSavedFP)) == 0)) {
		printFrameAndCallersSPshort(pointerForOop(unsignedLongAt(_theFP + FoxSavedFP)), (assert(!(isBaseFrame(_theFP))), (_theFP + (frameStackedReceiverOffsetNumArgs(((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
			 : byteAt((_theFP + FoxIFrameFlags) + 1))))) + BytesPerWord), _printShort);
	}
	if (_printShort) {
		shortPrintFrame(_theFP);
		return null;
	}
	/* begin cr */
	print("\n");
	/* end cr */
	printFrameWithSP(_theFP, _theSP);
	return 0;
}
/* StackInterpreter>>#printFrameOop:at: */
static void NoDbgRegParms
printFrameOopat(char *_name, char *_address)
{
	sqInt _i;
	sqInt _iLimit;
	sqInt _it;

	_it = unsignedLongAt(_address);
	{
		/* begin printHexPtr: */
		printHex(oopForPointer(_address));
		/* end printHexPtr: */
		printChar(':');
	}
	for (_i = 1, _iLimit = 12 - (strlen(_name)); _i <= _iLimit; _i += 1) {
		printChar(' ');
	}
	{
		print(_name);
		print(": ");
		printHex(_it);
		/* begin tab */
		printChar('	');
		/* end tab */
		printChar('=');
		printOopShort(_it);
		/* begin cr */
		print("\n");
		/* end cr */
	}
}
/* StackInterpreter>>#printFrameOop:index:at: */
static void NoDbgRegParms
printFrameOopindexat(char *_name, sqInt _idx, char *_address)
{
	sqInt _i;
	sqInt _iLimit;
	sqInt _it;

	_it = unsignedLongAt(_address);
	{
		/* begin printHexPtr: */
		printHex(oopForPointer(_address));
		/* end printHexPtr: */
		printChar(':');
	}
	for (_i = 1, _iLimit = (11 - (strlen(_name))) - (floor(log10(((_idx < 1) ? 1 : _idx)))); _i <= _iLimit; _i += 1) {
		printChar(' ');
	}
	{
		print(_name);
		printNum(_idx);
		print(": ");
		printHex(_it);
		/* begin tab */
		printChar('	');
		/* end tab */
		printChar('=');
		printOopShort(_it);
		/* begin cr */
		print("\n");
		/* end cr */
	}
}
/*	use export: not api, so it won't be written to cointerp.h. cogit.c is 
	unaware of StackPage */
/* StackInterpreter>>#printFramesInPage: */
EXPORT(void)
printFramesInPage(StackPage *_thePage)
{
	printFrameAndCallersSPshort((_thePage->headFP), (_thePage->headSP), 0);
}
/* StackInterpreter>>#printFramesOnStackPageListInUse */
EXPORT(void)
printFramesOnStackPageListInUse(void)
{
	StackPage *_page;

	_page = mostRecentlyUsedPage();
	do {
		if (!(((_page->baseFP)) == 0)) {
			{
				print("page ");
				/* begin printHexPtrnp: */
				printHexnp(oopForPointer(_page));
				/* end printHexPtrnp: */
				/* begin cr */
				print("\n");
				/* end cr */
			}
			printFramesInPage(_page);
			/* begin cr */
			print("\n");
			/* end cr */
		}
	} while (((_page = (_page->prevPage))) != (mostRecentlyUsedPage()));
}
/* StackInterpreter>>#printFrameThing:andFrame:at: */
static void NoDbgRegParms
printFrameThingandFrameat(char *_name, char *_theFP, char *_address)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _it;
	sqInt _len;

	_it = unsignedLongAt(_address);
	{
		/* begin printHexPtr: */
		printHex(oopForPointer(_address));
		/* end printHexPtr: */
		printChar(':');
	}
	_len = strlen(_name);
	for (_i = 1; _i <= (12 - _len); _i += 1) {
		/* begin space */
		printChar(' ');
		/* end space */
	}
	{
		print(_name);
		print(": ");
		printHex(_it);
	}
	if (_it != 0) {
		printChar('=');
		if (_it == GIV(nilObj)) {
			print("nil");
		}
 else {
			printNum(_it);
		}
	}
	{
		print(" frame: ");
		/* begin printHexPtr: */
		printHex(oopForPointer(_theFP));
		/* end printHexPtr: */
		/* begin cr */
		print("\n");
		/* end cr */
	}
}
/* StackInterpreter>>#printFrameThing:at: */
static void NoDbgRegParms
printFrameThingat(char *_name, char *_address)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _it;
	sqInt _len;

	_it = unsignedLongAt(_address);
	{
		/* begin printHexPtr: */
		printHex(oopForPointer(_address));
		/* end printHexPtr: */
		printChar(':');
	}
	_len = strlen(_name);
	for (_i = 1; _i <= (12 - _len); _i += 1) {
		/* begin space */
		printChar(' ');
		/* end space */
	}
	{
		print(_name);
		print(": ");
		printHex(_it);
	}
	if (_it != 0) {
		printChar('=');
		if (_it == GIV(nilObj)) {
			print("nil");
		}
 else {
			printNum(_it);
		}
	}
	/* begin cr */
	print("\n");
	/* end cr */
}
/* StackInterpreter>>#printFrameThing:at:extraString: */
static void NoDbgRegParms
printFrameThingatextraString(char *_name, char *_address, char *_extraStringOrNil)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _it;
	sqInt _len;

	_it = longAt(_address);
	{
		/* begin printHexPtr: */
		printHex(oopForPointer(_address));
		/* end printHexPtr: */
		printChar(':');
	}
	_len = strlen(_name);
	for (_i = 1; _i <= (12 - _len); _i += 1) {
		/* begin space */
		printChar(' ');
		/* end space */
	}
	{
		print(_name);
		print(": ");
		printHex(_it);
	}
	if (_it != 0) {
		printChar('=');
		if (_it == GIV(nilObj)) {
			print("nil");
		}
 else {
			printNum(_it);
		}
	}
	if (_extraStringOrNil) {
		{
			/* begin space */
			printChar(' ');
			/* end space */
			print(_extraStringOrNil);
		}
	}
	/* begin cr */
	print("\n");
	/* end cr */
}
/* StackInterpreter>>#printFrameThing:at:extra: */
static void NoDbgRegParms
printFrameThingatextra(char *_name, char *_address, sqInt _extraValue)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _it;
	sqInt _len;

	_it = longAt(_address);
	{
		/* begin printHexPtr: */
		printHex(oopForPointer(_address));
		/* end printHexPtr: */
		printChar(':');
	}
	_len = strlen(_name);
	for (_i = 1; _i <= (12 - _len); _i += 1) {
		/* begin space */
		printChar(' ');
		/* end space */
	}
	{
		print(_name);
		print(": ");
		printHex(_it);
	}
	if (_it != 0) {
		printChar('=');
		if (_it == GIV(nilObj)) {
			print("nil");
		}
 else {
			printNum(_it);
		}
	}
	{
		/* begin space */
		printChar(' ');
		/* end space */
		printNum(_extraValue);
		/* begin cr */
		print("\n");
		/* end cr */
	}
}
/* StackInterpreter>>#printFrame: */
sqInt
printFrame(char *_theFP)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_aFrame;
	char *_frameAbove;
	char *_prevFrame;
	char *_startFrame;
	StackPage *_thePage;
	char *_theSP;

	if (!(((((usqInt) _theFP ) & (BytesPerWord - 1)) == 0) && ((((usqInt) _theFP ) >= ((usqInt) (GIV(stackBasePlus1) - 1) )) && (((usqInt) _theFP ) <= ((usqInt) GIV(pages) ))))) {
		if ((addressCouldBeObj(((sqInt) _theFP ))) && ((isInMemory(((sqInt) _theFP ))) && ((((longAt(((sqInt) _theFP ))) & (classIndexMask())) == ClassMethodContextCompactIndex) && (checkIsStillMarriedContextcurrentFP(((sqInt) _theFP ), GIV(framePointer)))))) {
			return printFrame(frameOfMarriedContext(((sqInt) _theFP )));
		}
		{
			/* begin printHexPtr: */
			printHex(oopForPointer(_theFP));
			/* end printHexPtr: */
			print(" is not in the stack zone?!");
			/* begin cr */
			print("\n");
			/* end cr */
		}
		return null;
	}
	_frameAbove = null;
	if (_theFP == GIV(framePointer)) {
		_theSP = GIV(stackPointer);
	} else {
		/* begin stackPageFor: */
		/* begin stackPageAt: */
		_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
		/* end stackPageAt: */
		/* end stackPageFor: */
		if (((_thePage->baseFP)) == 0) {
			{
				/* begin printHexPtr: */
				printHex(oopForPointer(_theFP));
				/* end printHexPtr: */
				print(" is on a free page?!");
				/* begin cr */
				print("\n");
				/* end cr */
			}
			return null;
		}
		if ((_thePage != GIV(stackPage)) && (_theFP == ((_thePage->headFP)))) {
			_theSP = (_thePage->headSP);
		} else {
			/* begin safeFindFrameAbove:on:startingFrom: */
			_startFrame = (((_thePage == GIV(stackPage)) && ((GIV(framePointer) >= ((_thePage->realStackLimit))) && (GIV(framePointer) <= ((_thePage->baseAddress)))))
				 ? GIV(framePointer)
				 : (_thePage->headFP));
			assert(!(isFree(_thePage)));
			if (_startFrame == _theFP) {
				_frameAbove = null;
				goto l5;
			}
			_aFrame = _startFrame;
			while (1) {
				_prevFrame = _aFrame;
				/* begin frameCallerFP: */
				_aFrame = pointerForOop(unsignedLongAt(_aFrame + FoxSavedFP));
				/* end frameCallerFP: */
				if (!(_aFrame != 0)) 
					break;
				if (_theFP == _aFrame) {
					_frameAbove = _prevFrame;
					goto l5;
				}
			}
			_frameAbove = null;
			l5:
			;
			/* end safeFindFrameAbove:on:startingFrom: */
			_theSP = ((_frameAbove)
				 ? (assert(!(isBaseFrame(_frameAbove))), (_frameAbove + (frameStackedReceiverOffsetNumArgs(((isMachineCodeIP(((usqInt) (unsignedLongAt(_frameAbove + FoxMethod)) )))
					 ? ((((CogMethod *) ((unsignedLongAt(_frameAbove + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
					 : byteAt((_frameAbove + FoxIFrameFlags) + 1))))) + BytesPerWord)
				 : 0);
		}
	}
	if (!_theSP) {
		{
			print("could not find sp; using bogus value");
			/* begin cr */
			print("\n");
			/* end cr */
		}
		_theSP = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? _theFP + FoxMFReceiver
			 : _theFP + FoxIFReceiver);
	}
	printFrameWithSP(_theFP, _theSP);
	if (_frameAbove) {
		printFrameThingat("frame pc", _frameAbove + FoxCallerSavedIP);
	}
	return 0;
}
/*	Print n in hex, in the form '1234', unpadded */
/* StackInterpreter>>#printHexnpnp: */
static sqInt NoDbgRegParms
printHexnpnp(usqInt _n)
{
	return vm_printf("%lx", _n);
}
/*	Print n in hex, in the form '0x1234', unpadded */
/* StackInterpreter>>#printHexnp: */
sqInt
printHexnp(usqInt _n)
{
	return vm_printf("0x%lx", _n);
}
/*	Print n in hex, in the form ' 0x1234', padded to a width of 10 characters 
	in 32-bits ('0x' + 8 nibbles) or 18 characters in 64-bits ('0x' + 16 
	nibbles)  */
/* StackInterpreter>>#printHex: */
void
printHex(usqInt n)
{
	char _buf[37];
	sqInt _len;

	memset(_buf,' ',36);
	_len = sprintf(_buf + 2 + 2 * BytesPerWord, "0x%" PRIxSQPTR, (usqIntptr_t)(n));
	vm_printf("%s", _buf + _len);
}
/*	Print all methods whose penultimate literal is either selector, 
	or an object whose first inst var is the method and whose 
	second is selector (e.g. an AdditionalMethodState). */
/* StackInterpreter>>#printLikelyImplementorsOfSelector: */
void
printLikelyImplementorsOfSelector(sqInt _selector)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _classLookupKey;
	sqInt _classOop;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	sqInt _i;
	usqInt _limit;
	sqInt _limit2;
	sqInt _methodClassAssociation;
	char *_name;
	sqInt _nameLen;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _objOop23;
	sqInt _offset;
	sqInt _oop;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;
	sqInt _tagBits;
	sqInt _theClass;

	/* begin allObjectsDo: */
	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop23 = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop23, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop23));
			{
				if ((((((usqInt) (longAt(_objOop23)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && ((maybeSelectorOfMethod(_objOop23)) == _selector)) {
					/* begin methodClassAssociationOf: */
					/* begin literal:ofMethod: */
					_offset = (literalCountOfMethodHeader(methodHeaderOf(_objOop23))) - 1;
					/* begin fetchPointer:ofObject: */
					_methodClassAssociation = unsignedLongAt((_objOop23 + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset + LiteralStart) ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					/* end literal:ofMethod: */
					/* end methodClassAssociationOf: */
					{
						printHexnp(_objOop23);
						/* begin space */
						printChar(' ');
						/* end space */
						/* begin printOopShortInner: */
						if ((((_methodClassAssociation & (tagMask())) == 0) && (((((usqInt) (longAt(_methodClassAssociation)) ) >> (formatShift())) & (formatMask())) <= 5)) && ((numSlotsOf(_methodClassAssociation)) >= 2)) {
							/* begin fetchPointer:ofObject: */
							_oop = unsignedLongAt((_methodClassAssociation + BaseHeaderSize) + (0U << (shiftForWord())));
							/* end fetchPointer:ofObject: */
						} else {
							_oop = _methodClassAssociation;
						}
						if (_oop & (tagMask())) {
							if (_oop & (characterTag())) {
								{
									printChar('$');
									printChar(((usqInt) ((usqInt) _oop ) ) >> (numTagBits()));
									printChar('(');
									printHexnp(((usqInt) ((usqInt) _oop ) ) >> (numTagBits()));
									printChar(')');
								}
								goto l23;
							}
							if (((_oop & 7) == 1)) {
								{
									printNum(_oop >> 3);
									printChar('(');
									printHexnp(_oop >> 3);
									printChar(')');
								}
								goto l23;
							}
							if (_oop & (smallFloatTag())) {
								{
									printFloat(dbgFloatValueOf(_oop));
									printChar('(');
									printHexnp(_oop);
									printChar(')');
								}
								goto l23;
							}
							{
								print("unknown immediate ");
								printHexnp(_oop);
							}
							goto l23;
						}
						if (!(addressCouldBeObj(_oop))) {
							print((((_oop & (8 - 1)) != 0)
								 ? " is misaligned"
								 : whereIs(_oop)));
							goto l23;
						}
						if (((longAt(_oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
							print(" is a free chunk");
							goto l23;
						}
						if (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
							{
								print(" is a forwarder to ");
								printHexnp(followForwarded(_oop));
							}
							goto l23;
						}
						if (((((_tagBits = _oop & (tagMask()))) != 0)
							 ? _tagBits == (smallFloatTag())
							 : ((longAt(_oop)) & (classIndexMask())) == ClassFloatCompactIndex)) {
							printFloat(dbgFloatValueOf(_oop));
							goto l23;
						}
						_classOop = fetchClassOfNonImm(_oop);
						if (!(addressCouldBeObj(_classOop))) {
							print("a ??");
							goto l23;
						}
						if ((numSlotsOf(_classOop)) == GIV(metaclassNumSlots)) {
							printNameOfClasscount(_oop, 5);
							goto l23;
						}
						if (_oop == GIV(nilObj)) {
							print("nil");
							goto l23;
						}
						if (_oop == GIV(trueObj)) {
							print("true");
							goto l23;
						}
						if (_oop == GIV(falseObj)) {
							print("false");
							goto l23;
						}
						_nameLen = lengthOfNameOfClass(_classOop);
						if (_nameLen == 0) {
							print("a ??");
							goto l23;
						}
						_name = nameOfClass(_classOop);
						if (_nameLen == 10) {
							if ((strncmp(_name, "ByteString", 10)) == 0) {
								{
									printChar('\'');
									printStringOf(_oop);
									printChar('\'');
								}
								goto l23;
							}
							if ((strncmp(_name, "ByteSymbol", 10)) == 0) {
								{
									printChar('#');
									printStringOf(_oop);
								}
								goto l23;
							}
						}
						if ((_nameLen == 9) && ((strncmp(_name, "Character", 9)) == 0)) {
							{
								printChar('$');
								printChar((unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())))) >> 3);
							}
							goto l23;
						}
						print("a(n) ");
						for (_i = 0; _i < _nameLen; _i += 1) {
							printChar(_name[_i]);
						}
						if ((((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) <= 5) && ((((assert(addressCouldBeClassObj(_classOop)), ((unsignedLongAt((_classOop + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3) & ((1U << (fixedFieldsFieldWidth())) - 1))) == (ValueIndex + 1)) && (isBytes(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) KeyIndex ) << (shiftForWord())) )))))) {
							_classLookupKey = fetchClassOfNonImm(splObj(SchedulerAssociation));
							while (1) {
								if (_classLookupKey == GIV(nilObj)) {
									goto l23;
								}
								if (((assert(addressCouldBeClassObj(_classLookupKey)), ((unsignedLongAt((_classLookupKey + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3) & ((1U << (fixedFieldsFieldWidth())) - 1))) == (KeyIndex + 1)) 
									break;
								/* begin followField:ofObject: */
								/* begin fetchPointer:ofObject: */
								_objOop = unsignedLongAt((_classLookupKey + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
									_objOop = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _classLookupKey, _objOop);
								}
								_classLookupKey = _objOop;
								/* end followField:ofObject: */
							}
							if (_classLookupKey == GIV(nilObj)) {
								goto l21;
							}
							_theClass = _classOop;
							while (1) {
								if (_theClass == _classLookupKey) {
									goto l22;
								}
								if (!(_theClass != GIV(nilObj))) 
									break;
								/* begin followField:ofObject: */
								/* begin fetchPointer:ofObject: */
								_objOop2 = unsignedLongAt((_theClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								if (((_objOop2 & (tagMask())) == 0) && (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
									_objOop2 = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _theClass, _objOop2);
								}
								_theClass = _objOop2;
								/* end followField:ofObject: */
							}
							l22:
							;
							{
								/* begin space */
								printChar(' ');
								/* end space */
								printOopShort(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) KeyIndex ) << (shiftForWord())) )));
								print(" -> ");
								printHexnp(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) )));
							}
							l21:
							;
						}
						l23:
						;
						/* end printOopShortInner: */
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop23;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop23);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop23 = _limit;
			goto l13;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop23 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l13:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop23 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop23, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop23));
			{
				if ((((((usqInt) (longAt(_objOop23)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && ((maybeSelectorOfMethod(_objOop23)) == _selector)) {
					/* begin methodClassAssociationOf: */
					/* begin literal:ofMethod: */
					_offset = (literalCountOfMethodHeader(methodHeaderOf(_objOop23))) - 1;
					/* begin fetchPointer:ofObject: */
					_methodClassAssociation = unsignedLongAt((_objOop23 + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset + LiteralStart) ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					/* end literal:ofMethod: */
					/* end methodClassAssociationOf: */
					{
						printHexnp(_objOop23);
						/* begin space */
						printChar(' ');
						/* end space */
						/* begin printOopShortInner: */
						if ((((_methodClassAssociation & (tagMask())) == 0) && (((((usqInt) (longAt(_methodClassAssociation)) ) >> (formatShift())) & (formatMask())) <= 5)) && ((numSlotsOf(_methodClassAssociation)) >= 2)) {
							/* begin fetchPointer:ofObject: */
							_oop = unsignedLongAt((_methodClassAssociation + BaseHeaderSize) + (0U << (shiftForWord())));
							/* end fetchPointer:ofObject: */
						} else {
							_oop = _methodClassAssociation;
						}
						if (_oop & (tagMask())) {
							if (_oop & (characterTag())) {
								{
									printChar('$');
									printChar(((usqInt) ((usqInt) _oop ) ) >> (numTagBits()));
									printChar('(');
									printHexnp(((usqInt) ((usqInt) _oop ) ) >> (numTagBits()));
									printChar(')');
								}
								goto l29;
							}
							if (((_oop & 7) == 1)) {
								{
									printNum(_oop >> 3);
									printChar('(');
									printHexnp(_oop >> 3);
									printChar(')');
								}
								goto l29;
							}
							if (_oop & (smallFloatTag())) {
								{
									printFloat(dbgFloatValueOf(_oop));
									printChar('(');
									printHexnp(_oop);
									printChar(')');
								}
								goto l29;
							}
							{
								print("unknown immediate ");
								printHexnp(_oop);
							}
							goto l29;
						}
						if (!(addressCouldBeObj(_oop))) {
							print((((_oop & (8 - 1)) != 0)
								 ? " is misaligned"
								 : whereIs(_oop)));
							goto l29;
						}
						if (((longAt(_oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
							print(" is a free chunk");
							goto l29;
						}
						if (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
							{
								print(" is a forwarder to ");
								printHexnp(followForwarded(_oop));
							}
							goto l29;
						}
						if (((((_tagBits = _oop & (tagMask()))) != 0)
							 ? _tagBits == (smallFloatTag())
							 : ((longAt(_oop)) & (classIndexMask())) == ClassFloatCompactIndex)) {
							printFloat(dbgFloatValueOf(_oop));
							goto l29;
						}
						_classOop = fetchClassOfNonImm(_oop);
						if (!(addressCouldBeObj(_classOop))) {
							print("a ??");
							goto l29;
						}
						if ((numSlotsOf(_classOop)) == GIV(metaclassNumSlots)) {
							printNameOfClasscount(_oop, 5);
							goto l29;
						}
						if (_oop == GIV(nilObj)) {
							print("nil");
							goto l29;
						}
						if (_oop == GIV(trueObj)) {
							print("true");
							goto l29;
						}
						if (_oop == GIV(falseObj)) {
							print("false");
							goto l29;
						}
						_nameLen = lengthOfNameOfClass(_classOop);
						if (_nameLen == 0) {
							print("a ??");
							goto l29;
						}
						_name = nameOfClass(_classOop);
						if (_nameLen == 10) {
							if ((strncmp(_name, "ByteString", 10)) == 0) {
								{
									printChar('\'');
									printStringOf(_oop);
									printChar('\'');
								}
								goto l29;
							}
							if ((strncmp(_name, "ByteSymbol", 10)) == 0) {
								{
									printChar('#');
									printStringOf(_oop);
								}
								goto l29;
							}
						}
						if ((_nameLen == 9) && ((strncmp(_name, "Character", 9)) == 0)) {
							{
								printChar('$');
								printChar((unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())))) >> 3);
							}
							goto l29;
						}
						print("a(n) ");
						for (_i = 0; _i < _nameLen; _i += 1) {
							printChar(_name[_i]);
						}
						if ((((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) <= 5) && ((((assert(addressCouldBeClassObj(_classOop)), ((unsignedLongAt((_classOop + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3) & ((1U << (fixedFieldsFieldWidth())) - 1))) == (ValueIndex + 1)) && (isBytes(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) KeyIndex ) << (shiftForWord())) )))))) {
							_classLookupKey = fetchClassOfNonImm(splObj(SchedulerAssociation));
							while (1) {
								if (_classLookupKey == GIV(nilObj)) {
									goto l29;
								}
								if (((assert(addressCouldBeClassObj(_classLookupKey)), ((unsignedLongAt((_classLookupKey + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3) & ((1U << (fixedFieldsFieldWidth())) - 1))) == (KeyIndex + 1)) 
									break;
								/* begin followField:ofObject: */
								/* begin fetchPointer:ofObject: */
								_objOop = unsignedLongAt((_classLookupKey + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
									_objOop = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _classLookupKey, _objOop);
								}
								_classLookupKey = _objOop;
								/* end followField:ofObject: */
							}
							if (_classLookupKey == GIV(nilObj)) {
								goto l27;
							}
							_theClass = _classOop;
							while (1) {
								if (_theClass == _classLookupKey) {
									goto l28;
								}
								if (!(_theClass != GIV(nilObj))) 
									break;
								/* begin followField:ofObject: */
								/* begin fetchPointer:ofObject: */
								_objOop2 = unsignedLongAt((_theClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								if (((_objOop2 & (tagMask())) == 0) && (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
									_objOop2 = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _theClass, _objOop2);
								}
								_theClass = _objOop2;
								/* end followField:ofObject: */
							}
							l28:
							;
							{
								/* begin space */
								printChar(' ');
								/* end space */
								printOopShort(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) KeyIndex ) << (shiftForWord())) )));
								print(" -> ");
								printHexnp(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) )));
							}
							l27:
							;
						}
						l29:
						;
						/* end printOopShortInner: */
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop23;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop23);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop23 = GIV(freeStart);
			goto l16;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop23 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l16:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	/* begin allOldSpaceObjectsDo: */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop22 = GIV(nilObj);
	while (1) {
		assert((_objOop22 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop22)) != 0);
		{
			if (isEnumerableObject(_objOop22)) {
				{
					if ((((((usqInt) (longAt(_objOop22)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && ((maybeSelectorOfMethod(_objOop22)) == _selector)) {
						/* begin methodClassAssociationOf: */
						/* begin literal:ofMethod: */
						_offset = (literalCountOfMethodHeader(methodHeaderOf(_objOop22))) - 1;
						/* begin fetchPointer:ofObject: */
						_methodClassAssociation = unsignedLongAt((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset + LiteralStart) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						/* end literal:ofMethod: */
						/* end methodClassAssociationOf: */
						{
							printHexnp(_objOop22);
							/* begin space */
							printChar(' ');
							/* end space */
							/* begin printOopShortInner: */
							if ((((_methodClassAssociation & (tagMask())) == 0) && (((((usqInt) (longAt(_methodClassAssociation)) ) >> (formatShift())) & (formatMask())) <= 5)) && ((numSlotsOf(_methodClassAssociation)) >= 2)) {
								/* begin fetchPointer:ofObject: */
								_oop = unsignedLongAt((_methodClassAssociation + BaseHeaderSize) + (0U << (shiftForWord())));
								/* end fetchPointer:ofObject: */
							} else {
								_oop = _methodClassAssociation;
							}
							if (_oop & (tagMask())) {
								if (_oop & (characterTag())) {
									{
										printChar('$');
										printChar(((usqInt) ((usqInt) _oop ) ) >> (numTagBits()));
										printChar('(');
										printHexnp(((usqInt) ((usqInt) _oop ) ) >> (numTagBits()));
										printChar(')');
									}
									goto l35;
								}
								if (((_oop & 7) == 1)) {
									{
										printNum(_oop >> 3);
										printChar('(');
										printHexnp(_oop >> 3);
										printChar(')');
									}
									goto l35;
								}
								if (_oop & (smallFloatTag())) {
									{
										printFloat(dbgFloatValueOf(_oop));
										printChar('(');
										printHexnp(_oop);
										printChar(')');
									}
									goto l35;
								}
								{
									print("unknown immediate ");
									printHexnp(_oop);
								}
								goto l35;
							}
							if (!(addressCouldBeObj(_oop))) {
								print((((_oop & (8 - 1)) != 0)
									 ? " is misaligned"
									 : whereIs(_oop)));
								goto l35;
							}
							if (((longAt(_oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
								print(" is a free chunk");
								goto l35;
							}
							if (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
								{
									print(" is a forwarder to ");
									printHexnp(followForwarded(_oop));
								}
								goto l35;
							}
							if (((((_tagBits = _oop & (tagMask()))) != 0)
								 ? _tagBits == (smallFloatTag())
								 : ((longAt(_oop)) & (classIndexMask())) == ClassFloatCompactIndex)) {
								printFloat(dbgFloatValueOf(_oop));
								goto l35;
							}
							_classOop = fetchClassOfNonImm(_oop);
							if (!(addressCouldBeObj(_classOop))) {
								print("a ??");
								goto l35;
							}
							if ((numSlotsOf(_classOop)) == GIV(metaclassNumSlots)) {
								printNameOfClasscount(_oop, 5);
								goto l35;
							}
							if (_oop == GIV(nilObj)) {
								print("nil");
								goto l35;
							}
							if (_oop == GIV(trueObj)) {
								print("true");
								goto l35;
							}
							if (_oop == GIV(falseObj)) {
								print("false");
								goto l35;
							}
							_nameLen = lengthOfNameOfClass(_classOop);
							if (_nameLen == 0) {
								print("a ??");
								goto l35;
							}
							_name = nameOfClass(_classOop);
							if (_nameLen == 10) {
								if ((strncmp(_name, "ByteString", 10)) == 0) {
									{
										printChar('\'');
										printStringOf(_oop);
										printChar('\'');
									}
									goto l35;
								}
								if ((strncmp(_name, "ByteSymbol", 10)) == 0) {
									{
										printChar('#');
										printStringOf(_oop);
									}
									goto l35;
								}
							}
							if ((_nameLen == 9) && ((strncmp(_name, "Character", 9)) == 0)) {
								{
									printChar('$');
									printChar((unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())))) >> 3);
								}
								goto l35;
							}
							print("a(n) ");
							for (_i = 0; _i < _nameLen; _i += 1) {
								printChar(_name[_i]);
							}
							if ((((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) <= 5) && ((((assert(addressCouldBeClassObj(_classOop)), ((unsignedLongAt((_classOop + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3) & ((1U << (fixedFieldsFieldWidth())) - 1))) == (ValueIndex + 1)) && (isBytes(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) KeyIndex ) << (shiftForWord())) )))))) {
								_classLookupKey = fetchClassOfNonImm(splObj(SchedulerAssociation));
								while (1) {
									if (_classLookupKey == GIV(nilObj)) {
										goto l35;
									}
									if (((assert(addressCouldBeClassObj(_classLookupKey)), ((unsignedLongAt((_classLookupKey + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3) & ((1U << (fixedFieldsFieldWidth())) - 1))) == (KeyIndex + 1)) 
										break;
									/* begin followField:ofObject: */
									/* begin fetchPointer:ofObject: */
									_objOop = unsignedLongAt((_classLookupKey + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
										_objOop = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _classLookupKey, _objOop);
									}
									_classLookupKey = _objOop;
									/* end followField:ofObject: */
								}
								if (_classLookupKey == GIV(nilObj)) {
									goto l33;
								}
								_theClass = _classOop;
								while (1) {
									if (_theClass == _classLookupKey) {
										goto l34;
									}
									if (!(_theClass != GIV(nilObj))) 
										break;
									/* begin followField:ofObject: */
									/* begin fetchPointer:ofObject: */
									_objOop2 = unsignedLongAt((_theClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									if (((_objOop2 & (tagMask())) == 0) && (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
										_objOop2 = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _theClass, _objOop2);
									}
									_theClass = _objOop2;
									/* end followField:ofObject: */
								}
								l34:
								;
								{
									/* begin space */
									printChar(' ');
									/* end space */
									printOopShort(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) KeyIndex ) << (shiftForWord())) )));
									print(" -> ");
									printHexnp(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) )));
								}
								l33:
								;
							}
							l35:
							;
							/* end printOopShortInner: */
							/* begin cr */
							print("\n");
							/* end cr */
						}
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop22 = _limit2;
			goto l14;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l14:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	/* end allOldSpaceObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if ((((((usqInt) (longAt(_currentObject)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && ((maybeSelectorOfMethod(_currentObject)) == _selector)) {
					/* begin methodClassAssociationOf: */
					/* begin literal:ofMethod: */
					_offset = (literalCountOfMethodHeader(methodHeaderOf(_currentObject))) - 1;
					/* begin fetchPointer:ofObject: */
					_methodClassAssociation = unsignedLongAt((_currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset + LiteralStart) ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					/* end literal:ofMethod: */
					/* end methodClassAssociationOf: */
					{
						printHexnp(_currentObject);
						/* begin space */
						printChar(' ');
						/* end space */
						/* begin printOopShortInner: */
						if ((((_methodClassAssociation & (tagMask())) == 0) && (((((usqInt) (longAt(_methodClassAssociation)) ) >> (formatShift())) & (formatMask())) <= 5)) && ((numSlotsOf(_methodClassAssociation)) >= 2)) {
							/* begin fetchPointer:ofObject: */
							_oop = unsignedLongAt((_methodClassAssociation + BaseHeaderSize) + (0U << (shiftForWord())));
							/* end fetchPointer:ofObject: */
						} else {
							_oop = _methodClassAssociation;
						}
						if (_oop & (tagMask())) {
							if (_oop & (characterTag())) {
								{
									printChar('$');
									printChar(((usqInt) ((usqInt) _oop ) ) >> (numTagBits()));
									printChar('(');
									printHexnp(((usqInt) ((usqInt) _oop ) ) >> (numTagBits()));
									printChar(')');
								}
								goto l36;
							}
							if (((_oop & 7) == 1)) {
								{
									printNum(_oop >> 3);
									printChar('(');
									printHexnp(_oop >> 3);
									printChar(')');
								}
								goto l36;
							}
							if (_oop & (smallFloatTag())) {
								{
									printFloat(dbgFloatValueOf(_oop));
									printChar('(');
									printHexnp(_oop);
									printChar(')');
								}
								goto l36;
							}
							{
								print("unknown immediate ");
								printHexnp(_oop);
							}
							goto l36;
						}
						if (!(addressCouldBeObj(_oop))) {
							print((((_oop & (8 - 1)) != 0)
								 ? " is misaligned"
								 : whereIs(_oop)));
							goto l36;
						}
						if (((longAt(_oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
							print(" is a free chunk");
							goto l36;
						}
						if (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
							{
								print(" is a forwarder to ");
								printHexnp(followForwarded(_oop));
							}
							goto l36;
						}
						if (((((_tagBits = _oop & (tagMask()))) != 0)
							 ? _tagBits == (smallFloatTag())
							 : ((longAt(_oop)) & (classIndexMask())) == ClassFloatCompactIndex)) {
							printFloat(dbgFloatValueOf(_oop));
							goto l36;
						}
						_classOop = fetchClassOfNonImm(_oop);
						if (!(addressCouldBeObj(_classOop))) {
							print("a ??");
							goto l36;
						}
						if ((numSlotsOf(_classOop)) == GIV(metaclassNumSlots)) {
							printNameOfClasscount(_oop, 5);
							goto l36;
						}
						if (_oop == GIV(nilObj)) {
							print("nil");
							goto l36;
						}
						if (_oop == GIV(trueObj)) {
							print("true");
							goto l36;
						}
						if (_oop == GIV(falseObj)) {
							print("false");
							goto l36;
						}
						_nameLen = lengthOfNameOfClass(_classOop);
						if (_nameLen == 0) {
							print("a ??");
							goto l36;
						}
						_name = nameOfClass(_classOop);
						if (_nameLen == 10) {
							if ((strncmp(_name, "ByteString", 10)) == 0) {
								{
									printChar('\'');
									printStringOf(_oop);
									printChar('\'');
								}
								goto l36;
							}
							if ((strncmp(_name, "ByteSymbol", 10)) == 0) {
								{
									printChar('#');
									printStringOf(_oop);
								}
								goto l36;
							}
						}
						if ((_nameLen == 9) && ((strncmp(_name, "Character", 9)) == 0)) {
							{
								printChar('$');
								printChar((unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())))) >> 3);
							}
							goto l36;
						}
						print("a(n) ");
						for (_i = 0; _i < _nameLen; _i += 1) {
							printChar(_name[_i]);
						}
						if ((((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) <= 5) && ((((assert(addressCouldBeClassObj(_classOop)), ((unsignedLongAt((_classOop + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3) & ((1U << (fixedFieldsFieldWidth())) - 1))) == (ValueIndex + 1)) && (isBytes(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) KeyIndex ) << (shiftForWord())) )))))) {
							_classLookupKey = fetchClassOfNonImm(splObj(SchedulerAssociation));
							while (1) {
								if (_classLookupKey == GIV(nilObj)) {
									goto l36;
								}
								if (((assert(addressCouldBeClassObj(_classLookupKey)), ((unsignedLongAt((_classLookupKey + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3) & ((1U << (fixedFieldsFieldWidth())) - 1))) == (KeyIndex + 1)) 
									break;
								/* begin followField:ofObject: */
								/* begin fetchPointer:ofObject: */
								_objOop = unsignedLongAt((_classLookupKey + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
									_objOop = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _classLookupKey, _objOop);
								}
								_classLookupKey = _objOop;
								/* end followField:ofObject: */
							}
							if (_classLookupKey == GIV(nilObj)) {
								goto l37;
							}
							_theClass = _classOop;
							while (1) {
								if (_theClass == _classLookupKey) {
									goto l38;
								}
								if (!(_theClass != GIV(nilObj))) 
									break;
								/* begin followField:ofObject: */
								/* begin fetchPointer:ofObject: */
								_objOop2 = unsignedLongAt((_theClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								if (((_objOop2 & (tagMask())) == 0) && (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
									_objOop2 = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _theClass, _objOop2);
								}
								_theClass = _objOop2;
								/* end followField:ofObject: */
							}
							l38:
							;
							{
								/* begin space */
								printChar(' ');
								/* end space */
								printOopShort(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) KeyIndex ) << (shiftForWord())) )));
								print(" -> ");
								printHexnp(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) )));
							}
							l37:
							;
						}
						l36:
						;
						/* end printOopShortInner: */
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l17;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l17:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
}
/* StackInterpreter>>#printMethodCache */
void
printMethodCache(void)
{
	printMethodCacheFor(-1);
}
/* StackInterpreter>>#printMethodDictionaryOf: */
void
printMethodDictionaryOf(sqInt _behavior)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _dictionary;
	sqInt _iLimit;
	sqInt _index;
	sqInt _meth;
	sqInt _methodArray;
	sqInt _selector;

	/* begin printMethodDictionary: */
	_dictionary = unsignedLongAt((_behavior + BaseHeaderSize) + ((sqInt) (((usqInt) MethodDictionaryIndex ) << (shiftForWord())) ));
	/* begin fetchPointer:ofObject: */
	_methodArray = unsignedLongAt((_dictionary + BaseHeaderSize) + ((sqInt) (((usqInt) MethodArrayIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	for (_index = SelectorStart, _iLimit = (numSlotsOf(_dictionary)) - 1; _index <= _iLimit; _index += 1) {
		/* begin fetchPointer:ofObject: */
		_selector = unsignedLongAt((_dictionary + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (_selector != GIV(nilObj)) {
			/* begin fetchPointer:ofObject: */
			_meth = unsignedLongAt((_methodArray + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - SelectorStart) ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			{
				printOopShort(_selector);
				print(" => ");
				printOopShort(_meth);
				print(" (");
				printHex(_selector);
				print(" => ");
				printHex(_meth);
				putchar(')');
				/* begin cr */
				print("\n");
				/* end cr */
			}
		}
	}
	/* end printMethodDictionary: */
}
/* StackInterpreter>>#printMethodDictionary: */
void
printMethodDictionary(sqInt _dictionary)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _iLimit;
	sqInt _index;
	sqInt _meth;
	sqInt _methodArray;
	sqInt _selector;

	/* begin fetchPointer:ofObject: */
	_methodArray = unsignedLongAt((_dictionary + BaseHeaderSize) + ((sqInt) (((usqInt) MethodArrayIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	for (_index = SelectorStart, _iLimit = (numSlotsOf(_dictionary)) - 1; _index <= _iLimit; _index += 1) {
		/* begin fetchPointer:ofObject: */
		_selector = unsignedLongAt((_dictionary + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (_selector != GIV(nilObj)) {
			/* begin fetchPointer:ofObject: */
			_meth = unsignedLongAt((_methodArray + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - SelectorStart) ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			{
				printOopShort(_selector);
				print(" => ");
				printOopShort(_meth);
				print(" (");
				printHex(_selector);
				print(" => ");
				printHex(_meth);
				putchar(')');
				/* begin cr */
				print("\n");
				/* end cr */
			}
		}
	}
}
/*	Details: The count argument is used to avoid a possible infinite recursion 
	if classOop is a corrupted object. */
/* StackInterpreter>>#printNameOfClass:count: */
static void NoDbgRegParms
printNameOfClasscount(sqInt _classOop, sqInt _cnt)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqInt _numSlots;
	usqInt _numSlots2;

	if (!GIV(classNameIndex)) {
		print("??nil cnidx??");
		return;
	}
	if ((_classOop == null) || ((_classOop == 0) || (_cnt <= 0))) {
		print("bad class");
		return;
	}
	/* begin numSlotsOf: */
	assert((classIndexOf(_classOop)) > (isForwardedObjectClassIndexPun()));
	_numSlots2 = byteAt(_classOop + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_classOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOf: */
	if ((_numSlots == GIV(metaclassNumSlots)) && (GIV(metaclassNumSlots) > GIV(thisClassIndex))) {
		printNameOfClasscount(unsignedLongAt((_classOop + BaseHeaderSize) + ((sqInt) (((usqInt) GIV(thisClassIndex) ) << (shiftForWord())) )), _cnt - 1);
		print(" class");
	} else {
		if (_numSlots <= GIV(classNameIndex)) {
			print("bad class");
		}
 else {
			printStringOf(unsignedLongAt((_classOop + BaseHeaderSize) + ((sqInt) (((usqInt) GIV(classNameIndex) ) << (shiftForWord())) )));
		}
	}
}
/*	For testing in Smalltalk, this method should be overridden in a subclass. */
/* StackInterpreter>>#printNum: */
static void NoDbgRegParms
printNum(sqInt n)
{
	vm_printf("%ld", (long) n);
}
/* StackInterpreter>>#printOopShort: */
static void NoDbgRegParms
printOopShort(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classLookupKey;
	sqInt _classOop;
	sqInt _i;
	char *_name;
	sqInt _nameLen;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _tagBits;
	sqInt _theClass;

	/* begin printOopShortInner: */
	if (_oop & (tagMask())) {
		if (_oop & (characterTag())) {
			{
				printChar('$');
				printChar(((usqInt) ((usqInt) _oop ) ) >> (numTagBits()));
				printChar('(');
				printHexnp(((usqInt) ((usqInt) _oop ) ) >> (numTagBits()));
				printChar(')');
			}
			goto l8;
		}
		if (((_oop & 7) == 1)) {
			{
				printNum(_oop >> 3);
				printChar('(');
				printHexnp(_oop >> 3);
				printChar(')');
			}
			goto l8;
		}
		if (_oop & (smallFloatTag())) {
			{
				printFloat(dbgFloatValueOf(_oop));
				printChar('(');
				printHexnp(_oop);
				printChar(')');
			}
			goto l8;
		}
		{
			print("unknown immediate ");
			printHexnp(_oop);
		}
		goto l8;
	}
	if (!(addressCouldBeObj(_oop))) {
		print((((_oop & (8 - 1)) != 0)
			 ? " is misaligned"
			 : whereIs(_oop)));
		goto l8;
	}
	if (((longAt(_oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
		print(" is a free chunk");
		goto l8;
	}
	if (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		{
			print(" is a forwarder to ");
			printHexnp(followForwarded(_oop));
		}
		goto l8;
	}
	if (((((_tagBits = _oop & (tagMask()))) != 0)
		 ? _tagBits == (smallFloatTag())
		 : ((longAt(_oop)) & (classIndexMask())) == ClassFloatCompactIndex)) {
		printFloat(dbgFloatValueOf(_oop));
		goto l8;
	}
	_classOop = fetchClassOfNonImm(_oop);
	if (!(addressCouldBeObj(_classOop))) {
		print("a ??");
		goto l8;
	}
	if ((numSlotsOf(_classOop)) == GIV(metaclassNumSlots)) {
		printNameOfClasscount(_oop, 5);
		goto l8;
	}
	if (_oop == GIV(nilObj)) {
		print("nil");
		goto l8;
	}
	if (_oop == GIV(trueObj)) {
		print("true");
		goto l8;
	}
	if (_oop == GIV(falseObj)) {
		print("false");
		goto l8;
	}
	_nameLen = lengthOfNameOfClass(_classOop);
	if (_nameLen == 0) {
		print("a ??");
		goto l8;
	}
	_name = nameOfClass(_classOop);
	if (_nameLen == 10) {
		if ((strncmp(_name, "ByteString", 10)) == 0) {
			{
				printChar('\'');
				printStringOf(_oop);
				printChar('\'');
			}
			goto l8;
		}
		if ((strncmp(_name, "ByteSymbol", 10)) == 0) {
			{
				printChar('#');
				printStringOf(_oop);
			}
			goto l8;
		}
	}
	if ((_nameLen == 9) && ((strncmp(_name, "Character", 9)) == 0)) {
		{
			printChar('$');
			printChar((unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())))) >> 3);
		}
		goto l8;
	}
	print("a(n) ");
	for (_i = 0; _i < _nameLen; _i += 1) {
		printChar(_name[_i]);
	}
	if ((((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) <= 5) && ((((assert(addressCouldBeClassObj(_classOop)), ((unsignedLongAt((_classOop + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3) & ((1U << (fixedFieldsFieldWidth())) - 1))) == (ValueIndex + 1)) && (isBytes(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) KeyIndex ) << (shiftForWord())) )))))) {
		_classLookupKey = fetchClassOfNonImm(splObj(SchedulerAssociation));
		while (1) {
			if (_classLookupKey == GIV(nilObj)) {
				goto l8;
			}
			if (((assert(addressCouldBeClassObj(_classLookupKey)), ((unsignedLongAt((_classLookupKey + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3) & ((1U << (fixedFieldsFieldWidth())) - 1))) == (KeyIndex + 1)) 
				break;
			/* begin followField:ofObject: */
			/* begin fetchPointer:ofObject: */
			_objOop = unsignedLongAt((_classLookupKey + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				_objOop = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _classLookupKey, _objOop);
			}
			_classLookupKey = _objOop;
			/* end followField:ofObject: */
		}
		if (_classLookupKey == GIV(nilObj)) {
			goto l2;
		}
		_theClass = _classOop;
		while (1) {
			if (_theClass == _classLookupKey) {
				goto l3;
			}
			if (!(_theClass != GIV(nilObj))) 
				break;
			/* begin followField:ofObject: */
			/* begin fetchPointer:ofObject: */
			_objOop2 = unsignedLongAt((_theClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((_objOop2 & (tagMask())) == 0) && (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				_objOop2 = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _theClass, _objOop2);
			}
			_theClass = _objOop2;
			/* end followField:ofObject: */
		}
		l3:
		;
		{
			/* begin space */
			printChar(' ');
			/* end space */
			printOopShort(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) KeyIndex ) << (shiftForWord())) )));
			print(" -> ");
			printHexnp(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) )));
		}
		l2:
		;
	}
	l8:
	;
	/* end printOopShortInner: */
	flush();
}
/* StackInterpreter>>#printOop: */
sqInt
printOop(sqInt _oop)
{
	sqInt _byte;
	int _bytecodesPerLine;
	sqInt _cls;
	int _column;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	sqInt _lastIndex;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _startIP;

	if (_oop & (tagMask())) {
		return shortPrintOop(_oop);
	}
	printHex(_oop);
	if (!(addressCouldBeObj(_oop))) {
		{
			print((((_oop & (8 - 1)) != 0)
				 ? " is misaligned"
				 : whereIs(_oop)));
			/* begin cr */
			print("\n");
			/* end cr */
		}
		return 0;
	}
	if (((longAt(_oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
		{
			print(" is a free chunk of size ");
			printNum((assert(isFreeObject(_oop)), bytesInObject(_oop)));
		}
		{
			print(" 0th: ");
			printHex(unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord()))));
		}
		printHeaderTypeOf(_oop);
		/* begin cr */
		print("\n");
		/* end cr */
		return 0;
	}
	if (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		{
			print(" is a forwarded object to ");
			printHex(followForwarded(_oop));
			print(" of slot size ");
			printNum(numSlotsOfAny(_oop));
		}
		printHeaderTypeOf(_oop);
		/* begin cr */
		print("\n");
		/* end cr */
		return 0;
	}
	print(": a(n) ");
	printNameOfClasscount((_cls = fetchClassOfNonImm(_oop)), 5);
	if (_cls == (splObj(ClassFloat))) {
		{
			/* begin cr */
			print("\n");
			/* end cr */
			printFloat(dbgFloatValueOf(_oop));
			/* begin cr */
			print("\n");
			/* end cr */
		}
		return 0;
	}
	_fmt = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
	if (_fmt > 5) {
		{
			print(" nbytes ");
			printNum(numBytesOf(_oop));
		}
	}
	/* begin cr */
	print("\n");
	/* end cr */
	if ((_fmt >= (firstLongFormat())) && (_fmt <= ((firstCompiledMethodFormat()) - 1))) {
		if ((((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) >= (firstLongFormat())) && (((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) <= ((firstShortFormat()) - 1))) {
			_lastIndex = ((64 < ((numBytesOf(_oop)) / BytesPerWord)) ? 64 : (numBytesOf(_oop)) / BytesPerWord);
			if (_lastIndex > 0) {
				for (_index = 1; _index <= _lastIndex; _index += 1) {
					{
						/* begin space */
						printChar(' ');
						/* end space */
						printHex(((unsigned int) (long32At((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << 2) ))) ));
					}
					if ((_index % 5) == 0) {
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
				if (!((_lastIndex % 5) == 0)) {
					/* begin cr */
					print("\n");
					/* end cr */
				}
			}
			return 0;
		}
		return (printStringOf(_oop), /* begin cr */ print("\n"), 1 /* end cr */);
	}
	_startIP = (((lastPointerOf(_oop)) + BytesPerOop) - BaseHeaderSize) / BytesPerOop;
	_lastIndex = ((256 < _startIP) ? 256 : _startIP);
	if (_lastIndex > 0) {
		for (_index = 1; _index <= _lastIndex; _index += 1) {
			{
				printHex(unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << (shiftForWord())) )));
				/* begin space */
				printChar(' ');
				/* end space */
			}
			if ((_index % 5) == 0) {
				/* begin cr */
				print("\n");
				/* end cr */
			}
		}
		if (!((_lastIndex % 5) == 0)) {
			/* begin cr */
			print("\n");
			/* end cr */
		}
	}
	if (((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
		_startIP = (_startIP * BytesPerWord) + 1;
		/* begin lengthOf:format: */
		_fmt2 = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
		/* begin numSlotsOfAny: */
		_numSlots2 = byteAt(_oop + 7);
		_numSlots = ((_numSlots2 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_oop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots2);
		/* end numSlotsOfAny: */
		if (_fmt2 <= 5) {
			_lastIndex = _numSlots;
			goto l17;
		}
		if (_fmt2 >= (firstByteFormat())) {
			_lastIndex = (_numSlots << (shiftForWord())) - (_fmt2 & 7);
			goto l17;
		}
		if (_fmt2 >= (firstShortFormat())) {
			_lastIndex = (_numSlots << ((shiftForWord()) - 1)) - (_fmt2 & 3);
			goto l17;
		}
		if (_fmt2 >= (firstLongFormat())) {
			_lastIndex = (_numSlots << ((shiftForWord()) - 2)) - (_fmt2 & 1);
			goto l17;
		}
		if (_fmt2 == (sixtyFourBitIndexableFormat())) {
			_lastIndex = _numSlots;
			goto l17;
		}
		_lastIndex = 0;
		l17:
		;
		/* end lengthOf:format: */
		if ((_lastIndex - _startIP) > 100) {
			_lastIndex = _startIP + 100;
		}
		_bytecodesPerLine = 8;
		_column = 1;
		for (_index = _startIP; _index <= _lastIndex; _index += 1) {
			if (_column == 1) {
				vm_printf("0x%08" PRIxSQPTR ": ", (usqIntptr_t)(_oop+BaseHeaderSize+_index-1));
			}
			/* begin fetchByte:ofObject: */
			_byte = byteAt((_oop + BaseHeaderSize) + (_index - 1));
			/* end fetchByte:ofObject: */
			vm_printf(" %02x/%-3d", (int)_byte,(int)_byte);
			_column += 1;
			if (_column > _bytecodesPerLine) {
				_column = 1;
				/* begin cr */
				print("\n");
				/* end cr */
			}
		}
		if (!(_column == 1)) {
			/* begin cr */
			print("\n");
			/* end cr */
		}
	} else {
		if (_startIP > 64) {
			{
				print("...");
				/* begin cr */
				print("\n");
				/* end cr */
			}
		}
	}
	return 0;
}
/* StackInterpreter>>#printPointersTo: */
void
printPointersTo(sqInt _anAddress)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _address;
	sqInt _address2;
	sqInt _currentObject;
	sqInt _followingWord;
	sqInt _followingWord2;
	sqInt _followingWord3;
	sqInt _followingWord4;
	usqInt _followingWordAddress;
	usqInt _followingWordAddress2;
	usqInt _followingWordAddress3;
	usqInt _followingWordAddress4;
	sqInt _idx;
	sqInt _iLimit;
	usqInt _limit;
	sqInt _limit2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _objOop2;
	sqInt _objOop22;
	sqInt _prevObj;
	sqInt _prevObj2;
	sqInt _prevPrevObj;
	sqInt _prevPrevObj2;
	sqInt _referent;

	/* begin allObjectsDo: */
	/* begin allNewSpaceObjectsDo: */
	/* begin allNewSpaceEntitiesDo: */
	_prevPrevObj = (_prevObj = null);
	assert((((pastSpace()).start)) < (((eden()).start)));
	/* begin objectStartingAt: */
	_address = ((pastSpace()).start);
	_numSlots = byteAt(_address + 7);
	_objOop2 = ((_numSlots == (numSlotsMask()))
		 ? _address + BaseHeaderSize
		 : _address);
	/* end objectStartingAt: */
	_limit = GIV(pastSpaceStart);
	while (oopisLessThan(_objOop2, _limit)) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent = unsignedLongAt((_objOop2 + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
					if (_referent == _anAddress) {
						shortPrintOop(_objOop2);
					}
				} else {
					for (_idx = 0, _iLimit = (numPointerSlotsOf(_objOop2)) - 1; _idx <= _iLimit; _idx += 1) {
						/* begin fetchPointer:ofObject: */
						_referent = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _idx ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						if (_referent == _anAddress) {
							shortPrintOop(_objOop2);
						}
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress, _limit)) {
			_objOop2 = _limit;
			goto l8;
		}
		flag("endianness");
		_followingWord = unsignedLongAt(_followingWordAddress);
		_objOop2 = (((((usqInt) _followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress + BaseHeaderSize
			 : _followingWordAddress);
		l8:
		;
		/* end objectAfter:limit: */
	}
	/* begin objectStartingAt: */
	_address2 = ((eden()).start);
	_numSlots2 = byteAt(_address2 + 7);
	_objOop2 = ((_numSlots2 == (numSlotsMask()))
		 ? _address2 + BaseHeaderSize
		 : _address2);
	/* end objectStartingAt: */
	while (oopisLessThan(_objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(_objOop2));
			{
				if (((long64At(_objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent = unsignedLongAt((_objOop2 + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
					if (_referent == _anAddress) {
						shortPrintOop(_objOop2);
					}
				} else {
					for (_idx = 0, _iLimit = (numPointerSlotsOf(_objOop2)) - 1; _idx <= _iLimit; _idx += 1) {
						/* begin fetchPointer:ofObject: */
						_referent = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) _idx ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						if (_referent == _anAddress) {
							shortPrintOop(_objOop2);
						}
					}
				}
			}
		}
		_prevPrevObj = _prevObj;
		_prevObj = _objOop2;
		/* begin objectAfter:limit: */
		_followingWordAddress2 = addressAfter(_objOop2);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress2, GIV(freeStart))) {
			_objOop2 = GIV(freeStart);
			goto l9;
		}
		flag("endianness");
		_followingWord2 = unsignedLongAt(_followingWordAddress2);
		_objOop2 = (((((usqInt) _followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress2 + BaseHeaderSize
			 : _followingWordAddress2);
		l9:
		;
		/* end objectAfter:limit: */
	}
	/* end allNewSpaceEntitiesDo: */
	/* end allNewSpaceObjectsDo: */
	/* begin allOldSpaceObjectsDo: */
	/* begin allOldSpaceObjectsFrom:do: */
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), GIV(nilObj)));
	_prevPrevObj2 = (_prevObj2 = null);
	_objOop22 = GIV(nilObj);
	while (1) {
		assert((_objOop22 % (allocationUnit())) == 0);
		if (!(oopisLessThan(_objOop22, (GIV(memoryMap)->oldSpaceEnd)))) 
			break;
		assert((uint64AtPointer(_objOop22)) != 0);
		{
			if (isEnumerableObject(_objOop22)) {
				{
					if (((long64At(_objOop22)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
						/* begin fetchPointer:ofMaybeForwardedObject: */
						_referent = unsignedLongAt((_objOop22 + BaseHeaderSize) + (0U << (shiftForWord())));
						/* end fetchPointer:ofMaybeForwardedObject: */
						if (_referent == _anAddress) {
							shortPrintOop(_objOop22);
						}
					} else {
						for (_idx = 0, _iLimit = (numPointerSlotsOf(_objOop22)) - 1; _idx <= _iLimit; _idx += 1) {
							/* begin fetchPointer:ofObject: */
							_referent = unsignedLongAt((_objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) _idx ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							if (_referent == _anAddress) {
								shortPrintOop(_objOop22);
							}
						}
					}
				}
			}
		}
		_prevPrevObj2 = _prevObj2;
		_prevObj2 = _objOop22;
		/* begin objectAfter:limit: */
		_limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		_followingWordAddress4 = addressAfter(_objOop22);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress4, _limit2)) {
			_objOop22 = _limit2;
			goto l7;
		}
		flag("endianness");
		_followingWord4 = unsignedLongAt(_followingWordAddress4);
		_objOop22 = (((((usqInt) _followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress4 + BaseHeaderSize
			 : _followingWordAddress4);
		l7:
		;
		/* end objectAfter:limit: */
	}
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	/* end allOldSpaceObjectsDo: */
	/* begin allPermSpaceObjectsDo: */
	_currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(_currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(_currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (((long64At(_currentObject)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					/* begin fetchPointer:ofMaybeForwardedObject: */
					_referent = unsignedLongAt((_currentObject + BaseHeaderSize) + (0U << (shiftForWord())));
					/* end fetchPointer:ofMaybeForwardedObject: */
					if (_referent == _anAddress) {
						shortPrintOop(_currentObject);
					}
				} else {
					for (_idx = 0, _iLimit = (numPointerSlotsOf(_currentObject)) - 1; _idx <= _iLimit; _idx += 1) {
						/* begin fetchPointer:ofObject: */
						_referent = unsignedLongAt((_currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) _idx ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						if (_referent == _anAddress) {
							shortPrintOop(_currentObject);
						}
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		_followingWordAddress3 = addressAfter(_currentObject);
		if (oopisGreaterThanOrEqualTo(_followingWordAddress3, GIV(permSpaceFreeStart))) {
			_currentObject = GIV(permSpaceFreeStart);
			goto l6;
		}
		flag("endianness");
		_followingWord3 = unsignedLongAt(_followingWordAddress3);
		_currentObject = (((((usqInt) _followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? _followingWordAddress3 + BaseHeaderSize
			 : _followingWordAddress3);
		l6:
		;
		/* end objectAfter:limit: */
	}
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
}
/* StackInterpreter>>#printProcessStack: */
void
printProcessStack(sqInt _aProcess)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _ctx;
	sqInt _objOop;
	sqInt _tagBits;

	{
		/* begin cr */
		print("\n");
		/* end cr */
		printNameOfClasscount(((((_tagBits = _aProcess & (tagMask()))) != 0)
			 ? unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) ))
			 : fetchClassOfNonImm(_aProcess)), 5);
		/* begin space */
		printChar(' ');
		/* end space */
		printHex(_aProcess);
	}
	{
		print(" priority ");
		printNum(quickFetchIntegerofObject(PriorityIndex, _aProcess));
		/* begin cr */
		print("\n");
		/* end cr */
	}
	/* begin followField:ofObject: */
	/* begin fetchPointer:ofObject: */
	_objOop = unsignedLongAt((_aProcess + BaseHeaderSize) + ((sqInt) (((usqInt) SuspendedContextIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		_objOop = fixFollowedFieldofObjectwithInitialValue(SuspendedContextIndex, _aProcess, _objOop);
	}
	_ctx = _objOop;
	/* end followField:ofObject: */
	if (!(_ctx == GIV(nilObj))) {
		printCallStackOfcurrentFP(_ctx, GIV(framePointer));
	}
}
/* StackInterpreter>>#printProcsOnList: */
sqInt
printProcsOnList(sqInt _procList)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _firstProc;
	sqInt _objOop;
	sqInt _proc;

	_proc = (_firstProc = followFieldofObject(FirstLinkIndex, _procList));
	while (!(_proc == GIV(nilObj))) {
		printProcessStack(_proc);
		/* begin followField:ofObject: */
		/* begin fetchPointer:ofObject: */
		_objOop = unsignedLongAt((_proc + BaseHeaderSize) + ((sqInt) (((usqInt) NextLinkIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			_objOop = fixFollowedFieldofObjectwithInitialValue(NextLinkIndex, _proc, _objOop);
		}
		_proc = _objOop;
		/* end followField:ofObject: */
		if (_proc == _firstProc) {
			warning("circular process list!!");
			return null;
		}
	}
	return 0;
}
/* StackInterpreter>>#printStackCallStackOf: */
sqInt
printStackCallStackOf(sqInt _aContextOrProcessOrFrame)
{
	sqInt _context;
	char *_theFP;

	{
		if (addressCouldBeObj(_aContextOrProcessOrFrame)) {
			if ((((_aContextOrProcessOrFrame & (tagMask())) == 0) && (((longAt(_aContextOrProcessOrFrame)) & (classIndexMask())) == ClassMethodContextCompactIndex)) && (checkIsStillMarriedContextcurrentFP(_aContextOrProcessOrFrame, null))) {
				return printStackCallStackOf(((sqInt) (frameOfMarriedContext(_aContextOrProcessOrFrame)) ));
			}
			if (couldBeProcess(_aContextOrProcessOrFrame)) {
				return printCallStackOf(unsignedLongAt((_aContextOrProcessOrFrame + BaseHeaderSize) + ((sqInt) (((usqInt) SuspendedContextIndex ) << (shiftForWord())) )));
			}
			return null;
		}
	}
	_theFP = ((void *) _aContextOrProcessOrFrame );
	while (1) {
		_context = shortReversePrintFrameAndCallers(_theFP);
		if (!(((((unsignedLongAt((_context + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (((_theFP = frameOfMarriedContext(_context)), checkIsStillMarriedContextcurrentFP(_context, _theFP))))) {
			return null;
		}
	}
	return 0;
}
/* StackInterpreter>>#printStackPageList */
void
printStackPageList(void)
{
	StackPage *_page;

	_page = mostRecentlyUsedPage();
	do {
		/* begin printStackPage: */
		printStackPageuseCount(_page, -1);
		/* end printStackPage: */
		/* begin cr */
		print("\n");
		/* end cr */
	} while (((_page = (_page->prevPage))) != (mostRecentlyUsedPage()));
}
/* StackInterpreter>>#printStackPageListInUse */
void
printStackPageListInUse(void)
{
	int _n;
	StackPage *_page;

	_page = mostRecentlyUsedPage();
	_n = 0;
	do {
		if (!(((_page->baseFP)) == 0)) {
			{
				printStackPageuseCount(_page, (_n += 1));
				/* begin cr */
				print("\n");
				/* end cr */
			}
		}
	} while (((_page = (_page->prevPage))) != (mostRecentlyUsedPage()));
}
/* StackInterpreter>>#printStackPages */
void
printStackPages(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	StackPage *_thePage;

	/* begin allStackPagesDo: */
	for (_i = 0; _i < GIV(numStackPages); _i += 1) {
		/* begin stackPageAt: */
		_thePage = stackPageAtpages(_i, GIV(pages));
		/* end stackPageAt: */
		{
			/* begin printStackPage: */
			printStackPageuseCount(((StackPage *) _thePage ), -1);
			/* end printStackPage: */
			/* begin cr */
			print("\n");
			/* end cr */
		}
	}
	/* end allStackPagesDo: */
}
/* StackInterpreter>>#printStackPagesInUse */
void
printStackPagesInUse(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	int _n;
	StackPage *_thePage2;

	_n = 0;
	/* begin usedStackPagesDo: */
	/* begin allStackPagesDo: */
	for (_i = 0; _i < GIV(numStackPages); _i += 1) {
		/* begin stackPageAt: */
		_thePage2 = stackPageAtpages(_i, GIV(pages));
		/* end stackPageAt: */
		{
			if (!(((_thePage2->baseFP)) == 0)) {
				{
					{
						printStackPageuseCount(_thePage2, (_n += 1));
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
	}
	/* end allStackPagesDo: */
	/* end usedStackPagesDo: */
}
/* StackInterpreter>>#printStackPage:useCount: */
static void NoDbgRegParms
printStackPageuseCount(StackPage *_page, sqInt _n)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	void *_p;
	void *_p2;
	void *_p3;
	void *_p4;
	void *_p5;
	void *_p6;
	void *_p7;
	void *_p8;
	void *_p9;

	{
		print("page ");
		/* begin printHexPtr: */
		printHex(oopForPointer(_page));
		/* end printHexPtr: */
		print(" (");
		printNum((assert((((char *) ((_page->realStackLimit)) ) >= (GIV(stackBasePlus1) - 1)) && (((char *) ((_page->realStackLimit)) ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage((_page->realStackLimit), GIV(stackBasePlus1), GIV(bytesPerPage))));
	}
	if (_n >= 0) {
		{
			print(",");
			printNum(_n);
		}
	}
	{
		print(")  (trace: ");
		printNum((_page->trace));
		printChar(')');
	}
	if (((_page->baseFP)) == 0) {
		print(" (free)");
	}
	if (_page == (mostRecentlyUsedPage())) {
		print(" (MRU)");
	}
	if (((_page->prevPage)) == (mostRecentlyUsedPage())) {
		print(" (LRU)");
	}
	{
		/* begin cr */
		print("\n");
		/* end cr */
		/* begin tab */
		printChar('	');
		/* end tab */
		print("ba: ");
		/* begin printHexPtr: */
		_p = (_page->baseAddress);
		printHex(oopForPointer(_p));
		/* end printHexPtr: */
		print(" - sl: ");
		/* begin printHexPtr: */
		_p2 = (_page->realStackLimit);
		printHex(oopForPointer(_p2));
		/* end printHexPtr: */
		print(" - sl-so: ");
		/* begin printHexPtr: */
		_p3 = ((_page->realStackLimit)) - ((IFrameSlots + 64) * BytesPerWord);
		printHex(oopForPointer(_p3));
		/* end printHexPtr: */
		print(" - la:");
		/* begin printHexPtr: */
		_p4 = (_page->lastAddress);
		printHex(oopForPointer(_p4));
		/* end printHexPtr: */
	}
	if (!(((_page->baseFP)) == 0)) {
		{
			/* begin cr */
			print("\n");
			/* end cr */
			/* begin tab */
			printChar('	');
			/* end tab */
			print("baseFP ");
			/* begin printHexPtr: */
			_p5 = (_page->baseFP);
			printHex(oopForPointer(_p5));
			/* end printHexPtr: */
		}
		{
			/* begin tab */
			printChar('	');
			/* end tab */
			print("headFP ");
			/* begin printHexPtr: */
			_p6 = (_page->headFP);
			printHex(oopForPointer(_p6));
			/* end printHexPtr: */
		}
		{
			/* begin tab */
			printChar('	');
			/* end tab */
			print("headSP ");
			/* begin printHexPtr: */
			_p7 = (_page->headSP);
			printHex(oopForPointer(_p7));
			/* end printHexPtr: */
		}
	}
	{
		/* begin cr */
		print("\n");
		/* end cr */
		/* begin tab */
		printChar('	');
		/* end tab */
		print("prev ");
		/* begin printHexPtr: */
		_p8 = ((void *) (_page->prevPage) );
		printHex(oopForPointer(_p8));
		/* end printHexPtr: */
		print(" (");
		printNum((assert((((char *) ((((_page->prevPage))->realStackLimit)) ) >= (GIV(stackBasePlus1) - 1)) && (((char *) ((((_page->prevPage))->realStackLimit)) ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage((((_page->prevPage))->realStackLimit), GIV(stackBasePlus1), GIV(bytesPerPage))));
		printChar(')');
	}
	{
		/* begin tab */
		printChar('	');
		/* end tab */
		print("next ");
		/* begin printHexPtr: */
		_p9 = ((void *) (_page->nextPage) );
		printHex(oopForPointer(_p9));
		/* end printHexPtr: */
		print(" (");
		printNum((assert((((char *) ((((_page->nextPage))->realStackLimit)) ) >= (GIV(stackBasePlus1) - 1)) && (((char *) ((((_page->nextPage))->realStackLimit)) ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage((((_page->nextPage))->realStackLimit), GIV(stackBasePlus1), GIV(bytesPerPage))));
		printChar(')');
	}
	/* begin cr */
	print("\n");
	/* end cr */
}
/* StackInterpreter>>#printStackReferencesTo: */
void
printStackReferencesTo(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_callerFP;
	sqInt _i;
	char *_theFP;
	StackPage *_thePage2;
	char *_theSP;

	/* begin usedStackPagesDo: */
	/* begin allStackPagesDo: */
	for (_i = 0; _i < GIV(numStackPages); _i += 1) {
		/* begin stackPageAt: */
		_thePage2 = stackPageAtpages(_i, GIV(pages));
		/* end stackPageAt: */
		{
			if (!(((_thePage2->baseFP)) == 0)) {
				{
					_theSP = (_thePage2->headSP);
					_theFP = (_thePage2->headFP);
					if (!(_thePage2 == GIV(stackPage))) {
						_theSP += BytesPerWord;
					}
					while (1) {
						while (_theSP <= (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
							 ? _theFP + FoxMFReceiver
							 : _theFP + FoxIFReceiver))) {
							if (_oop == (unsignedLongAt(_theSP))) {
								{
									print("FP: ");
									printHexnp(_theFP);
									print(" @ ");
									printHexnp(_theSP);
									/* begin cr */
									print("\n");
									/* end cr */
								}
							}
							_theSP += BytesPerWord;
						}
						if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
							 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
							 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0)) {
							if (_oop == (unsignedLongAt(_theFP + FoxThisContext))) {
								{
									print("FP: ");
									printHexnp(_theFP);
									print(" CTXT");
									/* begin cr */
									print("\n");
									/* end cr */
								}
							}
						}
						if (_oop == (unsignedLongAt(_theFP + FoxMethod))) {
							{
								print("FP: ");
								printHexnp(_theFP);
								print(" MTHD");
								/* begin cr */
								print("\n");
								/* end cr */
							}
						}
						if (!(((_callerFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP)))) != 0)) 
							break;
						_theSP = (_theFP + FoxCallerSavedIP) + BytesPerWord;
						_theFP = _callerFP;
					}
					_theSP = _theFP + FoxCallerSavedIP;
					while (_theSP <= ((_thePage2->baseAddress))) {
						if (_oop == (unsignedLongAt(_theSP))) {
							{
								print("FP: ");
								printHexnp(_theFP);
								print(" @ ");
								printHexnp(_theSP);
								/* begin cr */
								print("\n");
								/* end cr */
							}
						}
						_theSP += BytesPerWord;
					}
				}
			}
		}
	}
	/* end allStackPagesDo: */
	/* end usedStackPagesDo: */
}
/* StackInterpreter>>#printStringOf: */
void
printStringOf(sqInt _oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _cnt;
	sqInt _fmt;
	int _i;
	sqInt _len;
	int _max;

	if (_oop & (tagMask())) {
		return;
	}
	if (!(addressCouldBeObj(_oop))) {
		return;
	}
	_fmt = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (firstByteFormat())) {
		return;
	}
	_cnt = ((((_max = 128)) < ((_len = lengthOfformat(_oop, (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask()))))) ? (_max = 128) : (_len = lengthOfformat(_oop, (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask()))));
	_i = 0;
	if ((isinstanceOfcompactClassIndex(_oop, splObj(ClassByteArray), GIV(classByteArrayCompactIndex))) || (((_oop & (tagMask())) == 0) && (((usqInt) (((longAt(_oop)) & (classIndexMask())) - ClassLargeNegativeIntegerCompactIndex) ) <= 1))) {
		while (_i < _cnt) {
			printHex(byteAt((_oop + BaseHeaderSize) + _i));
			_i += 1;
		}
	}
 else {
		while (_i < _cnt) {
			if ((byteAt((_oop + BaseHeaderSize) + _i)) == 13) {
				print("<CR>");
				if ((_i + 1) < _len) {
					print("...");
				}
				return;
			}
			printChar(byteAt((_oop + BaseHeaderSize) + _i));
			_i += 1;
		}
	}
	if (_len > _max) {
		print("...");
	}
	flush();
}
/*	For testing in Smalltalk, this method should be overridden in a subclass. */
/* StackInterpreter>>#print: */
void
print(char *s)
{
	vm_printf(s);
}
/* StackInterpreter>>#pushBool: */
sqInt
pushBool(sqInt _trueOrFalse)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _object;
	char *_sp;

	/* begin push: */
	_object = ((_trueOrFalse)
		 ? GIV(trueObj)
		 : GIV(falseObj));
	unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
	GIV(stackPointer) = _sp;
	/* end push: */
	return 0;
}
/*	The receiver of a message send or the closure of a block activation is 
	always on the stack above any arguments and the frame itself. See the 
	diagram in StackInterpreter class>>initializeFrameIndices. */
/* StackInterpreter>>#pushedReceiverOrClosureOfFrame: */
static sqInt NoDbgRegParms
pushedReceiverOrClosureOfFrame(char *_theFP)
{
	return unsignedLongAt(_theFP + (frameStackedReceiverOffset(_theFP)));
}
/* StackInterpreter>>#pushFloat: */
void
pushFloat(double _f)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _object;
	char *_sp;

	/* begin push: */
	_object = floatObjectOf(_f);
	unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
	GIV(stackPointer) = _sp;
	/* end push: */
}
/* StackInterpreter>>#pushInteger: */
sqInt
pushInteger(sqInt _integerValue)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_sp;

	/* begin push: */
	unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), ((((usqInt) _integerValue ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end push: */
	return null;
}
/*	In the StackInterpreter stacks grow down. */
/* StackInterpreter>>#push: */
void
push(sqInt _object)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_sp;

	unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
	GIV(stackPointer) = _sp;
}
/*	Save the given process on the scheduler process list for its priority, 
	adding to the back if yieldImplicitly or to the front if not 
	yieldImplicitly.  */
/* StackInterpreter>>#putToSleep:yieldingIf: */
static void NoDbgRegParms
putToSleepyieldingIf(sqInt _aProcess, sqInt _yieldImplicitly)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _firstLink;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _oop;
	sqInt _priority;
	sqInt _processList;
	sqInt _processLists;

	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	/* begin quickFetchInteger:ofObject: */
	/* begin fetchPointer:ofObject: */
	_oop = unsignedLongAt((_aProcess + BaseHeaderSize) + ((sqInt) (((usqInt) PriorityIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(((_oop & 7) == 1));
	_priority = _oop >> 3;
	/* end quickFetchInteger:ofObject: */
	if ((GIV(highestRunnableProcessPriority) != 0) && (_priority > GIV(highestRunnableProcessPriority))) {
		GIV(highestRunnableProcessPriority) = _priority;
	}
	/* begin fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	_processLists = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ProcessListsIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	_processList = unsignedLongAt((_processLists + BaseHeaderSize) + ((sqInt) (((usqInt) (_priority - 1) ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (_yieldImplicitly) {
		addLastLinktoList(_aProcess, _processList);
	} else {
		/* begin addFirstLink:toList: */
		assert(!(isForwarded(_processList)));
		assert((fetchPointerofObject(NextLinkIndex, _aProcess)) == (nilObject()));
		/* begin fetchPointer:ofObject: */
		_firstLink = unsignedLongAt((_processList + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert(_firstLink != _aProcess);
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_processList)));
		if (((_processList & (tagMask())) == 0) && ((_processList & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_aProcess & (tagMask())) == 0) && (((_aProcess & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_aProcess >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_processList)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _processList);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_processList)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l7;
		}
		if (_aProcess & (tagMask())) {
			goto l7;
		}
		if (!(_processList >= 0x20000000000LL)) {
			goto l7;
		}
		if (_aProcess >= 0x20000000000LL) {
			goto l7;
		}
		if ((_aProcess >= GIV(nilObj)) && (_aProcess <= GIV(trueObj))) {
			goto l7;
		}
		if (!(_aProcess >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l7;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _processList);
		l7:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_processList + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ), _aProcess);
		/* end storePointer:ofObject:withValue: */
		if (_firstLink == GIV(nilObj)) {
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(_processList)));
			if (((_processList & (tagMask())) == 0) && ((_processList & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((_aProcess & (tagMask())) == 0) && (((_aProcess & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_aProcess >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(_processList)) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), _processList);
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(_processList)) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l12;
			}
			if (_aProcess & (tagMask())) {
				goto l12;
			}
			if (!(_processList >= 0x20000000000LL)) {
				goto l12;
			}
			if (_aProcess >= 0x20000000000LL) {
				goto l12;
			}
			if ((_aProcess >= GIV(nilObj)) && (_aProcess <= GIV(trueObj))) {
				goto l12;
			}
			if (!(_aProcess >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l12;
			}
			remember(getFromPermToNewSpaceRememberedSet(), _processList);
			l12:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((_processList + BaseHeaderSize) + ((sqInt) (((usqInt) LastLinkIndex ) << (shiftForWord())) ), _aProcess);
			/* end storePointer:ofObject:withValue: */
		}
 else {
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(_aProcess)));
			if (((_aProcess & (tagMask())) == 0) && ((_aProcess & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((_firstLink & (tagMask())) == 0) && (((_firstLink & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_firstLink >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(_aProcess)) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), _aProcess);
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(_aProcess)) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l5;
			}
			if (_firstLink & (tagMask())) {
				goto l5;
			}
			if (!(_aProcess >= 0x20000000000LL)) {
				goto l5;
			}
			if (_firstLink >= 0x20000000000LL) {
				goto l5;
			}
			if ((_firstLink >= GIV(nilObj)) && (_firstLink <= GIV(trueObj))) {
				goto l5;
			}
			if (!(_firstLink >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l5;
			}
			remember(getFromPermToNewSpaceRememberedSet(), _aProcess);
			l5:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((_aProcess + BaseHeaderSize) + ((sqInt) (((usqInt) NextLinkIndex ) << (shiftForWord())) ), _firstLink);
			/* end storePointer:ofObject:withValue: */
		}
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_aProcess)));
		if (((_aProcess & (tagMask())) == 0) && ((_aProcess & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_processList & (tagMask())) == 0) && (((_processList & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_processList >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_aProcess)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _aProcess);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_aProcess)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l9;
		}
		if (_processList & (tagMask())) {
			goto l9;
		}
		if (!(_aProcess >= 0x20000000000LL)) {
			goto l9;
		}
		if (_processList >= 0x20000000000LL) {
			goto l9;
		}
		if ((_processList >= GIV(nilObj)) && (_processList <= GIV(trueObj))) {
			goto l9;
		}
		if (!(_processList >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l9;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _aProcess);
		l9:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_aProcess + BaseHeaderSize) + ((sqInt) (((usqInt) MyListIndex ) << (shiftForWord())) ), _processList);
		/* end storePointer:ofObject:withValue: */
		/* end addFirstLink:toList: */
	}
}
/*	Return the integer value of the field without verifying that it is an 
	integer value! For use in time-critical places where the integer-ness of 
	the field can be guaranteed. */
/* StackInterpreter>>#quickFetchInteger:ofObject: */
static sqInt NoDbgRegParms
quickFetchIntegerofObject(sqInt _fieldIndex, sqInt _objectPointer)
{
	sqInt _oop;

	/* begin fetchPointer:ofObject: */
	_oop = unsignedLongAt((_objectPointer + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(((_oop & 7) == 1));
	return _oop >> 3;
}
/*	Assuming the primFailCode is non-zero, check if the method consumes the 
	error code 
	and if so, assign it through theFP into the correct temporary variable. 
	Then zero the primFailCode. This is infrequent code, so keep it out of the 
	common path. */
/* StackInterpreter>>#reapAndResetErrorCodeTo:header: */
static sqInt NoDbgRegParms NeverInline
reapAndResetErrorCodeToheader(sqInt _theFP, sqInt _methodHeader)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classFormat;
	sqInt _classIndex;
	sqInt _classObj;
	usqInt _clone;
	usqInt _errObj;
	sqInt _frameNumArgs;
	sqInt _frameNumArgs2;
	sqInt _i;
	sqInt _initialPC;
	usqInt _newObj;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _objFormat;
	sqInt _objOop;
	sqInt _table;
	sqInt _temporaryIndex;
	sqInt _valueOop;
	sqInt _valuePointer;
	sqInt _valuePointer2;
	sqInt _valuePointer3;
	sqInt _valuePointer4;

	assert(GIV(primFailCode) != 0);
	_initialPC = ((GIV(newMethod) + ((LiteralStart + ((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask))) * BytesPerOop)) + BaseHeaderSize) + 3;
	if ((byteAt(_initialPC)) == LongStoreBytecode) {
		_temporaryIndex = byteAt(_initialPC + 1);
		/* begin temporary:in:put: */
		/* begin getErrorObjectFromPrimFailCode */
		if (GIV(primFailCode) > 0) {
			/* begin splObj: */
			/* begin fetchPointer:ofObject: */
			_table = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) PrimErrTableIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			/* end splObj: */
			if (GIV(primFailCode) <= (numSlotsOf(_table))) {
				/* begin followField:ofObject: */
				/* begin fetchPointer:ofObject: */
				_objOop = unsignedLongAt((_table + BaseHeaderSize) + ((sqInt) (((usqInt) (GIV(primFailCode) - 1) ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
					_objOop = fixFollowedFieldofObjectwithInitialValue(GIV(primFailCode) - 1, _table, _objOop);
				}
				_errObj = _objOop;
				/* end followField:ofObject: */
				if (((GIV(primFailCode) == PrimErrOSError) || (GIV(primFailCode) == PrimErrFFIException)) && ((((((usqInt) (longAt(_errObj)) ) >> (formatShift())) & (formatMask())) == 1) && (((_numSlots = numSlotsOf(_errObj))) >= 2))) {
					/* begin cloneOSErrorObj:numSlots: */
					/* begin eeInstantiateSmallClass:numSlots: */
					_classObj = fetchClassOfNonImm(_errObj);
					assert((rawHashBitsOf(_classObj)) != 0);
					/* begin eeInstantiateSmallClassIndex:format:numSlots: */
					_classIndex = (uint32AtPointer(_classObj + 4)) & (identityHashHalfWordMask());
					/* begin instSpecOfClassFormat: */
					_classFormat = (unsignedLongAt((_classObj + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
					_objFormat = (((usqInt) _classFormat ) >> (fixedFieldsFieldWidth())) & (formatMask());
					/* end instSpecOfClassFormat: */
					assert((_numSlots >= 0) && ((_classIndex != 0) && ((classAtIndex(_classIndex)) != GIV(nilObj))));
					assert((((_objFormat < (firstByteFormat()))
						 ? _objFormat
						 : _objFormat & (byteFormatMask()))) == (instSpecOfClass(classAtIndex(_classIndex))));
					/* begin allocateSmallNewSpaceSlots:format:classIndex: */
					assert(_numSlots < (numSlotsMask()));
					_newObj = GIV(freeStart);
					_numBytes = BaseHeaderSize + (((_numSlots < 1)
						 ? 8
						 : _numSlots * BytesPerOop));
					assert((_numBytes % (allocationUnit())) == 0);
					assert((_newObj % (allocationUnit())) == 0);
					if ((GIV(freeStart) + _numBytes) > GIV(scavengeThreshold)) {
						if (!GIV(needGCFlag)) {
							/* begin scheduleScavenge */
							GIV(needGCFlag) = 1;
							forceInterruptCheck();
							/* end scheduleScavenge */
						}
						if ((GIV(freeStart) + _numBytes) > (((eden()).limit))) {
							error("no room in eden for allocateSmallNewSpaceSlots:format:classIndex:");
							_clone = 0;
							goto l6;
						}
					}
					long64Atput(_newObj, ((((usqLong) _numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) _objFormat ) << (formatShift())) )) + _classIndex);
					GIV(freeStart) += _numBytes;
					_clone = _newObj;
					/* end allocateSmallNewSpaceSlots:format:classIndex: */
					/* end eeInstantiateSmallClassIndex:format:numSlots: */
					l6:
					;
					/* end eeInstantiateSmallClass:numSlots: */
					for (_i = 0; _i < _numSlots; _i += 1) {
						/* begin storePointerUnchecked:ofObject:withValue: */
						_valuePointer = unsignedLongAt((_errObj + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
						assert(!(isOopForwarded(_clone)));
						longAtput((_clone + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _valuePointer);
						/* end storePointerUnchecked:ofObject:withValue: */
					}
					if ((_numSlots > 2) && (GIV(primFailCode) == PrimErrFFIException)) {
						/* begin storePointerUnchecked:ofObject:withValue: */
						_valuePointer2 = positive64BitIntegerFor(((usqLong) GIV(osErrorCode) ));
						assert(!(isOopForwarded(_clone)));
						longAtput((_clone + BaseHeaderSize) + (1U << (shiftForWord())), _valuePointer2);
						/* end storePointerUnchecked:ofObject:withValue: */
						/* begin storePointerUnchecked:ofObject:withValue: */
						_valuePointer3 = positiveMachineIntegerFor(GIV(exceptionPC));
						assert(!(isOopForwarded(_clone)));
						longAtput((_clone + BaseHeaderSize) + (2U << (shiftForWord())), _valuePointer3);
						/* end storePointerUnchecked:ofObject:withValue: */
					} else {
						/* begin storePointerUnchecked:ofObject:withValue: */
						_valuePointer4 = signed64BitIntegerFor(GIV(osErrorCode));
						assert(!(isOopForwarded(_clone)));
						longAtput((_clone + BaseHeaderSize) + (1U << (shiftForWord())), _valuePointer4);
						/* end storePointerUnchecked:ofObject:withValue: */
					}
					_errObj = _clone;
					/* end cloneOSErrorObj:numSlots: */
				}
				_valueOop = _errObj;
				goto l13;
			}
		}
		_valueOop = ((((usqInt) GIV(primFailCode) ) << 3) | 1);
		l13:
		;
		/* end getErrorObjectFromPrimFailCode */
		if (isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) ))) {
			unsignedLongAtput(((_temporaryIndex < ((_frameNumArgs = ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs))))
				 ? (_theFP + FoxCallerSavedIP) + ((_frameNumArgs - _temporaryIndex) * BytesPerWord)
				 : ((_theFP + FoxMFReceiver) - BytesPerWord) + ((_frameNumArgs - _temporaryIndex) * BytesPerWord)), _valueOop);
		} else {
			if (_temporaryIndex < ((_frameNumArgs2 = byteAt((_theFP + FoxIFrameFlags) + 1)))) {
				unsignedLongAtput((_theFP + FoxCallerSavedIP) + ((_frameNumArgs2 - _temporaryIndex) * BytesPerWord), _valueOop);
			}
 else {
				unsignedLongAtput(((_theFP + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs2 - _temporaryIndex) * BytesPerWord), _valueOop);
			}
		}
		/* end temporary:in:put: */
		return 1;
	}
	GIV(primFailCode) = 0;
	return 0;
}
/*	Remove the first process from the given linked list. */
/* StackInterpreter>>#removeFirstLinkOfList: */
static sqInt NoDbgRegParms
removeFirstLinkOfList(sqInt _aList)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _first;
	sqInt _last;
	sqInt _next;
	sqInt _valuePointer;
	sqInt _valuePointer2;
	sqInt _valuePointer3;

	assert(!(isForwarded(_aList)));
	/* begin fetchPointer:ofObject: */
	_first = unsignedLongAt((_aList + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	_last = unsignedLongAt((_aList + BaseHeaderSize) + ((sqInt) (((usqInt) LastLinkIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(!(isForwarded(_first)));
	assert(!(isForwarded(_last)));
	if (_first == _last) {
		{
			/* begin storePointerUnchecked:ofObject:withValue: */
			_valuePointer = GIV(nilObj);
			assert(!(isOopForwarded(_aList)));
			longAtput((_aList + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ), _valuePointer);
			/* end storePointerUnchecked:ofObject:withValue: */
			/* begin storePointerUnchecked:ofObject:withValue: */
			_valuePointer2 = GIV(nilObj);
			assert(!(isOopForwarded(_aList)));
			longAtput((_aList + BaseHeaderSize) + ((sqInt) (((usqInt) LastLinkIndex ) << (shiftForWord())) ), _valuePointer2);
			/* end storePointerUnchecked:ofObject:withValue: */
		}
	} else {
		/* begin fetchPointer:ofObject: */
		_next = unsignedLongAt((_first + BaseHeaderSize) + ((sqInt) (((usqInt) NextLinkIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_aList)));
		if (((_aList & (tagMask())) == 0) && ((_aList & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_next & (tagMask())) == 0) && (((_next & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_next >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_aList)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _aList);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_aList)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l8;
		}
		if (_next & (tagMask())) {
			goto l8;
		}
		if (!(_aList >= 0x20000000000LL)) {
			goto l8;
		}
		if (_next >= 0x20000000000LL) {
			goto l8;
		}
		if ((_next >= GIV(nilObj)) && (_next <= GIV(trueObj))) {
			goto l8;
		}
		if (!(_next >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l8;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _aList);
		l8:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_aList + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ), _next);
		/* end storePointer:ofObject:withValue: */
	}
	/* begin storePointerUnchecked:ofObject:withValue: */
	_valuePointer3 = GIV(nilObj);
	assert(!(isOopForwarded(_first)));
	longAtput((_first + BaseHeaderSize) + ((sqInt) (((usqInt) NextLinkIndex ) << (shiftForWord())) ), _valuePointer3);
	/* end storePointerUnchecked:ofObject:withValue: */
	return _first;
}
/*	Make aProcess runnable and if its priority is higher than that of the 
	current process, preempt the current process. Answer if the current 
	process was preempted. If the current process was preempted then if 
	yieldImplicitly add the current process to the back of its run queue, 
	causing an implicit yeild to other processes on the run queue, otherwise 
	add the current process to the front of its run queue, hence not yielding. 
	Blue book behaviour is to yield implicitly but is arguably incorrect. 
	Override to add tracing info. */
/* StackInterpreter>>#resume:preemptedYieldingIf:from: */
static sqInt NoDbgRegParms
resumepreemptedYieldingIffrom(sqInt _aProcess, sqInt _yieldImplicitly, sqInt _sourceCode)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activePriority;
	sqInt _activeProc;
	sqInt _newPriority;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _oop;
	sqInt _oop2;

	/* begin memoryActiveProcess */
	/* begin fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	_activeProc = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end memoryActiveProcess */
	/* begin quickFetchInteger:ofObject: */
	/* begin fetchPointer:ofObject: */
	_oop = unsignedLongAt((_activeProc + BaseHeaderSize) + ((sqInt) (((usqInt) PriorityIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(((_oop & 7) == 1));
	_activePriority = _oop >> 3;
	/* end quickFetchInteger:ofObject: */
	/* begin quickFetchInteger:ofObject: */
	/* begin fetchPointer:ofObject: */
	_oop2 = unsignedLongAt((_aProcess + BaseHeaderSize) + ((sqInt) (((usqInt) PriorityIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(((_oop2 & 7) == 1));
	_newPriority = _oop2 >> 3;
	/* end quickFetchInteger:ofObject: */
	if (_newPriority <= _activePriority) {
		putToSleepyieldingIf(_aProcess, 1);
		return 0;
	}
	putToSleepyieldingIf(_activeProc, _yieldImplicitly);
	transferTofrom(_aProcess, _sourceCode);
	return 1;
}
/*	In Spur two cases of primitive failure are handled specially. A primitive 
	may fail due to validation 
	encountering a forwarder. On failure, check the accessorDepth for the 
	primitive and if non-negative 
	scan the args to the depth, following any forwarders. Retry the primitive 
	if any are found. Hence 
	lazily and transparently following forwarders on primtiive failure. 
	Additionally a prmitive might fail 
	due to an allocation failing. Retry if external primitives have failed 
	with PrimErrNoMemory after running 
	first the scavenger and then on a subsequent failure, the global 
	mark-sweep collector. Hence lazily 
	and transparently GC on memory exhaustion. */
/* StackInterpreter>>#retryPrimitiveOnFailure */
static sqInt
retryPrimitiveOnFailure(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _accessorDepth;
	sqInt _canRetry;
	sqInt _firstBytecode;
	sqInt _followDone;
	sqInt _found;
	sqInt _found2;
	int _gcDone;
	sqInt _header;
	sqInt _index;
	sqInt _methodHeader;
	sqInt _oop;
	sqInt _primIndex;
	sqInt _referent;
	int _retried;
	sqInt _retry;
	int _scannedStackFrame;

	_gcDone = 0;
	_followDone = (_canRetry = (_retried = 0));
	while (1) {
		_retry = 0;
		if (GIV(primFailCode) == PrimErrNoMemory) {
			if (((_gcDone += 1)) == 1) {
				_canRetry = (primitiveIndexOfMethodheader(GIV(newMethod), methodHeaderOf(GIV(newMethod)))) == PrimNumberExternalCall;
			}
			if (_canRetry) {
				if (_gcDone == 1) {
					/* begin scavengingGC */
					scavengingGCTenuringIf(TenureByAge);
					/* end scavengingGC */
				}
				if (_gcDone == 2) {
					fullGC();
				}
				_retry = _gcDone <= 2;
			}
		} else {
			if (!_followDone) {
				_followDone = 1;
				/* begin checkForAndFollowForwardedPrimitiveState */
				if (recordPrimTrace()) {
					/* begin fastLogPrim: */
					GIV(primTraceLog)[GIV(primTraceLogIndex)] = TracePrimitiveFailure;
					primTraceLogIndex(GIV(primTraceLogIndex) + 1);
					/* end fastLogPrim: */
				}
				{
					assert(failed());
					/* begin primitiveIndexOfMethod:header: */
					/* begin methodHeaderOf: */
					assert(isCompiledMethod(GIV(newMethod)));
					/* begin fetchPointer:ofObject: */
					_header = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (((_header & 7) == 1)) {
						_methodHeader = _header;
					} else {
						assert(((usqInt) _header ) < ((GIV(memoryMap)->newSpaceStart)));
						assert((((((CogMethod *) _header ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
						_methodHeader = ((((CogMethod *) _header ))->methodHeader);
					}
					/* end methodHeaderOf: */
					if (_methodHeader & AlternateHeaderHasPrimFlag) {
						_firstBytecode = (GIV(newMethod) + ((LiteralStart + ((_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) * BytesPerOop)) + BaseHeaderSize;
						_primIndex = (byteAt(_firstBytecode + 1)) + ((sqInt) (((usqInt) (byteAt(_firstBytecode + 2)) ) << 8) );
					} else {
						_primIndex = 0;
					}
					/* end primitiveIndexOfMethod:header: */
					assert((isMetaPrimitiveIndex(_primIndex)) || (GIV(argumentCount) == (argumentCountOf(GIV(newMethod)))));
					/* begin checkForAndFollowForwardedPrimitiveState: */
					if (((_primIndex == PrimNumberDoPrimitive) || (_primIndex == PrimNumberDoExternalCall)) && (GIV(metaAccessorDepth) > -2)) {
						_accessorDepth = GIV(metaAccessorDepth);
					} else {
						if ((_primIndex == PrimNumberExternalCall) && (primitiveFunctionPointer != primitiveExternalCall)) {
							_accessorDepth = (fetchPointerofObject(2, literalofMethod(0, GIV(newMethod)))) >> 3;
						} else {
							_accessorDepth = primitiveAccessorDepthTable[_primIndex];
						}
					}
					assert(saneFunctionPointerForFailureOfPrimIndex(_primIndex));
					/* begin followForwardedForAccessorDepth: */
					_found2 = (_scannedStackFrame = 0);
					assert((_accessorDepth >= -1) && (_accessorDepth <= 5));
					if (_accessorDepth >= 0) {
						for (_index = 0; _index <= GIV(argumentCount); _index += 1) {
							_oop = unsignedLongAt(GIV(stackPointer) + (_index * BytesPerWord));
							if ((_oop & (tagMask())) == 0) {
								if (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
									assert(_index < GIV(argumentCount));
									_found2 = 1;
									/* begin followForwarded: */
									assert(isUnambiguouslyForwarder(_oop));
									/* begin fetchPointer:ofMaybeForwardedObject: */
									_referent = unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())));
									/* end fetchPointer:ofMaybeForwardedObject: */
									while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
										/* begin fetchPointer:ofMaybeForwardedObject: */
										_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
										/* end fetchPointer:ofMaybeForwardedObject: */
									}
									_oop = _referent;
									/* end followForwarded: */
									unsignedLongAtput(GIV(stackPointer) + (_index * BytesPerWord), _oop);
									if (!_scannedStackFrame) {
										_scannedStackFrame = 1;
										followForwardedFrameContentsstackPointer(GIV(framePointer), GIV(stackPointer) + ((GIV(argumentCount) + 1) * BytesPerWord));
									}
								}
								if ((_accessorDepth > 0) && ((((_oop & (tagMask())) == 0) && (isAnyPointerFormat((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())))) && (followForwardedObjectFieldstoDepth(_oop, _accessorDepth)))) {
									_found2 = 1;
								}
							}
						}
					}
					_found = _found2;
					/* end followForwardedForAccessorDepth: */
					/* end checkForAndFollowForwardedPrimitiveState: */
				}
				if (_found && (recordPrimTrace())) {
					/* begin fastLogPrim: */
					GIV(primTraceLog)[GIV(primTraceLogIndex)] = TracePrimitiveRetry;
					primTraceLogIndex(GIV(primTraceLogIndex) + 1);
					/* end fastLogPrim: */
				}
				_retry = _found;
				/* end checkForAndFollowForwardedPrimitiveState */
			}
		}
		if (!_retry) 
			break;
		assert(GIV(primFailCode) != 0);
		_retried = 1;
		/* begin initPrimCall */
		GIV(primFailCode) = 0;
		/* end initPrimCall */
		/* begin dispatchFunctionPointer: */
		primitiveFunctionPointer();
		/* end dispatchFunctionPointer: */
	}
	return _retried;
}
/*	Safe version of methodClassOf: that deals with malformed compiled methods, 
	etc, and does not fixup forwarding pointers.. */
/* StackInterpreter>>#safeMethodClassOf: */
static sqInt NoDbgRegParms
safeMethodClassOf(sqInt _methodPointer)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _literal;
	sqInt _maybeClass;
	sqInt _offset;
	sqInt _referent;
	sqInt _referent2;

	/* begin literal:ofMethod: */
	_offset = (literalCountOfMethodHeader(methodHeaderOf(_methodPointer))) - 1;
	/* begin fetchPointer:ofObject: */
	_literal = unsignedLongAt((_methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset + LiteralStart) ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end literal:ofMethod: */
	if (((_literal & (tagMask())) == 0) && (((long64At(_literal)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(_literal));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_literal + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		_literal = _referent;
		/* end followForwarded: */
	}
	if (!((((_literal & (tagMask())) == 0) && (((((usqInt) (longAt(_literal)) ) >> (formatShift())) & (formatMask())) <= 5)) && ((numSlotsOf(_literal)) > ValueIndex))) {
		/* begin nilObject */
		return GIV(nilObj);
		/* end nilObject */
	}
	/* begin fetchPointer:ofObject: */
	_maybeClass = unsignedLongAt((_literal + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_maybeClass & (tagMask())) == 0) && (((long64At(_maybeClass)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(_maybeClass));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent2 = unsignedLongAt((_maybeClass + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent2 & (tagMask())) == 0) && (((long64At(_referent2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent2 = unsignedLongAt((_referent2 + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		_maybeClass = _referent2;
		/* end followForwarded: */
	}
	return _maybeClass;
}
/* StackInterpreter>>#saneFunctionPointerForFailureOfPrimIndex: */
static sqInt NoDbgRegParms
saneFunctionPointerForFailureOfPrimIndex(sqInt _primIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	void (*_basePrimitive)(void);

	/* begin functionPointerFor: */
	_basePrimitive = ((void (*)(void)) (((_primIndex > MaxPrimitiveIndex)
		 ? 0
		 : primitiveTable[_primIndex])) );
	/* end functionPointerFor: */
	return (primitiveFunctionPointer == _basePrimitive) || (((_basePrimitive == primitiveExternalCall) && (!(((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex))) || (((_primIndex == PrimNumberDoPrimitive) || (_primIndex == PrimNumberDoExternalCall)) && (GIV(metaAccessorDepth) > -2)));
}
/* StackInterpreter>>#setBreakMNUSelector: */
void
setBreakMNUSelector(char *_aString)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (((GIV(breakSelector) = _aString)) == null) {
		breakSelectorLength = MinSmallInteger;
	} else {
		breakSelectorLength = -(strlen(_aString));
	}
}
/* StackInterpreter>>#setBreakSelector: */
void
setBreakSelector(char *_aString)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (((GIV(breakSelector) = _aString)) == null) {
		breakSelectorLength = MinSmallInteger;
	} else {
		breakSelectorLength = strlen(_aString);
	}
}
/* StackInterpreter>>#setDesiredEdenBytes: */
sqInt
setDesiredEdenBytes(usqLong _bytes)
{
	desiredEdenBytes = _bytes;
	return 0;
}
/*	Set the number of bytes desired for a stack page. 
	This setting governs a compromise between overflow rate and latency in 
	divorcing a page. 
	Using this page size, we will accomodates a number of frames inside the 
	page. The minimum frame size is 7 slots in the StackInterpreter, and 6 
	slots in the CoInterpreter. 
	The maximum size is 56 + 7 slots in the StackInterpreter and 56 + 8 slots 
	in the CoInterpreter. 
	 
	For example,  
	- 4069 byte pages gives 256 slots in 64-bits 
	=>allowing between 4 to 32 frames in the CoInterpreter. */
/* StackInterpreter>>#setDesiredStackPageBytes: */
void
setDesiredStackPageBytes(sqInt _desiredBytes)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	GIV(desiredStackPageBytes) = _desiredBytes;
}
/* StackInterpreter>>#setMaxStacksToPrint: */
void
setMaxStacksToPrint(sqInt _anInteger)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	GIV(maxStacksToPrint) = _anInteger;
}
/* StackInterpreter>>#setNextWakeupUsecs: */
void
setNextWakeupUsecs(usqLong _value)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	GIV(nextWakeupUsecs) = _value;
}
/*	The low space semaphore is about to be signaled. Set the signalLowSpace 
	flag, and force an interrupt check. Save the currently active process in 
	the special 
	objects array so that the low space handler will be able to determine the 
	process that first triggered a low space condition. The image's low space 
	handler is expected 
	to nil out the special objects array slot when it handles the low space 
	condition.  */
/* StackInterpreter>>#setSignalLowSpaceFlagAndSaveProcess */
static void
setSignalLowSpaceFlagAndSaveProcess(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeProc;
	sqInt _lastSavedProcess;
	sqInt _objOop;
	sqInt _objOop2;

	/* begin signalLowSpace: */
	GIV(signalLowSpace) = 1;
	/* end signalLowSpace: */
	/* begin lowSpaceThreshold: */
	GIV(lowSpaceThreshold) = 0;
	assert(GIV(totalFreeOldSpace) >= GIV(lowSpaceThreshold));
	/* end lowSpaceThreshold: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_lastSavedProcess = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ProcessSignalingLowSpace ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	if (_lastSavedProcess == GIV(nilObj)) {
		/* begin memoryActiveProcess */
		/* begin fetchPointer:ofObject: */
		/* begin fetchPointer:ofObject: */
		/* begin splObj: */
		/* begin fetchPointer:ofObject: */
		_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		_activeProc = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end memoryActiveProcess */
		/* begin splObj:put: */
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(GIV(specialObjectsOop))));
		if (((GIV(specialObjectsOop) & (tagMask())) == 0) && ((GIV(specialObjectsOop) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_activeProc & (tagMask())) == 0) && (((_activeProc & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_activeProc >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), GIV(specialObjectsOop));
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l8;
		}
		if (_activeProc & (tagMask())) {
			goto l8;
		}
		if (!(GIV(specialObjectsOop) >= 0x20000000000LL)) {
			goto l8;
		}
		if (_activeProc >= 0x20000000000LL) {
			goto l8;
		}
		if ((_activeProc >= GIV(nilObj)) && (_activeProc <= GIV(trueObj))) {
			goto l8;
		}
		if (!(_activeProc >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l8;
		}
		remember(getFromPermToNewSpaceRememberedSet(), GIV(specialObjectsOop));
		l8:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ProcessSignalingLowSpace ) << (shiftForWord())) ), _activeProc);
		/* end storePointer:ofObject:withValue: */
		/* end splObj:put: */
	}
	forceInterruptCheck();
}
/* StackInterpreter>>#setTraceFlagOnContextsFramesPageIfNeeded: */
static void NoDbgRegParms
setTraceFlagOnContextsFramesPageIfNeeded(sqInt _aContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	void *_pointer;
	sqInt _senderOop;
	StackPage *_thePage;

	if (((((unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContextDuringGC(_aContext)))) {
		/* begin stackPageFor: */
		/* begin frameOfMarriedContext: */
		/* begin fetchPointer:ofObject: */
		_senderOop = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		{
			assert(((_senderOop & 7) == 1));
			_pointer = pointerForOop(_senderOop - 1);
		}
		/* end frameOfMarriedContext: */
		/* begin stackPageAt: */
		_thePage = stackPageAtpages((assert((((char *) _pointer ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _pointer ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_pointer, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
		/* end stackPageAt: */
		/* end stackPageFor: */
		assert((((_thePage->trace)) >= StackPageUnreached) && (((_thePage->trace)) <= StackPageTraced));
		if (((_thePage->trace)) == StackPageUnreached) {
			(_thePage->trace = StackPageReachedButUntraced);
		}
	}
}
/* StackInterpreter>>#shortPrintContext: */
static sqInt NoDbgRegParms
shortPrintContext(sqInt _aContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _home;
	sqInt _senderOop;
	char *_theFP;

	if (!(((_aContext & (tagMask())) == 0) && (((longAt(_aContext)) & (classIndexMask())) == ClassMethodContextCompactIndex))) {
		{
			printHex(_aContext);
			print(" is not a context");
			/* begin cr */
			print("\n");
			/* end cr */
		}
		return null;
	}
	GIV(printedStackFrames) += 1;
	if ((GIV(maxStacksToPrint) != 0) && (GIV(printedStackFrames) > GIV(maxStacksToPrint))) {
		if (!(GIV(maxStackMessagePrinted) == 1)) {
			{
				print("    ... more contexts ...");
				/* begin cr */
				print("\n");
				/* end cr */
			}
			GIV(maxStackMessagePrinted) = 1;
		}
		return null;
	}
	printHex(_aContext);
	if ((((unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
		if (checkIsStillMarriedContextcurrentFP(_aContext, GIV(framePointer))) {
			/* begin frameOfMarriedContext: */
			/* begin fetchPointer:ofObject: */
			_senderOop = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			{
				assert(((_senderOop & 7) == 1));
				_theFP = pointerForOop(_senderOop - 1);
			}
			/* end frameOfMarriedContext: */
			if (isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) ))) {
				print(" M (");
			}
 else {
				print(" I (");
			}
			{
				printHex(((usqIntptr_t) _theFP ));
				print(") ");
			}
		} else {
			print(" w ");
		}
	} else {
		print(" s ");
	}
	{
		_home = findHomeForContext(_aContext);
		if (_home == null) {
			print(" BOGUS CONTEXT (can't determine home)");
		}
 else {
			printActivationNameForreceiverisBlockfirstTemporary(fetchPointerofObject(MethodIndex, ((!_home)
				 ? _aContext
				 : _home)), ((_home == null)
				 ? (/* begin nilObject */ GIV(nilObj) /* end nilObject */)
				 : (/* begin fetchPointer:ofObject: */ unsignedLongAt((_home + BaseHeaderSize) + ((sqInt) (((usqInt) ReceiverIndex ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */)), _home != _aContext, unsignedLongAt((_home + BaseHeaderSize) + ((sqInt) (((usqInt) (0 + CtxtTempFrameStart) ) << (shiftForWord())) )));
		}
	}
	/* begin cr */
	print("\n");
	/* end cr */
	return 0;
}
/* StackInterpreter>>#shortPrintFrameAndCallers: */
static sqInt NoDbgRegParms
shortPrintFrameAndCallers(char *_theFP)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (!(((((usqInt) _theFP ) & (BytesPerWord - 1)) == 0) && ((((usqInt) _theFP ) >= ((usqInt) (GIV(stackBasePlus1) - 1) )) && (((usqInt) _theFP ) <= ((usqInt) GIV(pages) ))))) {
		return null;
	}
	shortPrintFrame(_theFP);
	if (!((unsignedLongAt(_theFP + FoxSavedFP)) == 0)) {
		shortPrintFrameAndCallers(pointerForOop(unsignedLongAt(_theFP + FoxSavedFP)));
	}
	return 0;
}
/*	use export: not api, so it won't be written to cointerp.h. cogit.c is 
	unaware of StackPage */
/* StackInterpreter>>#shortPrintFramesInPage: */
EXPORT(void)
shortPrintFramesInPage(StackPage *_thePage)
{
	printFrameAndCallersSPshort((_thePage->headFP), (_thePage->headSP), 1);
}
/* StackInterpreter>>#shortPrintFramesOnStackPageListInUse */
EXPORT(void)
shortPrintFramesOnStackPageListInUse(void)
{
	StackPage *_page;

	_page = mostRecentlyUsedPage();
	do {
		if (!(((_page->baseFP)) == 0)) {
			{
				print("page ");
				/* begin printHexPtrnp: */
				printHexnp(oopForPointer(_page));
				/* end printHexPtrnp: */
				/* begin cr */
				print("\n");
				/* end cr */
			}
			shortPrintFramesInPage(_page);
			/* begin cr */
			print("\n");
			/* end cr */
		}
	} while (((_page = (_page->prevPage))) != (mostRecentlyUsedPage()));
}
/* StackInterpreter>>#shortPrintFrame: */
static sqInt NoDbgRegParms
shortPrintFrame(char *_theFP)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _frameNumArgs;
	sqInt _frameNumArgs2;
	sqInt _mthd;
	sqInt _rcvr;

	GIV(printedStackFrames) += 1;
	if ((GIV(maxStacksToPrint) != 0) && (GIV(printedStackFrames) > GIV(maxStacksToPrint))) {
		if (!(GIV(maxStackMessagePrinted) == 1)) {
			{
				print("    ... more contexts ...");
				/* begin cr */
				print("\n");
				/* end cr */
			}
			GIV(maxStackMessagePrinted) = 1;
		}
		return null;
	}
	if (!(((((usqInt) _theFP ) & (BytesPerWord - 1)) == 0) && ((((usqInt) _theFP ) >= ((usqInt) (GIV(stackBasePlus1) - 1) )) && (((usqInt) _theFP ) <= ((usqInt) GIV(pages) ))))) {
		{
			print("invalid frame pointer");
			/* begin cr */
			print("\n");
			/* end cr */
		}
		return null;
	}
	_rcvr = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? unsignedLongAt(_theFP + FoxMFReceiver)
		 : unsignedLongAt(_theFP + FoxIFReceiver));
	_mthd = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((mframeHomeMethod(_theFP))->methodObject)
		 : unsignedLongAt(_theFP + FoxMethod));
	/* begin printHexPtr: */
	printHex(oopForPointer(_theFP));
	/* end printHexPtr: */
	/* begin space */
	printChar(' ');
	/* end space */
	printChar(((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? 'M'
		 : 'I'));
	/* begin space */
	printChar(' ');
	/* end space */
	printActivationNameForreceiverisBlockfirstTemporary(_mthd, _rcvr, ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagIsBlockFlag) != 0
		 : (byteAt((_theFP + FoxIFrameFlags) + 3)) != 0), ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((0 < ((_frameNumArgs = ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs))))
			 ? unsignedLongAt((_theFP + FoxCallerSavedIP) + (_frameNumArgs * BytesPerWord))
			 : unsignedLongAt(((((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
				 ? _theFP + FoxMFReceiver
				 : _theFP + FoxIFReceiver)) - BytesPerWord) + (_frameNumArgs * BytesPerWord)))
		 : ((0 < ((_frameNumArgs2 = byteAt((_theFP + FoxIFrameFlags) + 1))))
			 ? unsignedLongAt((_theFP + FoxCallerSavedIP) + (_frameNumArgs2 * BytesPerWord))
			 : unsignedLongAt(((_theFP + FoxIFReceiver) - BytesPerWord) + (_frameNumArgs2 * BytesPerWord)))));
	/* begin space */
	printChar(' ');
	/* end space */
	shortPrintOop(_rcvr);
	return 0;
}
/* StackInterpreter>>#shortPrintFrame:AndNCallers: */
void
shortPrintFrameAndNCallers(char *_theFP, sqInt _n)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin resetStackPrintedCount */
	GIV(printedStackFrames) = (GIV(maxStackMessagePrinted) = 0);
	/* end resetStackPrintedCount */
	if ((_n != 0) && (((((usqInt) _theFP ) & (BytesPerWord - 1)) == 0) && ((((usqInt) _theFP ) >= ((usqInt) (GIV(stackBasePlus1) - 1) )) && (((usqInt) _theFP ) <= ((usqInt) GIV(pages) ))))) {
		shortPrintFrame(_theFP);
		shortPrintFrameAndNCallers(pointerForOop(unsignedLongAt(_theFP + FoxSavedFP)), _n - 1);
	}
}
/* StackInterpreter>>#shortPrintOop: */
static sqInt NoDbgRegParms
shortPrintOop(sqInt _oop)
{
	printHexnp(_oop);
	if (_oop & (tagMask())) {
		if (((_oop & 7) == 1)) {
			vm_printf("=%ld\n", (long)integerValueOf(_oop));
		}
		if (_oop & (characterTag())) {
			vm_printf("=$%ld ($%lc)\n", (long)characterValueOf(_oop), (wint_t)characterValueOf(_oop));
		}
		if (_oop & (smallFloatTag())) {
			vm_printf("=%g\n", floatValueOf(_oop));
		}
		return 0;
	}
	if (!(addressCouldBeObj(_oop))) {
		return (print((((_oop & (8 - 1)) != 0)
			 ? " is misaligned"
			 : whereIs(_oop))), /* begin cr */ print("\n"), 1 /* end cr */);
	}
	if ((((longAt(_oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) || (((long64At(_oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		return printOop(_oop);
	}
	print(": a(n) ");
	printNameOfClasscount(fetchClassOfNonImm(_oop), 5);
	/* begin cr */
	print("\n");
	/* end cr */
	return 0;
}
/* StackInterpreter>>#shortReversePrintFrameAndCallers: */
static sqInt NoDbgRegParms
shortReversePrintFrameAndCallers(char *_aFramePointer)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _caller;
	sqInt _callerContextOrNil;
	char *_callerFP;
	sqInt _referent;
	char *_theFP;
	StackPage *_thePage;

	if (_aFramePointer == 0) {
		/* begin nilObject */
		return GIV(nilObj);
		/* end nilObject */
	}
	_theFP = _aFramePointer;
	while (1) {
		shortPrintFrame(_theFP);
		/* begin frameCallerFP: */
		_callerFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP));
		/* end frameCallerFP: */
		if (!(_callerFP != 0)) 
			break;
		_theFP = _callerFP;
	}
	/* begin frameCallerContext: */
	assert(isBaseFrame(_theFP));
	/* begin stackPageFor: */
	/* begin stackPageAt: */
	_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
	/* end stackPageAt: */
	/* end stackPageFor: */
	_callerContextOrNil = unsignedLongAt((_thePage->baseAddress));
	assert(addressCouldBeObj(_callerContextOrNil));
	assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
	_caller = _callerContextOrNil;
	/* end frameCallerContext: */
	if (((long64At(_caller)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(_caller));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_caller + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		_caller = _referent;
		/* end followForwarded: */
	}
	return _caller;
}
/*	Signal all requested semaphores. Answer if a context switch has occurred. */
/* StackInterpreter>>#signalExternalSemaphores */
static sqInt
signalExternalSemaphores(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _xArray;

	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_xArray = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ExternalObjectsArray ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	return doSignalExternalSemaphores(numSlotsOf(_xArray));
}
/*	Answer a full 32 bit integer object for the given integer value. 
	N.B. Returning in each arm separately enables Slang inlining. 
	/Don't/ return the ifTrue:ifFalse: unless Slang inlining of conditionals 
	is fixed. */
/* StackInterpreter>>#signed32BitIntegerFor: */
sqInt
signed32BitIntegerFor(sqInt _integerValue)
{
	{
		return ((((usqInt) ((int) _integerValue ) ) << 3) | 1);
	}
}
/*	Answer a Large Integer object for the given integer value. N.B. will *not* 
	cause a GC. */
/* StackInterpreter>>#signed64BitIntegerFor: */
sqInt
signed64BitIntegerFor(sqLong _integerValue)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _largeClass;
	usqLong _magnitude;
	usqInt _newLargeInteger;
	usqInt _newObj;
	usqInt _numBytes;
	sqInt _numSlots;
	sqInt _objFormat;
	int _sz;
	sqLong _value;

	if (_integerValue < 0) {
		if (_integerValue >= MinSmallInteger) {
			return ((((usqInt) ((sqInt) _integerValue ) ) << 3) | 1);
		}
		_largeClass = ClassLargeNegativeIntegerCompactIndex;
		_magnitude = 0 - ((usqLong) _integerValue );
	} else {
		if (_integerValue <= MaxSmallInteger) {
			return ((((usqInt) ((sqInt) _integerValue ) ) << 3) | 1);
		}
		_largeClass = ClassLargePositiveIntegerCompactIndex;
		_magnitude = _integerValue;
	}
	{
		_sz = 8;
	}
	/* begin eeInstantiateSmallClassIndex:format:numSlots: */
	_objFormat = (firstByteFormat()) + ((8 - _sz) & (BytesPerWord - 1));
	_numSlots = (_sz + 3) / BytesPerOop;
	assert((_numSlots >= 0) && ((_largeClass != 0) && ((classAtIndex(_largeClass)) != GIV(nilObj))));
	assert((((_objFormat < (firstByteFormat()))
		 ? _objFormat
		 : _objFormat & (byteFormatMask()))) == (instSpecOfClass(classAtIndex(_largeClass))));
	/* begin allocateSmallNewSpaceSlots:format:classIndex: */
	assert(_numSlots < (numSlotsMask()));
	_newObj = GIV(freeStart);
	_numBytes = BaseHeaderSize + (((_numSlots < 1)
		 ? 8
		 : _numSlots * BytesPerOop));
	assert((_numBytes % (allocationUnit())) == 0);
	assert((_newObj % (allocationUnit())) == 0);
	if ((GIV(freeStart) + _numBytes) > GIV(scavengeThreshold)) {
		if (!GIV(needGCFlag)) {
			/* begin scheduleScavenge */
			GIV(needGCFlag) = 1;
			forceInterruptCheck();
			/* end scheduleScavenge */
		}
		if ((GIV(freeStart) + _numBytes) > (((eden()).limit))) {
			error("no room in eden for allocateSmallNewSpaceSlots:format:classIndex:");
			_newLargeInteger = 0;
			goto l3;
		}
	}
	long64Atput(_newObj, ((((usqLong) _numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) _objFormat ) << (formatShift())) )) + _largeClass);
	GIV(freeStart) += _numBytes;
	_newLargeInteger = _newObj;
	/* end allocateSmallNewSpaceSlots:format:classIndex: */
	l3:
	;
	/* end eeInstantiateSmallClassIndex:format:numSlots: */
	/* begin storeLong64:ofObject:withValue: */
	_value = SQ_SWAP_8_BYTES_IF_BIGENDIAN(_magnitude);
	long64Atput((_newLargeInteger + BaseHeaderSize) + (0U << 3), _value);
	/* end storeLong64:ofObject:withValue: */
	return _newLargeInteger;
}
/*	Answer the size of the CallPrimitive bytecode that may be used to store a 
	method's primitive. 
	SistaV1:		248	11111000 iiiiiiii	mssjjjjj	Call Primitive #iiiiiiii + ( 
	jjjjj * 256) */
/* StackInterpreter>>#sizeOfCallPrimitiveBytecode: */
sqInt
sizeOfCallPrimitiveBytecode(sqInt methodHeader)
{
	return 3;
}
/*	234		11101010	i i i i i i i i	Store Temporary Variable #iiiiiiii129 10000001 jjkkkkkk Store (Receiver Variable, Temporary Location, 
	Illegal, Literal Variable) [jj] #kkkkkk */
/* StackInterpreter>>#sizeOfLongStoreTempBytecode: */
sqInt
sizeOfLongStoreTempBytecode(sqInt methodHeader)
{
	return 2;
}
/*	Return the number of indexable fields of the given object. This method is 
	to be called from an automatically generated C primitive. The argument is 
	assumed to be a pointer to the first indexable field of a words or bytes 
	object; the object header starts 4 bytes before that.Note: Only called by translated primitive code. */
/* StackInterpreter>>#sizeOfSTArrayFromCPrimitive: */
sqInt
sizeOfSTArrayFromCPrimitive(void *_cPtr)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _fmt;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _oop;

	_oop = (oopForPointer(_cPtr)) - BaseHeaderSize;
	if (!(((_oop & (tagMask())) == 0) && (isPureBitsFormat((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask()))))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	/* begin lengthOf:format: */
	_fmt = (((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOfAny: */
	_numSlots2 = byteAt(_oop + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_oop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOfAny: */
	if (_fmt <= 5) {
		return _numSlots;
	}
	if (_fmt >= (firstByteFormat())) {
		return (_numSlots << (shiftForWord())) - (_fmt & 7);
	}
	if (_fmt >= (firstShortFormat())) {
		return (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
	}
	if (_fmt >= (firstLongFormat())) {
		return (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		return _numSlots;
	}
	return 0;
	/* end lengthOf:format: */
}
/* StackInterpreter>>#space */
static void
space(void)
{
	printChar(' ');
}
/* StackInterpreter>>#specialSelectorNumArgs: */
sqInt
specialSelectorNumArgs(sqInt _index)
{
	return (fetchPointerofObject((_index * 2) + 1, splObj(SpecialSelectors))) >> 3;
}
/* StackInterpreter>>#specialSelector: */
sqInt
specialSelector(sqInt _index)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _objOop;

	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SpecialSelectors ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	return unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) (_index * 2) ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
}
/*	In the StackInterpreter stacks grow down. */
/* StackInterpreter>>#stackFloatValue: */
double
stackFloatValue(sqInt _offset)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return floatValueOf(unsignedLongAt(GIV(stackPointer) + (_offset * BytesPerWord)));
}
/*	In the StackInterpreter stacks grow down. */
/* StackInterpreter>>#stackIntegerValue: */
sqInt
stackIntegerValue(sqInt _offset)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerPointer;

	_integerPointer = unsignedLongAt(GIV(stackPointer) + (_offset * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		return _integerPointer >> 3;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	/* end checkedIntegerValueOf: */
}
/*	Answer the actual stackLimit offset in a page. Since stackPageByteSize may 
	have chosen to shrink a page 
	this may be less than stackPageFrameBytes, but it should be no more than 
	stackPageFrameBytes.  */
/* StackInterpreter>>#stackLimitBytes */
static sqInt
stackLimitBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((GIV(desiredStackPageBytes) < (((stackPageByteSize()) - ((IFrameSlots + 64) * BytesPerWord)) - (osCogStackPageHeadroom()))) ? GIV(desiredStackPageBytes) : ((stackPageByteSize()) - ((IFrameSlots + 64) * BytesPerWord)) - (osCogStackPageHeadroom()));
}
/*	Answer the amount of slots needed to fit a new frame at the point the 
	stack limit is checked. A frame looks like this at the point the stack 
	limit is checked: 
	stacked receiver/closure 
	arg0 
	... 
	argN 
	caller's method ip/base frame's sender context 
	fp->	saved fp 
	method 
	context (uninitialized?) 
	method header fields (interpreter only) 
	saved method ip (uninitialized?; interpreter only when JIT VM) 
	receiver 
	first temp 
	... 
	sp->	Nth temp 
	So the amount of headroom is 
	the maximum number of arguments + 1 (for stacked receiver and arguments) 
	+ the frame size 
	+ the max number of temps. 
	Since a method's number of temps includes its arguments the actual offset 
	is:  */
/* StackInterpreter>>#stackLimitOffset */
static sqInt
stackLimitOffset(void)
{
	return (IFrameSlots + 64) * BytesPerWord;
}
/*	Ensures that the given object is a real object, not a SmallInteger.In the StackInterpreter stacks grow down. */
/* StackInterpreter>>#stackObjectValue: */
sqInt
stackObjectValue(sqInt _offset)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _oop;

	_oop = unsignedLongAt(GIV(stackPointer) + (_offset * BytesPerWord));
	if (_oop & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return null;
	}
	return _oop;
}
/*	Answer a page size that is a power-of-two and contains a useful number of 
	frames. Room for 256 slots for frames gives around 40 frames a page which 
	is a 
	good compromise between overflow rate and latency in divorcing a page. */
/* StackInterpreter>>#stackPageByteSize */
static sqInt
stackPageByteSize(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _pageBytes;

	_pageBytes = (GIV(desiredStackPageBytes) + ((IFrameSlots + 64) * BytesPerWord)) + (osCogStackPageHeadroom());
	if ((_pageBytes & (_pageBytes - 1)) == 0) {
		return _pageBytes;
	}
	return 1ULL << (highBit(_pageBytes));
}
/*	Return the stackPointer of a Context or BlockContext. */
/* StackInterpreter>>#stackPointerForMaybeMarriedContext: */
static sqInt NoDbgRegParms
stackPointerForMaybeMarriedContext(sqInt _aContext)
{
	sqInt _sp;
	sqInt _sp2;

	if (((((unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_aContext)))) {
		_sp = stackPointerIndexForFrame(frameOfMarriedContext(_aContext));
		assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_aContext)));
		return _sp;
	}
	/* begin fetchStackPointerOf: */
	/* begin fetchPointer:ofObject: */
	_sp2 = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (!(((_sp2 & 7) == 1))) {
		return 0;
	}
	assert((ReceiverIndex + (_sp2 >> 3)) < (lengthOf(_aContext)));
	return _sp2 >> 3;
	/* end fetchStackPointerOf: */
}
/*	Return the 0-based index rel to the given frame. 
	(This is what stackPointer used to be before conversion to pointer)In the StackInterpreter stacks grow down. */
/* StackInterpreter>>#stackPointerIndexForFrame: */
static sqInt NoDbgRegParms
stackPointerIndexForFrame(char *_theFP)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	StackPage *_thePage;
	char *_theSP;

	/* begin stackPageFor: */
	/* begin stackPageAt: */
	_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
	/* end stackPageAt: */
	/* end stackPageFor: */
	_theSP = findSPOfon(_theFP, _thePage);
	return (((usqInt) ((((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? _theFP + FoxMFReceiver
		 : _theFP + FoxIFReceiver)) - _theSP) ) >> (shiftForWord())) + (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
		 : byteAt((_theFP + FoxIFrameFlags) + 1)));
}
/*	In the StackInterpreter stacks grow down. */
/* StackInterpreter>>#stackPositiveMachineIntegerValue: */
usqIntptr_t
stackPositiveMachineIntegerValue(sqInt _offset)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _bs;
	sqInt _ccIndex;
	sqInt _classOop;
	sqInt _fmt;
	sqInt _integerPointer;
	sqInt _ok;
	sqInt _value;

	_integerPointer = unsignedLongAt(GIV(stackPointer) + (_offset * BytesPerWord));
	/* begin positiveMachineIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_value = _integerPointer >> 3;
		if (_value < 0) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			return null;
			/* end primitiveFail */
		}
		return _value;
	}
	if (_integerPointer & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(_integerPointer)));
	/* begin classIndexOf: */
	_ccIndex = (longAt(_integerPointer)) & (classIndexMask());
	/* end classIndexOf: */
	{
		_ok = ClassLargePositiveIntegerCompactIndex == _ccIndex;
		goto l3;
	}
	l3:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (!_ok) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	/* begin numBytesOfBytes: */
	_fmt = (((usqInt) (longAt(_integerPointer)) ) >> (formatShift())) & (formatMask());
	assert(_fmt >= (firstByteFormat()));
	_bs = ((numSlotsOf(_integerPointer)) << (shiftForWord())) - (_fmt & 7);
	/* end numBytesOfBytes: */
	if (_bs > (sizeof(usqIntptr_t))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return 0;
	}
	if (((sizeof(usqIntptr_t)) == 8) && (_bs > 4)) {
		return SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((_integerPointer + BaseHeaderSize) + (0U << 3)));
	}
 else {
		return ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_integerPointer + BaseHeaderSize) + (0U << 2)))) );
	}
	/* end positiveMachineIntegerValueOf: */
}
/*	In the StackInterpreter stacks grow down. */
/* StackInterpreter>>#stackSignedMachineIntegerValue: */
sqIntptr_t
stackSignedMachineIntegerValue(sqInt _offset)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerPointer;

	_integerPointer = unsignedLongAt(GIV(stackPointer) + (_offset * BytesPerWord));
	return signedMachineIntegerValueOf(_integerPointer);
}
/* StackInterpreter>>#stackTop */
sqInt
stackTop(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return unsignedLongAt(GIV(stackPointer));
}
/*	In the StackInterpreter stacks grow down. */
/* StackInterpreter>>#stackValue: */
sqInt
stackValue(sqInt _offset)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return unsignedLongAt(GIV(stackPointer) + (_offset * BytesPerWord));
}
/*	Answer the zero-relative index to the initial byte for a method. 
	Zero-relative version of CompiledMethod>>startpc. */
/* StackInterpreter>>#startPCOfMethodHeader: */
sqInt
startPCOfMethodHeader(sqInt _methodHeader)
{
	return (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) + LiteralStart) * BytesPerOop;
}
/*	Zero-relative version of CompiledMethod>>startpc. */
/* StackInterpreter>>#startPCOfMethod: */
sqInt
startPCOfMethod(sqInt _aCompiledMethod)
{
	return ((literalCountOfMethodHeader(methodHeaderOf(_aCompiledMethod))) + LiteralStart) * BytesPerOop;
}
/*	Return what ST would return for <obj> at: index. */
/* StackInterpreter>>#stObject:at: */
sqInt
stObjectat(sqInt _array, sqInt _index)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _class;
	sqInt _classFormat;
	sqInt _fixedFields;
	sqInt _fmt;
	unsigned int _integerValue;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _reasonCode;
	sqInt _sp;
	sqInt _sp2;
	sqInt _stSize;
	sqInt _totalLength;

	_fmt = (((usqInt) (longAt(_array)) ) >> (formatShift())) & (formatMask());
	/* begin lengthOf:format: */
	/* begin numSlotsOfAny: */
	_numSlots2 = byteAt(_array + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_array - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOfAny: */
	if (_fmt <= 5) {
		_totalLength = _numSlots;
		goto l4;
	}
	if (_fmt >= (firstByteFormat())) {
		_totalLength = (_numSlots << (shiftForWord())) - (_fmt & 7);
		goto l4;
	}
	if (_fmt >= (firstShortFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
		goto l4;
	}
	if (_fmt >= (firstLongFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
		goto l4;
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		_totalLength = _numSlots;
		goto l4;
	}
	_totalLength = 0;
	l4:
	;
	/* end lengthOf:format: */
	/* begin fixedFieldsOf:format:length: */
	if ((_fmt >= (sixtyFourBitIndexableFormat())) || (_fmt == 2)) {
		_fixedFields = 0;
		goto l5;
	}
	if (_fmt < 2) {
		_fixedFields = _totalLength;
		goto l5;
	}
	_class = fetchClassOfNonImm(_array);
	/* begin fixedFieldsOfClassFormat: */
	_classFormat = (unsignedLongAt((_class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	_fixedFields = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	/* end fixedFieldsOfClassFormat: */
	l5:
	;
	/* end fixedFieldsOf:format:length: */
	if ((_fmt == (indexablePointersFormat())) && (((long64At(_array)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
		/* begin stackPointerForMaybeMarriedContext: */
		if (((((unsignedLongAt((_array + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_array)))) {
			_sp = stackPointerIndexForFrame(frameOfMarriedContext(_array));
			assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_array)));
			_stSize = _sp;
			goto l7;
		}
		/* begin fetchStackPointerOf: */
		/* begin fetchPointer:ofObject: */
		_sp2 = unsignedLongAt((_array + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (!(((_sp2 & 7) == 1))) {
			_stSize = 0;
			goto l7;
		}
		assert((ReceiverIndex + (_sp2 >> 3)) < (lengthOf(_array)));
		_stSize = _sp2 >> 3;
		/* end fetchStackPointerOf: */
		l7:
		;
		/* end stackPointerForMaybeMarriedContext: */
		if ((oopisGreaterThanOrEqualTo(_index, 1)) && ((oopisLessThanOrEqualTo(_index, _stSize)) && (((((unsignedLongAt((_array + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_array)))))) {
			return noInlineTemporaryin(_index - 1, frameOfMarriedContext(_array));
		}
	} else {
		_stSize = _totalLength - _fixedFields;
	}
	if ((oopisGreaterThanOrEqualTo(_index, ((_fmt >= (firstCompiledMethodFormat()))
		 ? (((literalCountOf(_array)) + LiteralStart) * BytesPerOop) + 1
		 : 1))) && (oopisLessThanOrEqualTo(_index, _stSize))) {
		/* begin subscript:with:format: */
		if (_fmt <= 5) {
			/* begin fetchPointer:ofObject: */
			return unsignedLongAt((_array + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
		}
		if (_fmt >= (firstByteFormat())) {
			return ((((usqInt) (byteAt((_array + BaseHeaderSize) + ((_index + _fixedFields) - 1))) ) << 3) | 1);
		}
		if (_fmt >= (firstShortFormat())) {
			return ((((usqInt) ((unsigned short) (shortAt((_array + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 1) ))) ) ) << 3) | 1);
		}
		if (_fmt == (sixtyFourBitIndexableFormat())) {
			return positive64BitIntegerFor(long64At((_array + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 3) )));
		}
		/* begin positive32BitIntegerFor: */
		_integerValue = long32At((_array + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 2) ));
		{
			return (((((usqInt) _integerValue ) & 0xFFFFFFFFU) << 3) | 1);
		}
		/* end positive32BitIntegerFor: */
		/* end subscript:with:format: */
	}
	/* begin primitiveFailFor: */
	_reasonCode = ((_fmt <= 1)
		 ? PrimErrBadReceiver
		 : PrimErrBadIndex);
	GIV(primFailCode) = _reasonCode;
	/* end primitiveFailFor: */
	return 0;
}
/*	Do what ST would return for <obj> at: index put: value. */
/* StackInterpreter>>#stObject:at:put: */
sqInt
stObjectatput(sqInt _array, sqInt _index, sqInt _value)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _class;
	sqInt _classFormat;
	sqInt _fixedFields;
	sqInt _fmt;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _reasonCode;
	sqInt _signedValueToStore;
	sqInt _stSize;
	sqInt _totalLength;
	usqLong _unsigned64BitValueToStore;
	unsigned int _unsignedValueToStore;

	if (((long64At(_array)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadReceiver);
		/* end primitiveFailFor: */
	}
	_fmt = (((usqInt) (longAt(_array)) ) >> (formatShift())) & (formatMask());
	/* begin lengthOf:format: */
	/* begin numSlotsOfAny: */
	_numSlots2 = byteAt(_array + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_array - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOfAny: */
	if (_fmt <= 5) {
		_totalLength = _numSlots;
		goto l4;
	}
	if (_fmt >= (firstByteFormat())) {
		_totalLength = (_numSlots << (shiftForWord())) - (_fmt & 7);
		goto l4;
	}
	if (_fmt >= (firstShortFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
		goto l4;
	}
	if (_fmt >= (firstLongFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
		goto l4;
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		_totalLength = _numSlots;
		goto l4;
	}
	_totalLength = 0;
	l4:
	;
	/* end lengthOf:format: */
	/* begin fixedFieldsOf:format:length: */
	if ((_fmt >= (sixtyFourBitIndexableFormat())) || (_fmt == 2)) {
		_fixedFields = 0;
		goto l5;
	}
	if (_fmt < 2) {
		_fixedFields = _totalLength;
		goto l5;
	}
	_class = fetchClassOfNonImm(_array);
	/* begin fixedFieldsOfClassFormat: */
	_classFormat = (unsignedLongAt((_class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	_fixedFields = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	/* end fixedFieldsOfClassFormat: */
	l5:
	;
	/* end fixedFieldsOf:format:length: */
	_stSize = _totalLength - _fixedFields;
	if ((oopisGreaterThanOrEqualTo(_index, ((_fmt >= (firstCompiledMethodFormat()))
		 ? (((literalCountOf(_array)) + LiteralStart) * BytesPerOop) + 1
		 : 1))) && (oopisLessThanOrEqualTo(_index, _stSize))) {
		/* begin subscript:with:storing:format: */
		if (_fmt <= 5) {
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(_array)));
			if (((_array & (tagMask())) == 0) && ((_array & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((_value & (tagMask())) == 0) && (((_value & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_value >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(_array)) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), _array);
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(_array)) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l6;
			}
			if (_value & (tagMask())) {
				goto l6;
			}
			if (!(_array >= 0x20000000000LL)) {
				goto l6;
			}
			if (_value >= 0x20000000000LL) {
				goto l6;
			}
			if ((_value >= GIV(nilObj)) && (_value <= GIV(trueObj))) {
				goto l6;
			}
			if (!(_value >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l6;
			}
			remember(getFromPermToNewSpaceRememberedSet(), _array);
			l6:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((_array + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << (shiftForWord())) ), _value);
			/* end storePointer:ofObject:withValue: */
			goto l12;
		}
		if (_fmt >= (firstByteFormat())) {
			if (!(((_value & 7) == 1))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l12;
			}
			_signedValueToStore = _value >> 3;
			if (!((_signedValueToStore >= 0) && (_signedValueToStore <= 0xFF))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l12;
			}
			/* begin storeByte:ofObject:withValue: */
			byteAtput((_array + BaseHeaderSize) + ((_index + _fixedFields) - 1), _signedValueToStore);
			/* end storeByte:ofObject:withValue: */
			goto l12;
		}
		if (_fmt >= (firstShortFormat())) {
			if (!(((_value & 7) == 1))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l12;
			}
			_signedValueToStore = _value >> 3;
			if (!((_signedValueToStore >= 0) && (_signedValueToStore <= 0xFFFF))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l12;
			}
			/* begin storeShort16:ofObject:withValue: */
			shortAtput((_array + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 1) ), _signedValueToStore);
			/* end storeShort16:ofObject:withValue: */
			goto l12;
		}
		if (_fmt == (sixtyFourBitIndexableFormat())) {
			_unsigned64BitValueToStore = positive64BitValueOf(_value);
			if (!GIV(primFailCode)) {
				/* begin storeLong64:ofObject:withValue: */
				long64Atput((_array + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 3) ), _unsigned64BitValueToStore);
				/* end storeLong64:ofObject:withValue: */
			}
			goto l12;
		}
		_unsignedValueToStore = positive32BitValueOf(_value);
		if (!GIV(primFailCode)) {
			/* begin storeLong32:ofObject:withValue: */
			uint32AtPointerput((_array + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 2) ), _unsignedValueToStore);
			/* end storeLong32:ofObject:withValue: */
		}
		l12:
		;
		/* end subscript:with:storing:format: */
	} else {
		/* begin primitiveFailFor: */
		_reasonCode = ((_fmt <= 1)
			 ? PrimErrBadReceiver
			 : PrimErrBadIndex);
		GIV(primFailCode) = _reasonCode;
		/* end primitiveFailFor: */
	}
	return _value;
}
/*	Note: May be called by translated primitive code. */
/* StackInterpreter>>#storeInteger:ofObject:withValue: */
sqInt
storeIntegerofObjectwithValue(sqInt _fieldIndex, sqInt _objectPointer, sqInt _integerValue)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if ((((((usqInt) _integerValue ) >> 60) + 1) & 15) <= 1) {
		/* begin storePointerUnchecked:ofObject:withValue: */
		assert(!(isOopForwarded(_objectPointer)));
		longAtput((_objectPointer + BaseHeaderSize) + ((sqInt) (((usqInt) _fieldIndex ) << (shiftForWord())) ), ((((usqInt) _integerValue ) << 3) | 1));
		/* end storePointerUnchecked:ofObject:withValue: */
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
	}
	return null;
}
/*	Set the sender of a frame. If the frame is a base frame then this is 
	trivial; merely store into the FoxCallerSavedIP/FoxCallerContext field. If 
	not, then 
	split the stack at the frame, moving the frame and those hotter than it to 
	a new stack page. In the new stack page the frame will be the base frame 
	and storing trivial. Answer the possibly changed location of theFP. */
/* StackInterpreter>>#storeSenderOfFrame:withValue: */
static char * NoDbgRegParms
storeSenderOfFramewithValue(char *_theFP, sqInt _anOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _callerContextOrNil;
	char *_callerFP;
	StackPage *_lruOrFree;
	StackPage *_newPage;
	int _onCurrentPage;
	char *_theMovedFP;
	StackPage *_thePage;
	StackPage *_thePage2;

	if ((unsignedLongAt(_theFP + FoxSavedFP)) == 0) {
		/* begin frameCallerContext:put: */
		assert((_anOop == (nilObject())) || (isContext(_anOop)));
		assert(isBaseFrame(_theFP));
		assert(((_theFP + (frameStackedReceiverOffset(_theFP))) + (2 * BytesPerWord)) == (((stackPageFor(_theFP))->baseAddress)));
		{
			assert((longAt((_theFP + (frameStackedReceiverOffset(_theFP))) + BytesPerWord)) == (frameContext(_theFP)));
		}
		longAtput((_theFP + (frameStackedReceiverOffsetNumArgs(((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
			 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
			 : byteAt((_theFP + FoxIFrameFlags) + 1))))) + (2 * BytesPerWord), _anOop);
		/* end frameCallerContext:put: */
		return _theFP;
	}
	/* begin ensureCallerContext: */
	_callerFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP));
	if (_callerFP == 0) {
		/* begin frameCallerContext: */
		assert(isBaseFrame(_theFP));
		/* begin stackPageFor: */
		/* begin stackPageAt: */
		_thePage2 = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
		/* end stackPageAt: */
		/* end stackPageFor: */
		_callerContextOrNil = unsignedLongAt((_thePage2->baseAddress));
		assert(addressCouldBeObj(_callerContextOrNil));
		assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
		goto l7;
		/* end frameCallerContext: */
	}
	/* begin ensureFrameIsMarried:SP: */
	if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_callerFP + FoxMethod)) )))
		 ? ((unsignedLongAt(_callerFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
		 : (byteAt((_callerFP + FoxIFrameFlags) + 2)) != 0)) {
		assert(isContext(frameContext(_callerFP)));
		unsignedLongAt(_callerFP + FoxThisContext);
		goto l7;
	}
	marryFrameSP(_callerFP, (assert(!(isBaseFrame(_theFP))), (_theFP + (frameStackedReceiverOffset(_theFP))) + BytesPerWord));
	/* end ensureFrameIsMarried:SP: */
	l7:
	;
	/* end ensureCallerContext: */
	/* begin stackPageFor: */
	/* begin stackPageAt: */
	_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
	/* end stackPageAt: */
	/* end stackPageFor: */
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	_onCurrentPage = _thePage == GIV(stackPage);
	if (!_onCurrentPage) {
		markStackPageNextMostRecentlyUsed(_thePage);
	}
	/* begin newStackPage */
	_lruOrFree = (GIV(mostRecentlyUsedPage)->nextPage);
	if (((_lruOrFree->baseFP)) == 0) {
		_newPage = _lruOrFree;
		goto l2;
	}
	divorceFramesIn(_lruOrFree);
	_newPage = _lruOrFree;
	l2:
	;
	/* end newStackPage */
	_theMovedFP = moveFramesInthroughtoPage(_thePage, _theFP, _newPage);
	if (_onCurrentPage) {
		/* begin setStackPageAndLimit: */
		assert(_newPage != 0);
		GIV(stackPage) = _newPage;
		if (GIV(stackLimit) != ((char *) ((usqInt) -1 ) )) {
			GIV(stackLimit) = (GIV(stackPage)->stackLimit);
		}
		markStackPageMostRecentlyUsed(_newPage);
		/* end setStackPageAndLimit: */
	} else {
		markStackPageMostRecentlyUsed(_newPage);
	}
	assert(isBaseFrame(_theMovedFP));
	/* begin frameCallerContext:put: */
	assert((_anOop == (nilObject())) || (isContext(_anOop)));
	assert(isBaseFrame(_theMovedFP));
	assert(((_theMovedFP + (frameStackedReceiverOffset(_theMovedFP))) + (2 * BytesPerWord)) == (((stackPageFor(_theMovedFP))->baseAddress)));
	{
		assert((longAt((_theMovedFP + (frameStackedReceiverOffset(_theMovedFP))) + BytesPerWord)) == (frameContext(_theMovedFP)));
	}
	longAtput((_theMovedFP + (frameStackedReceiverOffsetNumArgs(((isMachineCodeIP(((usqInt) (unsignedLongAt(_theMovedFP + FoxMethod)) )))
		 ? ((((CogMethod *) ((unsignedLongAt(_theMovedFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
		 : byteAt((_theMovedFP + FoxIFrameFlags) + 1))))) + (2 * BytesPerWord), _anOop);
	/* end frameCallerContext:put: */
	return _theMovedFP;
}
/*	Return the number of indexable fields in the given object. (i.e., what 
	Smalltalk would return for <obj> size).Note: Assume oop is not a SmallInteger! */
/* StackInterpreter>>#stSizeOf: */
sqInt
stSizeOf(sqInt _oop)
{
	sqInt _class;
	sqInt _classFormat;
	sqInt _fixedFields;
	usqLong _fmt;
	sqLong _hdr;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _totalLength;

	/* begin baseHeader: */
	_hdr = long64At(_oop);
	/* end baseHeader: */
	_fmt = (((unsigned sqLong) _hdr ) >> (formatShift())) & (formatMask());
	/* begin lengthOf:format: */
	/* begin numSlotsOfAny: */
	_numSlots2 = byteAt(_oop + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_oop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOfAny: */
	if (_fmt <= 5) {
		_totalLength = _numSlots;
		goto l4;
	}
	if (_fmt >= (firstByteFormat())) {
		_totalLength = (_numSlots << (shiftForWord())) - (_fmt & 7);
		goto l4;
	}
	if (_fmt >= (firstShortFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
		goto l4;
	}
	if (_fmt >= (firstLongFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
		goto l4;
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		_totalLength = _numSlots;
		goto l4;
	}
	_totalLength = 0;
	l4:
	;
	/* end lengthOf:format: */
	/* begin fixedFieldsOf:format:length: */
	if ((_fmt >= (sixtyFourBitIndexableFormat())) || (_fmt == 2)) {
		_fixedFields = 0;
		goto l5;
	}
	if (_fmt < 2) {
		_fixedFields = _totalLength;
		goto l5;
	}
	_class = fetchClassOfNonImm(_oop);
	/* begin fixedFieldsOfClassFormat: */
	_classFormat = (unsignedLongAt((_class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	_fixedFields = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	/* end fixedFieldsOfClassFormat: */
	l5:
	;
	/* end fixedFieldsOf:format:length: */
	if (_fmt == (indexablePointersFormat())) {
		assert(!(isContextHeader(_hdr)));
	}
	return _totalLength - _fixedFields;
}
/* StackInterpreter>>#supendActiveProcess */
sqInt
supendActiveProcess(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeProc;
	sqInt _objOop;
	sqInt _objOop2;

	/* begin memoryActiveProcess */
	/* begin fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	_activeProc = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end memoryActiveProcess */
	transferTofrom(wakeHighestPriority(), CSCallbackEnter);
	return _activeProc;
}
/*	Using a read barrier here simplifies the become implementation and costs 
	very little because the class index and superclass almost certainly share 
	a cache line. */
/* StackInterpreter>>#superclassOf: */
sqInt
superclassOf(sqInt _classPointer)
{
	sqInt _objOop;

	/* begin followField:ofObject: */
	/* begin fetchPointer:ofObject: */
	_objOop = unsignedLongAt((_classPointer + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_objOop & (tagMask())) == 0) && (((long64At(_objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		_objOop = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, _classPointer, _objOop);
	}
	return _objOop;
	/* end followField:ofObject: */
}
/*	Signal the given semaphore from within the interpreter. 
	Answer if the current process was preempted. 
	Override to add tracing info. */
/* StackInterpreter>>#synchronousSignal: */
static sqInt NoDbgRegParms
synchronousSignal(sqInt _aSemaphore)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _ctxt;
	sqInt _excessSignals;
	sqInt _proc;
	sqInt _referent;

	if ((assert(!(isForwarded(_aSemaphore))), (unsignedLongAt((_aSemaphore + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ))) == GIV(nilObj))) {
		_excessSignals = fetchIntegerofObject(ExcessSignalsIndex, _aSemaphore);
		/* begin storeInteger:ofObject:withValue: */
		if ((((((usqInt) (_excessSignals + 1) ) >> 60) + 1) & 15) <= 1) {
			/* begin storePointerUnchecked:ofObject:withValue: */
			assert(!(isOopForwarded(_aSemaphore)));
			longAtput((_aSemaphore + BaseHeaderSize) + ((sqInt) (((usqInt) ExcessSignalsIndex ) << (shiftForWord())) ), ((((usqInt) (_excessSignals + 1) ) << 3) | 1));
			/* end storePointerUnchecked:ofObject:withValue: */
		} else {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
		}
		/* end storeInteger:ofObject:withValue: */
		return 0;
	}
	/* begin ensureSemaphoreUnforwardedThroughContext: */
	_proc = unsignedLongAt((_aSemaphore + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ));
	if (((long64At(_proc)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		followForwardedObjectFieldstoDepth(_aSemaphore, 1);
		_proc = unsignedLongAt((_aSemaphore + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ));
	}
	assert(!(isForwarded(_proc)));
	_ctxt = unsignedLongAt((_proc + BaseHeaderSize) + ((sqInt) (((usqInt) SuspendedContextIndex ) << (shiftForWord())) ));
	if (((long64At(_ctxt)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		/* begin followForwarded: */
		assert(isUnambiguouslyForwarder(_ctxt));
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_ctxt + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
		while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
		}
		_ctxt = _referent;
		/* end followForwarded: */
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_proc)));
		if (((_proc & (tagMask())) == 0) && ((_proc & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_ctxt & (tagMask())) == 0) && (((_ctxt & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_ctxt >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_proc)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _proc);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_proc)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l5;
		}
		if (_ctxt & (tagMask())) {
			goto l5;
		}
		if (!(_proc >= 0x20000000000LL)) {
			goto l5;
		}
		if (_ctxt >= 0x20000000000LL) {
			goto l5;
		}
		if ((_ctxt >= GIV(nilObj)) && (_ctxt <= GIV(trueObj))) {
			goto l5;
		}
		if (!(_ctxt >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l5;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _proc);
		l5:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_proc + BaseHeaderSize) + ((sqInt) (((usqInt) SuspendedContextIndex ) << (shiftForWord())) ), _ctxt);
		/* end storePointer:ofObject:withValue: */
	}
	/* end ensureSemaphoreUnforwardedThroughContext: */
	return resumepreemptedYieldingIffrom(removeFirstLinkOfList(_aSemaphore), GIV(preemptionYields), CSSignal);
}
/* StackInterpreter>>#tempCountOf: */
sqInt
tempCountOf(sqInt _methodPointer)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _header;
	sqInt _header2;

	/* begin temporaryCountOfMethodHeader: */
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_methodPointer));
	/* begin fetchPointer:ofObject: */
	_header2 = unsignedLongAt((_methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header2 & 7) == 1)) {
		_header = _header2;
	} else {
		assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_header = ((((CogMethod *) _header2 ))->methodHeader);
	}
	/* end methodHeaderOf: */
	return (((usqInt) _header ) >> MethodHeaderTempCountShift) & 0x3F;
	/* end temporaryCountOfMethodHeader: */
}
/* StackInterpreter>>#temporaryCountOfMethodHeader: */
sqInt
temporaryCountOfMethodHeader(sqInt _header)
{
	return (((usqInt) _header ) >> MethodHeaderTempCountShift) & 0x3F;
}
/*	Record a process to be awoken on the next interpreter cycle. */
/* StackInterpreter>>#transferTo:from: */
static void NoDbgRegParms
transferTofrom(sqInt _newProc, sqInt _sourceCode)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeContext;
	sqInt _aMethodObj;
	StackPage *_lastUsedPage;
	StackPage *_lruOrFree;
	sqInt _newContext;
	StackPage *_newPage;
	sqInt _objOop;
	sqInt _oldProc;
	sqInt _sched;
	sqInt _senderOop;
	char *_sp;
	char *_theFP;
	char *_theFrame;
	StackPage *_thePage;
	char *_theSP;
	char *_theSP2;
	sqInt _top;
	sqInt _valuePointer;
	sqInt _valuePointer2;

	GIV(statProcessSwitch) += 1;
	/* begin push: */
	unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
	GIV(stackPointer) = _sp;
	/* end push: */
	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	_theSP2 = GIV(stackPointer);
	assert(_theSP2 < GIV(framePointer));
	assert((_theSP2 < ((GIV(stackPage)->baseAddress))) && (_theSP2 > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(GIV(stackPage)->headFP = GIV(framePointer));
		(GIV(stackPage)->headSP = _theSP2);
	}
	/* end setHeadFP:andSP:inPage: */
	assert(pageListIsWellFormed());
	/* end writeBackHeadFramePointers */
	/* begin assertValidExecutionPointe:r:s: */
	assertValidExecutionPointersimbarline(((usqInt) GIV(instructionPointer) ), GIV(framePointer), GIV(stackPointer), !(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) ))), __LINE__);
	/* end assertValidExecutionPointe:r:s: */
	GIV(instructionPointer) = 0;
	/* begin schedulerPointer */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_objOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	_sched = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end schedulerPointer */
	/* begin fetchPointer:ofObject: */
	_oldProc = unsignedLongAt((_sched + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* begin recordContextSwitchFrom:in: */
	if (recordEventTrace()) {
		/* begin recordTrace:thing:source: */
		GIV(traceLog)[GIV(traceLogIndex)] = TraceContextSwitch;
		GIV(traceLog)[GIV(traceLogIndex) + 1] = _oldProc;
		GIV(traceLog)[GIV(traceLogIndex) + 2] = _sourceCode;
		GIV(traceLogIndex) = (GIV(traceLogIndex) + 3) % TraceBufferSize;
		/* end recordTrace:thing:source: */
	}
	/* end recordContextSwitchFrom:in: */
	/* begin ensureFrameIsMarried:SP: */
	_theFP = GIV(framePointer);
	_theSP = GIV(stackPointer) + BytesPerWord;
	if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
		 : (byteAt((_theFP + FoxIFrameFlags) + 2)) != 0)) {
		assert(isContext(frameContext(_theFP)));
		_activeContext = unsignedLongAt(_theFP + FoxThisContext);
		goto l6;
	}
	_activeContext = marryFrameSP(_theFP, _theSP);
	l6:
	;
	/* end ensureFrameIsMarried:SP: */
	/* begin storePointer:ofObject:withValue: */
	assert(!(isForwarded(_oldProc)));
	if (((_oldProc & (tagMask())) == 0) && ((_oldProc & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((_activeContext & (tagMask())) == 0) && (((_activeContext & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_activeContext >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_oldProc)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _oldProc);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(_oldProc)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l7;
	}
	if (_activeContext & (tagMask())) {
		goto l7;
	}
	if (!(_oldProc >= 0x20000000000LL)) {
		goto l7;
	}
	if (_activeContext >= 0x20000000000LL) {
		goto l7;
	}
	if ((_activeContext >= GIV(nilObj)) && (_activeContext <= GIV(trueObj))) {
		goto l7;
	}
	if (!(_activeContext >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l7;
	}
	remember(getFromPermToNewSpaceRememberedSet(), _oldProc);
	l7:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((_oldProc + BaseHeaderSize) + ((sqInt) (((usqInt) SuspendedContextIndex ) << (shiftForWord())) ), _activeContext);
	/* end storePointer:ofObject:withValue: */
	/* begin storePointer:ofObject:withValue: */
	assert(!(isForwarded(_sched)));
	if (((_sched & (tagMask())) == 0) && ((_sched & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((_newProc & (tagMask())) == 0) && (((_newProc & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_newProc >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_sched)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _sched);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(_sched)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l9;
	}
	if (_newProc & (tagMask())) {
		goto l9;
	}
	if (!(_sched >= 0x20000000000LL)) {
		goto l9;
	}
	if (_newProc >= 0x20000000000LL) {
		goto l9;
	}
	if ((_newProc >= GIV(nilObj)) && (_newProc <= GIV(trueObj))) {
		goto l9;
	}
	if (!(_newProc >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l9;
	}
	remember(getFromPermToNewSpaceRememberedSet(), _sched);
	l9:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((_sched + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ), _newProc);
	/* end storePointer:ofObject:withValue: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	_valuePointer = GIV(nilObj);
	assert(!(isOopForwarded(_newProc)));
	longAtput((_newProc + BaseHeaderSize) + ((sqInt) (((usqInt) MyListIndex ) << (shiftForWord())) ), _valuePointer);
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin setStackPageAndPointersForSuspendedContextOfProcess: */
	/* begin fetchPointer:ofObject: */
	_newContext = unsignedLongAt((_newProc + BaseHeaderSize) + ((sqInt) (((usqInt) SuspendedContextIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(isContext(_newContext));
	if ((((unsignedLongAt((_newContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
		assert(checkIsStillMarriedContextcurrentFP(_newContext, GIV(framePointer)));
	}
	/* begin storePointerUnchecked:ofObject:withValue: */
	_valuePointer2 = GIV(nilObj);
	assert(!(isOopForwarded(_newProc)));
	longAtput((_newProc + BaseHeaderSize) + ((sqInt) (((usqInt) SuspendedContextIndex ) << (shiftForWord())) ), _valuePointer2);
	/* end storePointerUnchecked:ofObject:withValue: */
	if (((((unsignedLongAt((_newContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_newContext)))) {
		/* begin frameOfMarriedContext: */
		/* begin fetchPointer:ofObject: */
		_senderOop = unsignedLongAt((_newContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		{
			assert(((_senderOop & 7) == 1));
			_theFrame = pointerForOop(_senderOop - 1);
		}
		/* end frameOfMarriedContext: */
		/* begin stackPageFor: */
		/* begin stackPageAt: */
		_thePage = stackPageAtpages((assert((((char *) _theFrame ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFrame ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFrame, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
		/* end stackPageAt: */
		/* end stackPageFor: */
		if (_theFrame != ((_thePage->headFP))) {
			/* begin newStackPage */
			_lruOrFree = (GIV(mostRecentlyUsedPage)->nextPage);
			if (((_lruOrFree->baseFP)) == 0) {
				_newPage = _lruOrFree;
				goto l14;
			}
			divorceFramesIn(_lruOrFree);
			_newPage = _lruOrFree;
			l14:
			;
			/* end newStackPage */
			moveFramesInthroughtoPage(_thePage, findFrameAboveinPage(_theFrame, _thePage), _newPage);
			/* begin markStackPageLeastMostRecentlyUsed: */
			assert(_newPage == ((GIV(mostRecentlyUsedPage)->nextPage)));
			_lastUsedPage = (_newPage->nextPage);
			while (((_lastUsedPage->baseFP)) == 0) {
				_lastUsedPage = (_lastUsedPage->nextPage);
			}
			if (((_lastUsedPage->nextPage)) == _newPage) {
				goto l17;
			}
			(((_newPage->prevPage))->nextPage = (_newPage->nextPage));
			(((_newPage->nextPage))->prevPage = (_newPage->prevPage));
			(((_lastUsedPage->prevPage))->nextPage = _newPage);
			(_newPage->prevPage = (_lastUsedPage->prevPage));
			(_newPage->nextPage = _lastUsedPage);
			(_lastUsedPage->prevPage = _newPage);
			assert(pageListIsWellFormed());
			l17:
			;
			/* end markStackPageLeastMostRecentlyUsed: */
		}
		assert(((_thePage->headFP)) == _theFrame);
	} else {
		_thePage = makeBaseFrameFor(_newContext);
		_theFrame = (_thePage->baseFP);
	}
	/* begin setStackPageAndLimit: */
	assert(_thePage != 0);
	GIV(stackPage) = _thePage;
	if (GIV(stackLimit) != ((char *) ((usqInt) -1 ) )) {
		GIV(stackLimit) = (GIV(stackPage)->stackLimit);
	}
	markStackPageMostRecentlyUsed(_thePage);
	/* end setStackPageAndLimit: */
	/* begin setStackPointersFromPage: */
	GIV(stackPointer) = (_thePage->headSP);
	GIV(framePointer) = (_thePage->headFP);
	/* end setStackPointersFromPage: */
	if (!(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))) {
		/* begin setMethod: */
		_aMethodObj = unsignedLongAt(GIV(framePointer) + FoxMethod);
		assert(((usqInt) _aMethodObj ) >= (startOfObjectMemory(getMemoryMap())));
		{
			GIV(method) = _aMethodObj;
			assert(isOopCompiledMethod(GIV(method)));
		}
		/* end setMethod: */
	}
	/* begin popStack */
	_top = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	GIV(instructionPointer) = _top;
	/* end popStack */
	/* begin assertValidExecutionPointe:r:s: */
	assertValidExecutionPointersimbarline(((usqInt) GIV(instructionPointer) ), GIV(framePointer), GIV(stackPointer), !(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) ))), __LINE__);
	/* end assertValidExecutionPointe:r:s: */
	/* end setStackPageAndPointersForSuspendedContextOfProcess: */
}
/* StackInterpreter>>#ultimateLiteralOf: */
sqInt
ultimateLiteralOf(sqInt _aMethodOop)
{
	sqInt _offset;

	assert(isOopCompiledMethod(_aMethodOop));
	/* begin literal:ofMethod: */
	_offset = (literalCountOfMethodHeader(methodHeaderOf(_aMethodOop))) - 1;
	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((_aMethodOop + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset + LiteralStart) ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end literal:ofMethod: */
}
/* StackInterpreter>>#ultimateLiteralOf:put: */
void
ultimateLiteralOfput(sqInt _aMethodOop, sqInt _aValue)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _offset;

	assert(isOopCompiledMethod(_aMethodOop));
	{
		/* begin literal:ofMethod:put: */
		_offset = (literalCountOfMethodHeader(methodHeaderOf(_aMethodOop))) - 1;
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_aMethodOop)));
		if (((_aMethodOop & (tagMask())) == 0) && ((_aMethodOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_aValue & (tagMask())) == 0) && (((_aValue & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_aValue >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_aMethodOop)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _aMethodOop);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_aMethodOop)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l2;
		}
		if (_aValue & (tagMask())) {
			goto l2;
		}
		if (!(_aMethodOop >= 0x20000000000LL)) {
			goto l2;
		}
		if (_aValue >= 0x20000000000LL) {
			goto l2;
		}
		if ((_aValue >= GIV(nilObj)) && (_aValue <= GIV(trueObj))) {
			goto l2;
		}
		if (!(_aValue >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l2;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _aMethodOop);
		l2:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_aMethodOop + BaseHeaderSize) + ((sqInt) (((usqInt) (_offset + LiteralStart) ) << (shiftForWord())) ), _aValue);
		/* end storePointer:ofObject:withValue: */
		/* end literal:ofMethod:put: */
		return;
	}
}
/*	So rare it mustn't bulk up the common path */
/* StackInterpreter>>#unfollow:atIndex: */
static sqInt NoDbgRegParms NeverInline
unfollowatIndex(sqInt _litVar, sqInt _literalIndex)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _followed;
	sqInt _referent;

	/* begin followForwarded: */
	assert(isUnambiguouslyForwarder(_litVar));
	/* begin fetchPointer:ofMaybeForwardedObject: */
	_referent = unsignedLongAt((_litVar + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofMaybeForwardedObject: */
	while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		/* begin fetchPointer:ofMaybeForwardedObject: */
		_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofMaybeForwardedObject: */
	}
	_followed = _referent;
	/* end followForwarded: */
	/* begin literal:ofMethod:put: */
	/* begin storePointer:ofObject:withValue: */
	assert(!(isForwarded(GIV(method))));
	if (((GIV(method) & (tagMask())) == 0) && ((GIV(method) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((_followed & (tagMask())) == 0) && (((_followed & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_followed >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(GIV(method))) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), GIV(method));
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(GIV(method))) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l6;
	}
	if (_followed & (tagMask())) {
		goto l6;
	}
	if (!(GIV(method) >= 0x20000000000LL)) {
		goto l6;
	}
	if (_followed >= 0x20000000000LL) {
		goto l6;
	}
	if ((_followed >= GIV(nilObj)) && (_followed <= GIV(trueObj))) {
		goto l6;
	}
	if (!(_followed >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l6;
	}
	remember(getFromPermToNewSpaceRememberedSet(), GIV(method));
	l6:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (_literalIndex + LiteralStart) ) << (shiftForWord())) ), _followed);
	/* end storePointer:ofObject:withValue: */
	/* end literal:ofMethod:put: */
	return _followed;
}
/*	Update the frame's spouse context with the frame's current state except 
	for the 
	sender and instruction pointer, which are used to mark the context as 
	married.  */
/* StackInterpreter>>#updateStateOfSpouseContextForFrame:WithSP: */
static void NoDbgRegParms
updateStateOfSpouseContextForFrameWithSP(char *_theFP, char *_theSP)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_argsPointer;
	sqInt _i;
	char *_pointer;
	sqInt _tempIndex;
	sqInt _theContext;
	sqInt _valuePointer;
	sqInt _valuePointer2;

	assert(frameHasContext(_theFP));
	/* begin frameContext: */
	_theContext = unsignedLongAt(_theFP + FoxThisContext);
	/* end frameContext: */
	assert(isContext(_theContext));
	assert((frameReceiver(_theFP)) == (noFixupFollowFieldofObject(ReceiverIndex, _theContext)));
	_tempIndex = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? ((((CogMethod *) ((unsignedLongAt(_theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
		 : byteAt((_theFP + FoxIFrameFlags) + 1));
	_argsPointer = _theFP + ((FoxCallerSavedIP + BytesPerWord) + ((sqInt) (((usqInt) _tempIndex ) << (shiftForWord())) ));
	for (_i = 1; _i <= _tempIndex; _i += 1) {
		_argsPointer -= BytesPerWord;
		assert(addressCouldBeOop(longAt(_argsPointer)));
		/* begin storePointer:ofObject:withValue: */
		_valuePointer = longAt(_argsPointer);
		assert(!(isForwarded(_theContext)));
		if (((_theContext & (tagMask())) == 0) && ((_theContext & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_valuePointer & (tagMask())) == 0) && (((_valuePointer & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_valuePointer >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_theContext)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _theContext);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_theContext)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l4;
		}
		if (_valuePointer & (tagMask())) {
			goto l4;
		}
		if (!(_theContext >= 0x20000000000LL)) {
			goto l4;
		}
		if (_valuePointer >= 0x20000000000LL) {
			goto l4;
		}
		if ((_valuePointer >= GIV(nilObj)) && (_valuePointer <= GIV(trueObj))) {
			goto l4;
		}
		if (!(_valuePointer >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l4;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _theContext);
		l4:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) (ReceiverIndex + _i) ) << (shiftForWord())) ), _valuePointer);
		/* end storePointer:ofObject:withValue: */
	}
	_pointer = (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP + FoxMethod)) )))
		 ? _theFP + FoxMFReceiver
		 : _theFP + FoxIFReceiver)) - BytesPerWord;
	while (_pointer >= _theSP) {
		assert(addressCouldBeOop(longAt(_pointer)));
		_tempIndex += 1;
		/* begin storePointer:ofObject:withValue: */
		_valuePointer2 = longAt(_pointer);
		assert(!(isForwarded(_theContext)));
		if (((_theContext & (tagMask())) == 0) && ((_theContext & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_valuePointer2 & (tagMask())) == 0) && (((_valuePointer2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_valuePointer2 >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_theContext)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _theContext);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_theContext)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l6;
		}
		if (_valuePointer2 & (tagMask())) {
			goto l6;
		}
		if (!(_theContext >= 0x20000000000LL)) {
			goto l6;
		}
		if (_valuePointer2 >= 0x20000000000LL) {
			goto l6;
		}
		if ((_valuePointer2 >= GIV(nilObj)) && (_valuePointer2 <= GIV(trueObj))) {
			goto l6;
		}
		if (!(_valuePointer2 >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l6;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _theContext);
		l6:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) (ReceiverIndex + _tempIndex) ) << (shiftForWord())) ), _valuePointer2);
		/* end storePointer:ofObject:withValue: */
		_pointer -= BytesPerWord;
	}
	assert((ReceiverIndex + _tempIndex) < (lengthOf(_theContext)));
	/* begin storePointerUnchecked:ofObject:withValue: */
	assert(!(isOopForwarded(_theContext)));
	longAtput((_theContext + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ), ((((usqInt) _tempIndex ) << 3) | 1));
	/* end storePointerUnchecked:ofObject:withValue: */
}
/*	Note that we accept anInstrPointer pointing to a callPrimitiveBytecode 
	at the start of a method that contains a primitive. This because methods 
	like Context(Part)>>reset have to be updated to skip the callPrimtiive 
	bytecode otherwise. */
/* StackInterpreter>>#validBCPC:inMethod: */
static sqInt NoDbgRegParms
validBCPCinMethod(sqInt _thePC, usqInt _aMethod)
{
	return (_thePC >= (((literalCountOfMethodHeader(methodHeaderOf(_aMethod))) + LiteralStart) * BytesPerOop)) && (_thePC <= (numBytesOfBytes(_aMethod)));
}
/*	Note that we accept anInstrPointer pointing to a callPrimitiveBytecode 
	at the start of a method that contains a primitive. This because methods 
	like Context(Part)>>reset have to be updated to skip the callPrimtiive 
	bytecode otherwise. */
/* StackInterpreter>>#validInstructionPointer:inFrame: */
static sqInt NoDbgRegParms
validInstructionPointerinFrame(usqInt _anInstrPointer, char *_fp)
{
	return validInstructionPointerinMethodframePointer(_anInstrPointer, ((isMachineCodeIP(((usqInt) (unsignedLongAt(_fp + FoxMethod)) )))
		 ? ((mframeHomeMethod(_fp))->methodObject)
		 : unsignedLongAt(_fp + FoxMethod)), _fp);
}
/*	Check that the base frames in all in-use stack pages have a sender and a 
	saved context. */
/* StackInterpreter>>#validStackPageBaseFrames */
static sqInt
validStackPageBaseFrames(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	StackPage *_thePage2;

	/* begin usedStackPagesDo: */
	/* begin allStackPagesDo: */
	for (_i = 0; _i < GIV(numStackPages); _i += 1) {
		/* begin stackPageAt: */
		_thePage2 = stackPageAtpages(_i, GIV(pages));
		/* end stackPageAt: */
		{
			if (!(((_thePage2->baseFP)) == 0)) {
				{
					if (!(validStackPageBaseFrame(_thePage2))) {
						return 0;
					}
				}
			}
		}
	}
	/* end allStackPagesDo: */
	/* end usedStackPagesDo: */
	return 1;
}
/*	Check that the base frame in the stack page has a valid sender context. */
/* StackInterpreter>>#validStackPageBaseFrame: */
static sqInt NoDbgRegParms
validStackPageBaseFrame(StackPage *_aPage)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _callerContextOrNil;
	sqInt _senderContextOrNil;
	char *_theFP;
	StackPage *_thePage;

	if (!(asserta(isBaseFrame((_aPage->baseFP))))) {
		return 0;
	}
	/* begin frameCallerContext: */
	_theFP = (_aPage->baseFP);
	assert(isBaseFrame(_theFP));
	/* begin stackPageFor: */
	/* begin stackPageAt: */
	_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
	/* end stackPageAt: */
	/* end stackPageFor: */
	_callerContextOrNil = unsignedLongAt((_thePage->baseAddress));
	assert(addressCouldBeObj(_callerContextOrNil));
	assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
	_senderContextOrNil = _callerContextOrNil;
	/* end frameCallerContext: */
	if (!(asserta(addressCouldBeObj(_senderContextOrNil)))) {
		return 0;
	}
	if (!(asserta((_senderContextOrNil == (nilObject())) || (isContext(_senderContextOrNil))))) {
		return 0;
	}
	return 1;
}
/*	Void the state associated with the long-running primitive check. 
	This is done when a new semaphore is installed or when it appears 
	that is longRunningPrimitiveCheckMethod is invalid, e.g. because it 
	has eben sampled in the middle of a GC. */
/* StackInterpreter>>#voidLongRunningPrimitive: */
static void NoDbgRegParms NeverInline
voidLongRunningPrimitive(char *reason)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	GIV(longRunningPrimitiveCheckMethod) = null;
	GIV(longRunningPrimitiveStartUsecs) = (GIV(longRunningPrimitiveStopUsecs) = 0);
	GIV(longRunningPrimitiveSignalUndelivered) = 1;
	sqLowLevelMFence();
}
/*	Return the highest priority process that is ready to run. 
	To save time looking at many empty lists before finding a 
	runnable process the VM maintains a variable holding the 
	highest priority runnable process. If this variable is 0 then the 
	VM does not know the highest priority and must search all lists. 
	Note: It is a fatal VM error if there is no runnable process. */
/* StackInterpreter>>#wakeHighestPriority */
static sqInt
wakeHighestPriority(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _ctxt;
	usqInt _numSlots;
	sqInt _objOop;
	sqInt _objOop2;
	sqInt _p;
	sqInt _proc;
	sqInt _processList;
	sqInt _schedLists;
	char *_theSP;

	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	_theSP = GIV(stackPointer);
	assert(_theSP < GIV(framePointer));
	assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(GIV(stackPage)->headFP = GIV(framePointer));
		(GIV(stackPage)->headSP = _theSP);
	}
	/* end setHeadFP:andSP:inPage: */
	assert(pageListIsWellFormed());
	/* end writeBackHeadFramePointers */
	/* begin fetchPointer:ofObject: */
	/* begin schedulerPointer */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end schedulerPointer */
	_schedLists = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ProcessListsIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (GIV(highestRunnableProcessPriority) == 0) {
		/* begin numSlotsOf: */
		assert((classIndexOf(_schedLists)) > (isForwardedObjectClassIndexPun()));
		_numSlots = byteAt(_schedLists + 7);
		_p = ((_numSlots == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_schedLists - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots);
		/* end numSlotsOf: */
	} else {
		_p = GIV(highestRunnableProcessPriority);
	}
	while (((_p -= 1)) >= 0) {
		/* begin fetchPointer:ofObject: */
		_processList = unsignedLongAt((_schedLists + BaseHeaderSize) + ((sqInt) (((usqInt) _p ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		while (!((assert(!(isForwarded(_processList))), (unsignedLongAt((_processList + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ))) == GIV(nilObj)))) {
			_proc = removeFirstLinkOfList(_processList);
			/* begin fetchPointer:ofObject: */
			_ctxt = unsignedLongAt((_proc + BaseHeaderSize) + ((sqInt) (((usqInt) SuspendedContextIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (isLiveContext(_ctxt)) {
				GIV(highestRunnableProcessPriority) = _p + 1;
				return _proc;
			}
			if (((_ctxt & (tagMask())) == 0) && (((long64At(_ctxt)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				_ctxt = fixFollowedFieldofObjectwithInitialValue(SuspendedContextIndex, _proc, _ctxt);
			}
			if (isLiveContext(_ctxt)) {
				GIV(highestRunnableProcessPriority) = _p + 1;
				return _proc;
			}
			warning("evicted zombie process from run queue");
		}
	}
	error("scheduler could not find a runnable process");
	return null;
}
/* StackInterpreter>>#withSmallIntegerTags: */
static sqInt NoDbgRegParms
withSmallIntegerTags(char *_value)
{
	assert(((oopForPointer(_value)) & (BytesPerWord - 1)) == 0);
	return (oopForPointer(_value)) + (smallIntegerTag());
}
/* StackInterpreterPrimitives>>#cloneContext: */
static sqInt NoDbgRegParms
cloneContext(sqInt _aContext)
{
	sqInt _cloned;
	sqInt _frameNumArgs;
	sqInt _frameNumArgs2;
	sqInt _i;
	usqInt _numSlots;
	sqInt _senderOop;
	sqInt _sp;
	char *_spouseFP;
	usqInt _sz;
	sqInt _valuePointer;
	sqInt _valuePointer2;
	sqInt _valuePointer3;
	sqInt _valuePointer4;

	/* begin numSlotsOf: */
	assert((classIndexOf(_aContext)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_aContext + 7);
	_sz = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_aContext - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_cloned = allocateNewSpaceSlotsformatclassIndex(_sz, indexablePointersFormat(), ClassMethodContextCompactIndex);
	if (_cloned != 0) {
		for (_i = 0; _i <= StackPointerIndex; _i += 1) {
			/* begin storePointerUnchecked:ofObject:withValue: */
			_valuePointer = instVarofContext(_i, _aContext);
			assert(!(isOopForwarded(_cloned)));
			longAtput((_cloned + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _valuePointer);
			/* end storePointerUnchecked:ofObject:withValue: */
		}
		for (_i = MethodIndex; _i <= ReceiverIndex; _i += 1) {
			/* begin storePointerUnchecked:ofObject:withValue: */
			_valuePointer2 = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
			assert(!(isOopForwarded(_cloned)));
			longAtput((_cloned + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ), _valuePointer2);
			/* end storePointerUnchecked:ofObject:withValue: */
		}
		if (((((unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_aContext)))) {
			/* begin frameOfMarriedContext: */
			/* begin fetchPointer:ofObject: */
			_senderOop = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			{
				assert(((_senderOop & 7) == 1));
				_spouseFP = pointerForOop(_senderOop - 1);
			}
			/* end frameOfMarriedContext: */
			_sp = (stackPointerIndexForFrame(_spouseFP)) - 1;
			for (_i = 0; _i <= _sp; _i += 1) {
				/* begin storePointerUnchecked:ofObject:withValue: */
				if (isMachineCodeIP(((usqInt) (unsignedLongAt(_spouseFP + FoxMethod)) ))) {
					_valuePointer3 = ((_i < ((_frameNumArgs = ((((CogMethod *) ((unsignedLongAt(_spouseFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs))))
						 ? unsignedLongAt((_spouseFP + FoxCallerSavedIP) + ((_frameNumArgs - _i) * BytesPerWord))
						 : unsignedLongAt(((((isMachineCodeIP(((usqInt) (unsignedLongAt(_spouseFP + FoxMethod)) )))
							 ? _spouseFP + FoxMFReceiver
							 : _spouseFP + FoxIFReceiver)) - BytesPerWord) + ((_frameNumArgs - _i) * BytesPerWord)));
				} else {
					{
						_valuePointer3 = ((_i < ((_frameNumArgs2 = byteAt((_spouseFP + FoxIFrameFlags) + 1))))
							 ? unsignedLongAt((_spouseFP + FoxCallerSavedIP) + ((_frameNumArgs2 - _i) * BytesPerWord))
							 : unsignedLongAt(((_spouseFP + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs2 - _i) * BytesPerWord)));
					}
				}
				assert(!(isOopForwarded(_cloned)));
				longAtput((_cloned + BaseHeaderSize) + ((sqInt) (((usqInt) (_i + CtxtTempFrameStart) ) << (shiftForWord())) ), _valuePointer3);
				/* end storePointerUnchecked:ofObject:withValue: */
			}
		} else {
			_sp = (fetchStackPointerOf(_aContext)) - 1;
			for (_i = 0; _i <= _sp; _i += 1) {
				/* begin storePointerUnchecked:ofObject:withValue: */
				_valuePointer4 = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) (_i + CtxtTempFrameStart) ) << (shiftForWord())) ));
				assert(!(isOopForwarded(_cloned)));
				longAtput((_cloned + BaseHeaderSize) + ((sqInt) (((usqInt) (_i + CtxtTempFrameStart) ) << (shiftForWord())) ), _valuePointer4);
				/* end storePointerUnchecked:ofObject:withValue: */
			}
		}
	}
	return _cloned;
}
/*	Actual primitive implementation of primitiveSameThreadCallout. 
	Because of Slang restrictions, making FFI optional requires cutting the 
	primitive in two different methods. Otherwise slang will unconditionally 
	do all local declarations which may refer to invalid types if FFI is not 
	enabled.  
	Method primitiveSameThreadCallout checks if the feature is available. If 
	so, it calls this method. */
/* StackInterpreterPrimitives>>#doPrimitiveSameThreadCallout */

#if FEATURE_FFI
static sqInt
doPrimitiveSameThreadCallout(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _anOop;
	sqInt _anOop2;
	sqInt _anOop3;
	sqInt _argHolder;
	ffi_type * _argType;
	usqInt _argumentSize;
	sqInt _argumentsArrayOop;
	ffi_cif * _cif;
	void *_externalFunction;
	sqInt _i;
	sqInt _objOop;
	int _PARAM_ARGUMENTS;
	int _PARAM_EXTERNALFUNCTION;
	void **_parameters;
	void *_returnHolder;

	_PARAM_EXTERNALFUNCTION = 1;
	_PARAM_ARGUMENTS = 0;
	/* begin getHandler: */
	_anOop = unsignedLongAt(GIV(stackPointer) + (_PARAM_EXTERNALFUNCTION * BytesPerWord));
	if ((!(((_anOop & (tagMask())) == 0) && (((((usqInt) (longAt(_anOop)) ) >> (formatShift())) & (formatMask())) <= 5))) || ((slotSizeOf(_anOop)) < 1)) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_externalFunction = null;
		goto l6;
	}
	/* begin readAddress: */
	_anOop2 = unsignedLongAt((_anOop + BaseHeaderSize) + (0U << (shiftForWord())));
	if (!(isKindOfClass(_anOop2, unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ))))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_externalFunction = null;
		goto l6;
	}
	/* begin fetchPointer:ofObject: */
	_externalFunction = unsignedLongAt((_anOop2 + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	/* end readAddress: */
	l6:
	;
	/* end getHandler: */
	if (GIV(primFailCode)) {
		logDebug("Invalid External Function Argument");
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadArgument);
		/* end primitiveFailFor: */
	}
	/* begin getHandlerAsCif: */
	/* begin fetchPointer:ofObject: */
	_objOop = unsignedLongAt(GIV(stackPointer) + (_PARAM_EXTERNALFUNCTION * BytesPerWord));
	_anOop3 = unsignedLongAt((_objOop + BaseHeaderSize) + (1U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	_cif = ((ffi_cif *) (getHandler(_anOop3)) );
	/* end getHandlerAsCif: */
	if (GIV(primFailCode)) {
		logDebug("Invalid CIF in ExternalFunction");
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadArgument);
		/* end primitiveFailFor: */
	}
	/* begin stackValue: */
	_argumentsArrayOop = unsignedLongAt(GIV(stackPointer) + (_PARAM_ARGUMENTS * BytesPerWord));
	/* end stackValue: */
	if (!(((_argumentsArrayOop & (tagMask())) == 0) && (((((usqInt) (longAt(_argumentsArrayOop)) ) >> (formatShift())) & (formatMask())) == 2))) {
		logDebug("Argument Array is not an Array");
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadArgument);
		/* end primitiveFailFor: */
	}
	/* begin numberArguments */
	_argumentSize = (_cif->nargs);
	/* end numberArguments */
	if (!((slotSizeOf(_argumentsArrayOop)) == _argumentSize)) {
		logDebug("Argument Array size mismatch");
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadArgument);
		/* end primitiveFailFor: */
	}
	/* begin allocateParameters:using: */
	if (_argumentSize == 0) {
		_parameters = ((sqInt) null );
		goto l4;
	}
	{
		_parameters = alloca((sizeof(void*)) * _argumentSize);
	}
	l4:
	;
	/* end allocateParameters:using: */
	for (_i = 0; _i < _argumentSize; _i += 1) {
		/* begin argTypeAt: */
		_argType = (_cif->arg_types)[_i];
		/* end argTypeAt: */
		_argHolder = alloca((_argType->size));
		_parameters[_i] = _argHolder;
		marshallArgumentFromatIndexintoofTypewithSize(_argumentsArrayOop, _i, _argHolder, (_argType->type), (_argType->size));
		if (GIV(primFailCode)) {
			logDebug("Could not convert argument index: %d", _i + 1);
			/* begin primitiveFailFor: */
			return (GIV(primFailCode) = PrimErrBadArgument);
			/* end primitiveFailFor: */
		}
	}
	_returnHolder = alloca((((_cif->rtype))->size));
	ffi_call(_cif, _externalFunction, _returnHolder, _parameters);
	marshallAndPushReturnValueFromofTypepoping(_returnHolder, (_cif->rtype), 3);
	return 0;
}
#endif /* FEATURE_FFI */
/*	Actual primitive implementation of primitiveWorkerCallout. 
	Because of Slang restrictions, making FFI optional requires cutting the 
	primitive in two different methods. Otherwise slang will unconditionally 
	do all local declarations which may refer to invalid types if FFI is not 
	enabled.  
	Method primitiveWorkerCallout checks if the feature is available. If so, 
	it calls this method. */
/* StackInterpreterPrimitives>>#doPrimitiveWorkerCallout */

#if FEATURE_THREADED_FFI
EXPORT(sqInt)
doPrimitiveWorkerCallout(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _anInteger;
	sqInt _anOop;
	sqInt _anOop2;
	sqInt _anOop3;
	sqInt _aPointer;
	sqInt _aPtr;
	sqInt _argHolder;
	ffi_type * _argType;
	usqInt _argumentSize;
	sqInt _argumentsArrayOop;
	ffi_cif * _cif;
	sqInt _classObj;
	void *_externalFunction;
	sqInt _i;
	sqInt _i2;
	sqInt _integerPointer;
	sqInt _nElements;
	sqInt _objOop;
	sqInt _oop;
	sqInt _oop2;
	int _PARAM_ARGUMENTS;
	int _PARAM_EXTERNALFUNCTION;
	int _PARAM_RECEIVER;
	int _PARAM_SEMAPHORE_INDEX;
	void **_parameters;
	sqInt _primitiveReceiver;
	void **_ptr;
	void *_returnHolder;
	sqInt _semaphoreIndex;
	char *_sp;
	WorkerTask *_task;
	Worker * _worker;

	_PARAM_RECEIVER = 3;
	_PARAM_EXTERNALFUNCTION = 2;
	_PARAM_ARGUMENTS = 1;
	_PARAM_SEMAPHORE_INDEX = 0;
	/* begin getHandler: */
	_anOop = unsignedLongAt(GIV(stackPointer) + (_PARAM_EXTERNALFUNCTION * BytesPerWord));
	if ((!(((_anOop & (tagMask())) == 0) && (((((usqInt) (longAt(_anOop)) ) >> (formatShift())) & (formatMask())) <= 5))) || ((slotSizeOf(_anOop)) < 1)) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_externalFunction = null;
		goto l9;
	}
	/* begin readAddress: */
	_anOop2 = unsignedLongAt((_anOop + BaseHeaderSize) + (0U << (shiftForWord())));
	if (!(isKindOfClass(_anOop2, unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ))))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_externalFunction = null;
		goto l9;
	}
	/* begin fetchPointer:ofObject: */
	_externalFunction = unsignedLongAt((_anOop2 + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	/* end readAddress: */
	l9:
	;
	/* end getHandler: */
	if (GIV(primFailCode)) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadArgument);
		/* end primitiveFailFor: */
	}
	/* begin getHandlerAsCif: */
	/* begin fetchPointer:ofObject: */
	_objOop = unsignedLongAt(GIV(stackPointer) + (_PARAM_EXTERNALFUNCTION * BytesPerWord));
	_anOop3 = unsignedLongAt((_objOop + BaseHeaderSize) + (1U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	_cif = ((ffi_cif *) (getHandler(_anOop3)) );
	/* end getHandlerAsCif: */
	if (GIV(primFailCode)) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadArgument);
		/* end primitiveFailFor: */
	}
	/* begin stackIntegerValue: */
	_integerPointer = unsignedLongAt(GIV(stackPointer) + (_PARAM_SEMAPHORE_INDEX * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_semaphoreIndex = _integerPointer >> 3;
		goto l7;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_semaphoreIndex = 0;
		goto l7;
	}
	/* end checkedIntegerValueOf: */
	l7:
	;
	/* end stackIntegerValue: */
	if (GIV(primFailCode)) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadArgument);
		/* end primitiveFailFor: */
	}
	/* begin stackValue: */
	_primitiveReceiver = unsignedLongAt(GIV(stackPointer) + (_PARAM_RECEIVER * BytesPerWord));
	/* end stackValue: */
	/* begin getWorkerFromAddress: */
	_anInteger = ((sqInt) (getHandler(_primitiveReceiver)) );
	_worker = ((Worker *) _anInteger );
	/* end getWorkerFromAddress: */
	if (GIV(primFailCode)) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadArgument);
		/* end primitiveFailFor: */
	}
	/* begin stackValue: */
	_argumentsArrayOop = unsignedLongAt(GIV(stackPointer) + (_PARAM_ARGUMENTS * BytesPerWord));
	/* end stackValue: */
	if (!(((_argumentsArrayOop & (tagMask())) == 0) && (((((usqInt) (longAt(_argumentsArrayOop)) ) >> (formatShift())) & (formatMask())) == 2))) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadArgument);
		/* end primitiveFailFor: */
	}
	/* begin numberArguments */
	_argumentSize = (_cif->nargs);
	/* end numberArguments */
	if (!((slotSizeOf(_argumentsArrayOop)) == _argumentSize)) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadArgument);
		/* end primitiveFailFor: */
	}
	/* begin allocateParameters:using: */
	if (_argumentSize == 0) {
		_parameters = ((sqInt) null );
		goto l5;
	}
	{
		_parameters = calloc(_argumentSize, sizeof(void*));
	}
	l5:
	;
	/* end allocateParameters:using: */
	for (_i = 0; _i < _argumentSize; _i += 1) {
		/* begin argTypeAt: */
		_argType = (_cif->arg_types)[_i];
		/* end argTypeAt: */
		_argHolder = malloc((_argType->size));
		_parameters[_i] = _argHolder;
		marshallArgumentFromatIndexintoofTypewithSize(_argumentsArrayOop, _i, _argHolder, (_argType->type), (_argType->size));
		if (GIV(primFailCode)) {
			/* begin freeArgumentsArray:count: */
			for (_i2 = 0; _i2 < _argumentSize; _i2 += 1) {
				{
					_aPtr = _parameters[_i2];
					if (!(_aPtr == null)) {
						_parameters[_i2] = null;
						free(_aPtr);
					}
				}
			}
			free(_parameters);
			/* end freeArgumentsArray:count: */
			/* begin primitiveFailFor: */
			return (GIV(primFailCode) = PrimErrBadArgument);
			/* end primitiveFailFor: */
		}
	}
	if (((((_cif->rtype))->size)) > 0) {
		_returnHolder = malloc(((((((_cif->rtype))->size)) < BytesPerWord) ? BytesPerWord : (((_cif->rtype))->size)));
	} else {
		_returnHolder = null;
	}
	_task = worker_task_new(_externalFunction, _cif, _parameters, _returnHolder, _semaphoreIndex);
	worker_dispatch_callout(_worker, _task);
	/* begin pop:thenPush: */
	/* begin newExternalAddressWithValue: */
	_aPointer = ((sqInt) ((void*) ((sqInt) _task ) ) );
	/* begin instantiateClass:indexableSize: */
	_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ));
	_nElements = sizeof(void*);
	_oop2 = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, _nElements, 0, 0);
	/* end instantiateClass:indexableSize: */
	_ptr = ((void **) (firstIndexableField(_oop2)) );
	_ptr[0] = ((sqIntptr_t) _aPointer );
	_oop = _oop2;
	/* end newExternalAddressWithValue: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((4 - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	return 0;
}
#endif /* FEATURE_THREADED_FFI */
/*	Actual primitive implementation of primitiveWorkerExtractReturnValue. 
	Because of Slang restrictions, making FFI optional requires cutting the 
	primitive in two different methods. Otherwise slang will unconditionally 
	do all local declarations which may refer to invalid types if FFI is not 
	enabled.  
	Method primitiveWorkerExtractReturnValue checks if the feature is 
	available. If so, it calls this method. */
/* StackInterpreterPrimitives>>#doPrimitiveWorkerExtractReturnValue */

#if FEATURE_THREADED_FFI
static sqInt
doPrimitiveWorkerExtractReturnValue(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	void * _anAddress;
	sqInt _anInteger;
	sqInt _anOop;
	sqInt _anParameterAddress;
	sqInt _i;
	int _PARAM_RECEIVER;
	int _PARAM_TASK_ADDRESS;
	void ** _parameters;
	sqInt _primitiveReceiver;
	void *_returnHolder;
	WorkerTask *_task;
	void * _taskAddress;

	_PARAM_RECEIVER = 1;
	_PARAM_TASK_ADDRESS = 0;
	/* begin readAddress: */
	_anOop = unsignedLongAt(GIV(stackPointer) + (_PARAM_TASK_ADDRESS * BytesPerWord));
	if (!(isKindOfClass(_anOop, unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ))))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_taskAddress = null;
		goto l6;
	}
	/* begin fetchPointer:ofObject: */
	_taskAddress = unsignedLongAt((_anOop + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	l6:
	;
	/* end readAddress: */
	/* begin stackValue: */
	_primitiveReceiver = unsignedLongAt(GIV(stackPointer) + (_PARAM_RECEIVER * BytesPerWord));
	/* end stackValue: */
	/* begin getWorkerFromAddress: */
	_anInteger = ((sqInt) (getHandler(_primitiveReceiver)) );
	/* end getWorkerFromAddress: */
	if (GIV(primFailCode)) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadArgument);
		/* end primitiveFailFor: */
	}
	/* begin getTaskFromAddress: */
	_task = ((WorkerTask *) _taskAddress );
	/* end getTaskFromAddress: */
	if (!_task) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadReceiver);
		/* end primitiveFailFor: */
	}
	_returnHolder = (_task->returnHolderAddress);
	marshallAndPushReturnValueFromofTypepoping(_returnHolder, (((_task->cif))->rtype), 2);
	/* begin freeTask */
	{
		_anAddress = (_task->parametersAddress);
		if (!(_anAddress == null)) {
			_parameters = ((void **) _anAddress );
			for (_i = 0; _i < ((((_task->cif))->nargs)); _i += 1) {
				_anParameterAddress = _parameters[_i];
				if (!(_anParameterAddress == null)) {
					doFreeFromTask(_task, _anParameterAddress);
				}
			}
			doFreeFromTask(_task, _parameters);
		}
	}
	{
		_anAddress = (_task->returnHolderAddress);
		if (!(_anAddress == null)) {
			doFreeFromTask(_task, _anAddress);
		}
	}
	doFreeFromTask(_task, ((sqInt) _task ));
	/* end freeTask */
	return 0;
}
#endif /* FEATURE_THREADED_FFI */
/* StackInterpreterPrimitives>>#getHandler: */
void *
getHandler(sqInt _anOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _anOop2;

	if ((!(((_anOop & (tagMask())) == 0) && (((((usqInt) (longAt(_anOop)) ) >> (formatShift())) & (formatMask())) <= 5))) || ((slotSizeOf(_anOop)) < 1)) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return null;
	}
	/* begin readAddress: */
	_anOop2 = unsignedLongAt((_anOop + BaseHeaderSize) + (0U << (shiftForWord())));
	if (!(isKindOfClass(_anOop2, unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ))))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return null;
	}
	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((_anOop2 + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	/* end readAddress: */
}
/* StackInterpreterPrimitives>>#isAppropriateForCopyObject: */
static sqInt NoDbgRegParms
isAppropriateForCopyObject(sqInt _oop)
{
	if (!(((((usqInt) (longAt(_oop)) ) >> (formatShift())) & (formatMask())) <= 5)) {
		return 0;
	}
	if (((_oop & (tagMask())) == 0) && (((longAt(_oop)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
		return !(((((unsignedLongAt((_oop + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_oop))));
	}
	return 1;
}
/* StackInterpreterPrimitives>>#marshallAndPushReturnValueFrom:ofType:poping: */

#if FEATURE_FFI
static void NoDbgRegParms
marshallAndPushReturnValueFromofTypepoping(sqInt _returnHolder, ffi_type *_ffiType, sqInt _argumentsAndReceiverCount)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aPointer;
	sqInt _classObj;
	sqInt _classObj2;
	double _f;
	double _f2;
	float * _floatPtr;
	double * _floatPtr2;
	sqInt _integerVal;
	sqInt _integerVal2;
	sqInt _integerVal3;
	sqInt _integerVal4;
	sqInt _integerValue;
	unsigned int _integerValue2;
	sqInt _nElements;
	sqInt _oop;
	sqInt _oop2;
	sqInt _oop3;
	sqInt _oop4;
	sqInt _oop5;
	sqInt _oop6;
	sqInt _oop7;
	sqInt _oop8;
	void **_ptr;
	sqInt _sizeToCopy;
	char *_sp;
	char *_sp10;
	char *_sp11;
	char *_sp12;
	char *_sp2;
	char *_sp3;
	char *_sp4;
	char *_sp5;
	char *_sp6;
	char *_sp7;
	char *_sp8;
	char *_sp9;
	void * _targetPointer;

	switch ((_ffiType->type)) {
		case FFI_TYPE_SINT8:
		{
			/* begin pop:thenPushInteger: */
			_integerVal = ((sqInt) (readSINT8AtPointer(_returnHolder)) );
			unsignedLongAtput((_sp9 = GIV(stackPointer) + ((_argumentsAndReceiverCount - 1) * BytesPerWord)), ((((usqInt) _integerVal ) << 3) | 1));
			GIV(stackPointer) = _sp9;
			/* end pop:thenPushInteger: */
		}
		break;
		case FFI_TYPE_SINT16:
		{
			/* begin pop:thenPushInteger: */
			_integerVal2 = ((sqInt) (readSINT16AtPointer(_returnHolder)) );
			unsignedLongAtput((_sp10 = GIV(stackPointer) + ((_argumentsAndReceiverCount - 1) * BytesPerWord)), ((((usqInt) _integerVal2 ) << 3) | 1));
			GIV(stackPointer) = _sp10;
			/* end pop:thenPushInteger: */
		}
		break;
		case FFI_TYPE_SINT32:
		{
			/* begin pop:thenPush: */
			/* begin signed32BitIntegerFor: */
			_integerValue = ((sqInt) (readSINT32AtPointer(_returnHolder)) );
			{
				_oop = ((((usqInt) ((int) _integerValue ) ) << 3) | 1);
				goto l4;
			}
			l4:
			;
			/* end signed32BitIntegerFor: */
			unsignedLongAtput((_sp = GIV(stackPointer) + ((_argumentsAndReceiverCount - 1) * BytesPerWord)), _oop);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
		}
		break;
		case FFI_TYPE_SINT64:
		{
			/* begin pop:thenPush: */
			_oop2 = signed64BitIntegerFor(readSINT64AtPointer(_returnHolder));
			unsignedLongAtput((_sp2 = GIV(stackPointer) + ((_argumentsAndReceiverCount - 1) * BytesPerWord)), _oop2);
			GIV(stackPointer) = _sp2;
			/* end pop:thenPush: */
		}
		break;
		case FFI_TYPE_UINT8:
		{
			/* begin pop:thenPushInteger: */
			_integerVal3 = ((sqInt) (readUINT8AtPointer(_returnHolder)) );
			unsignedLongAtput((_sp11 = GIV(stackPointer) + ((_argumentsAndReceiverCount - 1) * BytesPerWord)), ((((usqInt) _integerVal3 ) << 3) | 1));
			GIV(stackPointer) = _sp11;
			/* end pop:thenPushInteger: */
		}
		break;
		case FFI_TYPE_UINT16:
		{
			/* begin pop:thenPushInteger: */
			_integerVal4 = ((sqInt) (readUINT16AtPointer(_returnHolder)) );
			unsignedLongAtput((_sp12 = GIV(stackPointer) + ((_argumentsAndReceiverCount - 1) * BytesPerWord)), ((((usqInt) _integerVal4 ) << 3) | 1));
			GIV(stackPointer) = _sp12;
			/* end pop:thenPushInteger: */
		}
		break;
		case FFI_TYPE_UINT32:
		{
			/* begin pop:thenPush: */
			/* begin positive32BitIntegerFor: */
			_integerValue2 = ((unsigned int) (readUINT32AtPointer(_returnHolder)) );
			{
				_oop3 = (((((usqInt) _integerValue2 ) & 0xFFFFFFFFU) << 3) | 1);
				goto l5;
			}
			l5:
			;
			/* end positive32BitIntegerFor: */
			unsignedLongAtput((_sp3 = GIV(stackPointer) + ((_argumentsAndReceiverCount - 1) * BytesPerWord)), _oop3);
			GIV(stackPointer) = _sp3;
			/* end pop:thenPush: */
		}
		break;
		case FFI_TYPE_UINT64:
		{
			/* begin pop:thenPush: */
			_oop4 = positive64BitIntegerFor(readUINT64AtPointer(_returnHolder));
			unsignedLongAtput((_sp4 = GIV(stackPointer) + ((_argumentsAndReceiverCount - 1) * BytesPerWord)), _oop4);
			GIV(stackPointer) = _sp4;
			/* end pop:thenPush: */
		}
		break;
		case FFI_TYPE_POINTER:
		{
			/* begin pop:thenPush: */
			/* begin newExternalAddressWithValue: */
			_aPointer = ((sqInt) (readPointerAtPointer(_returnHolder)) );
			/* begin instantiateClass:indexableSize: */
			_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ));
			_nElements = sizeof(void*);
			_oop7 = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, _nElements, 0, 0);
			/* end instantiateClass:indexableSize: */
			_ptr = ((void **) (firstIndexableField(_oop7)) );
			_ptr[0] = ((sqIntptr_t) _aPointer );
			_oop5 = _oop7;
			/* end newExternalAddressWithValue: */
			unsignedLongAtput((_sp5 = GIV(stackPointer) + ((_argumentsAndReceiverCount - 1) * BytesPerWord)), _oop5);
			GIV(stackPointer) = _sp5;
			/* end pop:thenPush: */
		}
		break;
		case FFI_TYPE_STRUCT:
		{
			/* begin pop:thenPush: */
			/* begin newByteArrayWithStructContent:size: */
			_sizeToCopy = (_ffiType->size);
			/* begin instantiateClass:indexableSize: */
			_classObj2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteArray ) << (shiftForWord())) ));
			_oop8 = instantiateClassindexableSizeisPinnedisOldSpace(_classObj2, _sizeToCopy, 0, 0);
			/* end instantiateClass:indexableSize: */
			_targetPointer = firstIndexableField(_oop8);
			memcpy(_targetPointer, _returnHolder, _sizeToCopy);
			_oop6 = _oop8;
			/* end newByteArrayWithStructContent:size: */
			unsignedLongAtput((_sp6 = GIV(stackPointer) + ((_argumentsAndReceiverCount - 1) * BytesPerWord)), _oop6);
			GIV(stackPointer) = _sp6;
			/* end pop:thenPush: */
		}
		break;
		case FFI_TYPE_FLOAT:
		{
			/* begin pop:thenPushFloat: */
			/* begin readFloat32AtPointer: */
			_floatPtr = ((float *) _returnHolder );
			_f = _floatPtr[0];
			/* end readFloat32AtPointer: */
			unsignedLongAtput((_sp7 = GIV(stackPointer) + ((_argumentsAndReceiverCount - 1) * BytesPerWord)), floatObjectOf(_f));
			GIV(stackPointer) = _sp7;
			/* end pop:thenPushFloat: */
		}
		break;
		case FFI_TYPE_DOUBLE:
		{
			/* begin pop:thenPushFloat: */
			/* begin readFloat64AtPointer: */
			_floatPtr2 = ((double *) _returnHolder );
			_f2 = _floatPtr2[0];
			/* end readFloat64AtPointer: */
			unsignedLongAtput((_sp8 = GIV(stackPointer) + ((_argumentsAndReceiverCount - 1) * BytesPerWord)), floatObjectOf(_f2));
			GIV(stackPointer) = _sp8;
			/* end pop:thenPushFloat: */
		}
		break;
		case FFI_TYPE_VOID:
		{
			/* begin pop: */
			GIV(stackPointer) += (_argumentsAndReceiverCount - 1) * BytesPerWord;
			/* end pop: */
		}
		break;
		default:
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
		}
	}
}
#endif /* FEATURE_FFI */
/* StackInterpreterPrimitives>>#marshallArgumentFrom:atIndex:into:ofType:withSize: */

#if FEATURE_FFI
static void NoDbgRegParms
marshallArgumentFromatIndexintoofTypewithSize(sqInt _argumentsArrayOop, sqInt _i, sqInt _argHolder, sqInt _argType, sqInt _argTypeSize)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	void * _address;
	double * _doubleHolder;
	sqInt _externalAddress;
	float * _floatHolder;
	int8_t * _intHolder;
	int16_t * _intHolder2;
	uint16_t * _intHolder3;
	int64_t * _intHolder4;
	uint8_t * _intHolder5;
	int32_t * _intHolder6;
	uint32_t * _intHolder7;
	uint64_t * _intHolder8;
	sqInt _oop;
	sqInt _oop2;
	void ** _pointerHolder;
	void * _srcPtr;
	sqInt _tagBits;
	sqInt _tagBits2;
	sqInt _value;
	sqInt _value2;
	sqInt _value3;
	sqLong _value4;
	sqInt _value5;
	int _value6;
	unsigned int _value7;
	usqLong _value8;

	switch (_argType) {
		case FFI_TYPE_POINTER:
		{
			/* begin marshallPointerFrom:at:into: */
			_pointerHolder = ((void **) _argHolder );
			/* begin fetchPointer:ofObject: */
			_externalAddress = unsignedLongAt((_argumentsArrayOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			_pointerHolder[0] = readAddress(_externalAddress);
			/* end marshallPointerFrom:at:into: */
		}
		break;
		case FFI_TYPE_STRUCT:
		{
			/* begin marshallStructFrom:at:into:withSize: */
			/* begin fetchPointer:ofObject: */
			_oop2 = unsignedLongAt((_argumentsArrayOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if ((((((_tagBits = _oop2 & (tagMask()))) != 0)
				 ? unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) ))
				 : fetchClassOfNonImm(_oop2))) == (unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) )))) {
				/* begin readAddress: */
				if (!(isKindOfClass(_oop2, unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ))))) {
					/* begin primitiveFail */
					if (!GIV(primFailCode)) {
						GIV(primFailCode) = 1;
					}
					/* end primitiveFail */
					_address = null;
					goto l11;
				}
				/* begin fetchPointer:ofObject: */
				_address = unsignedLongAt((_oop2 + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofObject: */
				l11:
				;
				/* end readAddress: */
				if (_address == 0) {
					/* begin primitiveFailFor: */
					GIV(primFailCode) = PrimErrBadArgument;
					goto l13;
					/* end primitiveFailFor: */
				}
			} else {
				if (!((((((_tagBits2 = _oop2 & (tagMask()))) != 0)
					 ? unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits2 ) << (shiftForWord())) ))
					 : fetchClassOfNonImm(_oop2))) == (unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteArray ) << (shiftForWord())) ))))) {
					/* begin primitiveFailFor: */
					GIV(primFailCode) = PrimErrBadArgument;
					goto l13;
					/* end primitiveFailFor: */
				}
				_address = firstIndexableField(_oop2);
			}
			_srcPtr = ((void *) _address );
			memcpy(_argHolder, _srcPtr, _argTypeSize);
			l13:
			;
			/* end marshallStructFrom:at:into:withSize: */
		}
		break;
		case FFI_TYPE_FLOAT:
		{
			/* begin marshallFloatFrom:at:into: */
			_floatHolder = ((float *) _argHolder );
			_floatHolder[0] = fetchFloatofObject(_i, _argumentsArrayOop);
			/* end marshallFloatFrom:at:into: */
		}
		break;
		case FFI_TYPE_DOUBLE:
		{
			/* begin marshallDoubleFrom:at:into: */
			_doubleHolder = ((double *) _argHolder );
			_doubleHolder[0] = fetchFloatofObject(_i, _argumentsArrayOop);
			/* end marshallDoubleFrom:at:into: */
		}
		break;
		case FFI_TYPE_SINT8:
		{
			/* begin marshallSInt8From:at:into: */
			_value = fetchIntegerofObject(_i, _argumentsArrayOop);
			if (_value > INT8_MAX) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l3;
				/* end primitiveFailFor: */
			}
			if (_value < INT8_MIN) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l3;
				/* end primitiveFailFor: */
			}
			_intHolder = ((int8_t *) _argHolder );
			_intHolder[0] = fetchIntegerofObject(_i, _argumentsArrayOop);
			l3:
			;
			/* end marshallSInt8From:at:into: */
		}
		break;
		case FFI_TYPE_UINT8:
		{
			/* begin marshallUInt8From:at:into: */
			/* begin fetchPointer:ofObject: */
			_oop = unsignedLongAt((_argumentsArrayOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (_oop & (characterTag())) {
				/* begin characterValueOf: */
				_value5 = ((usqInt) ((usqInt) _oop ) ) >> (numTagBits());
				/* end characterValueOf: */
			} else {
				_value5 = _oop >> 3;
			}
			if (_value5 < 0) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l9;
				/* end primitiveFailFor: */
			}
			if (_value5 > UINT8_MAX) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l9;
				/* end primitiveFailFor: */
			}
			_intHolder5 = ((uint8_t *) _argHolder );
			_intHolder5[0] = _value5;
			l9:
			;
			/* end marshallUInt8From:at:into: */
		}
		break;
		case FFI_TYPE_SINT16:
		{
			/* begin marshallSInt16From:at:into: */
			_value2 = fetchIntegerofObject(_i, _argumentsArrayOop);
			if (_value2 > INT16_MAX) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l4;
				/* end primitiveFailFor: */
			}
			if (_value2 < INT16_MIN) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l4;
				/* end primitiveFailFor: */
			}
			_intHolder2 = ((int16_t *) _argHolder );
			_intHolder2[0] = _value2;
			l4:
			;
			/* end marshallSInt16From:at:into: */
		}
		break;
		case FFI_TYPE_UINT16:
		{
			/* begin marshallUInt16From:at:into: */
			_value3 = fetchIntegerofObject(_i, _argumentsArrayOop);
			if (_value3 < 0) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l5;
				/* end primitiveFailFor: */
			}
			if (_value3 > UINT16_MAX) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l5;
				/* end primitiveFailFor: */
			}
			_intHolder3 = ((uint16_t *) _argHolder );
			_intHolder3[0] = _value3;
			l5:
			;
			/* end marshallUInt16From:at:into: */
		}
		break;
		case FFI_TYPE_SINT32:
		{
			/* begin marshallSInt32From:at:into: */
			_value6 = signed32BitValueOf(unsignedLongAt((_argumentsArrayOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )));
			if (GIV(primFailCode)) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l14;
				/* end primitiveFailFor: */
			}
			_intHolder6 = ((int32_t *) _argHolder );
			_intHolder6[0] = _value6;
			l14:
			;
			/* end marshallSInt32From:at:into: */
		}
		break;
		case FFI_TYPE_UINT32:
		{
			/* begin marshallUInt32From:at:into: */
			_value7 = positive32BitValueOf(unsignedLongAt((_argumentsArrayOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )));
			if (GIV(primFailCode)) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l15;
				/* end primitiveFailFor: */
			}
			_intHolder7 = ((uint32_t *) _argHolder );
			_intHolder7[0] = _value7;
			l15:
			;
			/* end marshallUInt32From:at:into: */
		}
		break;
		case FFI_TYPE_SINT64:
		{
			/* begin marshallSInt64From:at:into: */
			_value4 = signed64BitValueOf(unsignedLongAt((_argumentsArrayOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )));
			if (GIV(primFailCode)) {
				goto l6;
			}
			_intHolder4 = ((int64_t *) _argHolder );
			_intHolder4[0] = _value4;
			l6:
			;
			/* end marshallSInt64From:at:into: */
		}
		break;
		case FFI_TYPE_UINT64:
		{
			/* begin marshallUInt64From:at:into: */
			_value8 = positive64BitValueOf(unsignedLongAt((_argumentsArrayOop + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) )));
			if (GIV(primFailCode)) {
				goto l16;
			}
			_intHolder8 = ((uint64_t *) _argHolder );
			_intHolder8[0] = _value8;
			l16:
			;
			/* end marshallUInt64From:at:into: */
		}
		break;
		default:
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
		}
	}
}
#endif /* FEATURE_FFI */
/*	Return an int of the address of the byteSize slot (byte, short, int, 
	whatever) at byteOffset in rcvr. 
	If the rcvr is an ExternalAddress the initial address is its contents. If 
	the receiver is a byte array, the address is inside the byte array */
/* StackInterpreterPrimitives>>#maybeExternalAddressOf:startingAt:size: */
static sqInt NoDbgRegParms
maybeExternalAddressOfstartingAtsize(sqInt _rcvr, sqInt _byteOffset, sqInt _byteSize)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _addr;
	sqInt _fmt;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvrClass;
	sqInt _rcvrSize;
	sqInt _tagBits;

	if (!(((_rcvr & (tagMask())) == 0) && (((((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	if (!(_byteOffset > 0)) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	/* begin fetchClassOf: */
	_rcvrClass = ((((_tagBits = _rcvr & (tagMask()))) != 0)
		 ? unsignedLongAt((GIV(classTableFirstPage) + BaseHeaderSize) + ((sqInt) (((usqInt) _tagBits ) << (shiftForWord())) ))
		 : fetchClassOfNonImm(_rcvr));
	/* end fetchClassOf: */
	/* begin byteSizeOf: */
	if (_rcvr & (tagMask())) {
		_rcvrSize = 0;
		goto l5;
	}
	/* begin numBytesOf: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt >= (firstByteFormat())) {
		_rcvrSize = _numBytes - (_fmt & 7);
		goto l5;
	}
	if (_fmt <= (sixtyFourBitIndexableFormat())) {
		_rcvrSize = _numBytes;
		goto l5;
	}
	if (_fmt >= (firstShortFormat())) {
		_rcvrSize = _numBytes - ((sqInt) (((usqInt) (_fmt & 3) ) << 1) );
		goto l5;
	}
	_rcvrSize = _numBytes - ((sqInt) (((usqInt) (_fmt & 1) ) << 2) );
	/* end numBytesOf: */
	l5:
	;
	/* end byteSizeOf: */
	if (_rcvrClass == (unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) )))) {
		if (!(_rcvrSize == BytesPerWord)) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			return null;
			/* end primitiveFail */
		}
		/* begin fetchPointer:ofObject: */
		_addr = unsignedLongAt((_rcvr + BaseHeaderSize) + (0U << (shiftForWord())));
		/* end fetchPointer:ofObject: */
		if (_addr == 0) {
			return 0;
		}
	} else {
		if (!(((_byteOffset + _byteSize) - 1) <= _rcvrSize)) {
			return 0;
		}
		_addr = ((sqIntptr_t) (firstIndexableField(_rcvr)) );
	}
	_addr = (_addr + _byteOffset) - 1;
	return _addr;
}
/* StackInterpreterPrimitives>>#noInlineLoadFloatOrIntFrom: */
static double NoDbgRegParms NeverInline
noInlineLoadFloatOrIntFrom(sqInt _floatOrInt)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _bits;
	double _result;
	usqLong _rot;
	sqInt _shift;
	sqInt _tagBits;
	double _value;

	/* begin loadFloatOrIntFrom: */
	if (((_tagBits = _floatOrInt & (tagMask()))) != 0) {
		if (_tagBits == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(_floatOrInt));
			_rot = ((usqInt) ((usqInt) _floatOrInt ) ) >> (numTagBits());
			if (_rot > 1) {
				_rot += ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
			}
			/* begin rotateRight: */
			_rot = (_rot << 0x3F) + (((usqInt) ((usqInt) _rot ) ) >> 1);
			/* end rotateRight: */
			_bits = _rot;
			/* end smallFloatBitsOf: */
			{
				memcpy(&_value, &_bits, sizeof(_value));
				return _value;
			}
			return null;
			/* end smallFloatValueOf: */
		}
		if ((_tagBits == (smallIntegerTag())) && (((_shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) _floatOrInt ) << _shift) ) ) >> _shift) == _floatOrInt))) {
			return ((double) (_floatOrInt >> 3) );
		}
	} else {
		if (((longAt(_floatOrInt)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(_floatOrInt + BaseHeaderSize, _result);
			return _result;
		}
	}
	_result = 0;
	_value = 0;
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	return 0.0;
	/* end loadFloatOrIntFrom: */
}
/*	Return a shallow copy of the receiver. 
	Special-case non-single contexts (because of context-to-stack mapping). 
	Can't fail for contexts cuz of image context instantiation code (sigh). */
/* StackInterpreterPrimitives>>#primitiveClone */
static void
primitiveClone(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _newCopy;
	sqInt _rcvr;
	char *_sp;

	/* begin stackTop */
	_rcvr = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	if (_rcvr & (tagMask())) {
		_newCopy = _rcvr;
	} else {
		if (((longAt(_rcvr)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
			_newCopy = cloneContext(_rcvr);
		} else {
			if ((GIV(argumentCount) == 0) || (!(((long64At(_rcvr)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))) {
				_newCopy = cloneshouldAllocateInPermSpace(_rcvr, 0);
			} else {
				_newCopy = 0;
			}
		}
		if (_newCopy == 0) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrNoMemory;
			return;
			/* end primitiveFailFor: */
		}
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _newCopy);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Special version of primitiveAt for accessing contexts. 
	Written to be varargs for use from mirror primitives. */
/* StackInterpreterPrimitives>>#primitiveContextAt */
static void
primitiveContextAt(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aContext;
	sqInt _class;
	sqInt _class2;
	sqInt _classFormat;
	sqInt _classFormat2;
	sqInt _fixedFields;
	sqInt _fixedFields2;
	usqLong _fmt;
	sqInt _fmt2;
	sqInt _frameNumArgs;
	sqInt _frameNumArgs2;
	sqLong _hdr;
	sqInt _index;
	unsigned int _integerValue;
	unsigned int _integerValue2;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots22;
	usqInt _numSlots3;
	sqInt _reasonCode;
	sqInt _senderOop;
	char *_sp;
	char *_sp2;
	sqInt _sp22;
	char *_sp3;
	sqInt _sp4;
	sqInt _sp5;
	char *_spouseFP;
	sqInt _stSize;
	sqInt _stSize2;
	char *_theSP;
	sqInt _totalLength;
	sqInt _totalLength2;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	if (!(((_index & 7) == 1))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		/* end primitiveFailFor: */
		return;
	}
	_index = _index >> 3;
	/* begin stackValue: */
	_aContext = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin baseHeader: */
	_hdr = long64At(_aContext);
	/* end baseHeader: */
	if (!((_hdr & (classIndexMask())) == ClassMethodContextCompactIndex)) {
		/* begin stObject:at: */
		_fmt2 = (((usqInt) (longAt(_aContext)) ) >> (formatShift())) & (formatMask());
		/* begin lengthOf:format: */
		/* begin numSlotsOfAny: */
		_numSlots22 = byteAt(_aContext + 7);
		_numSlots3 = ((_numSlots22 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_aContext - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots22);
		/* end numSlotsOfAny: */
		if (_fmt2 <= 5) {
			_totalLength2 = _numSlots3;
			goto l16;
		}
		if (_fmt2 >= (firstByteFormat())) {
			_totalLength2 = (_numSlots3 << (shiftForWord())) - (_fmt2 & 7);
			goto l16;
		}
		if (_fmt2 >= (firstShortFormat())) {
			_totalLength2 = (_numSlots3 << ((shiftForWord()) - 1)) - (_fmt2 & 3);
			goto l16;
		}
		if (_fmt2 >= (firstLongFormat())) {
			_totalLength2 = (_numSlots3 << ((shiftForWord()) - 2)) - (_fmt2 & 1);
			goto l16;
		}
		if (_fmt2 == (sixtyFourBitIndexableFormat())) {
			_totalLength2 = _numSlots3;
			goto l16;
		}
		_totalLength2 = 0;
		l16:
		;
		/* end lengthOf:format: */
		/* begin fixedFieldsOf:format:length: */
		if ((_fmt2 >= (sixtyFourBitIndexableFormat())) || (_fmt2 == 2)) {
			_fixedFields2 = 0;
			goto l19;
		}
		if (_fmt2 < 2) {
			_fixedFields2 = _totalLength2;
			goto l19;
		}
		_class2 = fetchClassOfNonImm(_aContext);
		/* begin fixedFieldsOfClassFormat: */
		_classFormat2 = (unsignedLongAt((_class2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
		_fixedFields2 = _classFormat2 & ((1U << (fixedFieldsFieldWidth())) - 1);
		/* end fixedFieldsOfClassFormat: */
		l19:
		;
		/* end fixedFieldsOf:format:length: */
		if ((_fmt2 == (indexablePointersFormat())) && (((long64At(_aContext)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
			/* begin stackPointerForMaybeMarriedContext: */
			if (((((unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_aContext)))) {
				_sp5 = stackPointerIndexForFrame(frameOfMarriedContext(_aContext));
				assert((ReceiverIndex + (_sp5 >> 3)) < (lengthOf(_aContext)));
				_stSize2 = _sp5;
				goto l18;
			}
			/* begin fetchStackPointerOf: */
			/* begin fetchPointer:ofObject: */
			_sp22 = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (!(((_sp22 & 7) == 1))) {
				_stSize2 = 0;
				goto l18;
			}
			assert((ReceiverIndex + (_sp22 >> 3)) < (lengthOf(_aContext)));
			_stSize2 = _sp22 >> 3;
			/* end fetchStackPointerOf: */
			l18:
			;
			/* end stackPointerForMaybeMarriedContext: */
			if ((oopisGreaterThanOrEqualTo(_index, 1)) && ((oopisLessThanOrEqualTo(_index, _stSize2)) && (((((unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_aContext)))))) {
				_value = noInlineTemporaryin(_index - 1, frameOfMarriedContext(_aContext));
				goto l22;
			}
		} else {
			_stSize2 = _totalLength2 - _fixedFields2;
		}
		if ((oopisGreaterThanOrEqualTo(_index, ((_fmt2 >= (firstCompiledMethodFormat()))
			 ? (((literalCountOf(_aContext)) + LiteralStart) * BytesPerOop) + 1
			 : 1))) && (oopisLessThanOrEqualTo(_index, _stSize2))) {
			/* begin subscript:with:format: */
			if (_fmt2 <= 5) {
				/* begin fetchPointer:ofObject: */
				_value = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields2) - 1) ) << (shiftForWord())) ));
				goto l22;
				/* end fetchPointer:ofObject: */
			}
			if (_fmt2 >= (firstByteFormat())) {
				_value = ((((usqInt) (byteAt((_aContext + BaseHeaderSize) + ((_index + _fixedFields2) - 1))) ) << 3) | 1);
				goto l22;
			}
			if (_fmt2 >= (firstShortFormat())) {
				_value = ((((usqInt) ((unsigned short) (shortAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields2) - 1) ) << 1) ))) ) ) << 3) | 1);
				goto l22;
			}
			if (_fmt2 == (sixtyFourBitIndexableFormat())) {
				_value = positive64BitIntegerFor(long64At((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields2) - 1) ) << 3) )));
				goto l22;
			}
			/* begin positive32BitIntegerFor: */
			_integerValue2 = long32At((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields2) - 1) ) << 2) ));
			{
				_value = (((((usqInt) _integerValue2 ) & 0xFFFFFFFFU) << 3) | 1);
				goto l22;
			}
			/* end positive32BitIntegerFor: */
			/* end subscript:with:format: */
		}
		/* begin primitiveFailFor: */
		_reasonCode = ((_fmt2 <= 1)
			 ? PrimErrBadReceiver
			 : PrimErrBadIndex);
		GIV(primFailCode) = _reasonCode;
		/* end primitiveFailFor: */
		_value = 0;
		l22:
		;
		/* end stObject:at: */
		if (!GIV(primFailCode)) {
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _value);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
		}
		return;
	}
	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	_theSP = GIV(stackPointer);
	assert(_theSP < GIV(framePointer));
	assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(GIV(stackPage)->headFP = GIV(framePointer));
		(GIV(stackPage)->headSP = _theSP);
	}
	/* end setHeadFP:andSP:inPage: */
	assert(pageListIsWellFormed());
	/* end writeBackHeadFramePointers */
	if (!(((((unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_aContext))))) {
		_fmt = (((unsigned sqLong) _hdr ) >> (formatShift())) & (formatMask());
		/* begin lengthOf:format: */
		/* begin numSlotsOfAny: */
		_numSlots2 = byteAt(_aContext + 7);
		_numSlots = ((_numSlots2 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_aContext - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots2);
		/* end numSlotsOfAny: */
		if (_fmt <= 5) {
			_totalLength = _numSlots;
			goto l11;
		}
		if (_fmt >= (firstByteFormat())) {
			_totalLength = (_numSlots << (shiftForWord())) - (_fmt & 7);
			goto l11;
		}
		if (_fmt >= (firstShortFormat())) {
			_totalLength = (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
			goto l11;
		}
		if (_fmt >= (firstLongFormat())) {
			_totalLength = (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
			goto l11;
		}
		if (_fmt == (sixtyFourBitIndexableFormat())) {
			_totalLength = _numSlots;
			goto l11;
		}
		_totalLength = 0;
		l11:
		;
		/* end lengthOf:format: */
		/* begin fixedFieldsOf:format:length: */
		if ((_fmt >= (sixtyFourBitIndexableFormat())) || (_fmt == 2)) {
			_fixedFields = 0;
			goto l12;
		}
		if (_fmt < 2) {
			_fixedFields = _totalLength;
			goto l12;
		}
		_class = fetchClassOfNonImm(_aContext);
		/* begin fixedFieldsOfClassFormat: */
		_classFormat = (unsignedLongAt((_class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
		_fixedFields = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
		/* end fixedFieldsOfClassFormat: */
		l12:
		;
		/* end fixedFieldsOf:format:length: */
		/* begin fetchStackPointerOf: */
		/* begin fetchPointer:ofObject: */
		_sp4 = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (!(((_sp4 & 7) == 1))) {
			_stSize = 0;
			goto l14;
		}
		assert((ReceiverIndex + (_sp4 >> 3)) < (lengthOf(_aContext)));
		_stSize = _sp4 >> 3;
		l14:
		;
		/* end fetchStackPointerOf: */
		if (!((_index >= 1) && (_index <= _stSize))) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadIndex;
			/* end primitiveFailFor: */
			return;
		}
		/* begin subscript:with:format: */
		if (_fmt <= 5) {
			/* begin fetchPointer:ofObject: */
			_value = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << (shiftForWord())) ));
			goto l15;
			/* end fetchPointer:ofObject: */
		}
		if (_fmt >= (firstByteFormat())) {
			_value = ((((usqInt) (byteAt((_aContext + BaseHeaderSize) + ((_index + _fixedFields) - 1))) ) << 3) | 1);
			goto l15;
		}
		if (_fmt >= (firstShortFormat())) {
			_value = ((((usqInt) ((unsigned short) (shortAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 1) ))) ) ) << 3) | 1);
			goto l15;
		}
		if (_fmt == (sixtyFourBitIndexableFormat())) {
			_value = positive64BitIntegerFor(long64At((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 3) )));
			goto l15;
		}
		/* begin positive32BitIntegerFor: */
		_integerValue = long32At((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 2) ));
		{
			_value = (((((usqInt) _integerValue ) & 0xFFFFFFFFU) << 3) | 1);
			goto l15;
		}
		/* end positive32BitIntegerFor: */
		l15:
		;
		/* end subscript:with:format: */
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp2 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _value);
		GIV(stackPointer) = _sp2;
		/* end pop:thenPush: */
		return;
	}
	/* begin frameOfMarriedContext: */
	/* begin fetchPointer:ofObject: */
	_senderOop = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	{
		assert(((_senderOop & 7) == 1));
		_spouseFP = pointerForOop(_senderOop - 1);
	}
	/* end frameOfMarriedContext: */
	if (!((_index >= 1) && (_index <= (stackPointerIndexForFrame(_spouseFP))))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		/* end primitiveFailFor: */
		return;
	}
	if (isMachineCodeIP(((usqInt) (unsignedLongAt(_spouseFP + FoxMethod)) ))) {
		_value = (((_index - 1) < ((_frameNumArgs = ((((CogMethod *) ((unsignedLongAt(_spouseFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs))))
			 ? unsignedLongAt((_spouseFP + FoxCallerSavedIP) + ((_frameNumArgs - (_index - 1)) * BytesPerWord))
			 : unsignedLongAt(((((isMachineCodeIP(((usqInt) (unsignedLongAt(_spouseFP + FoxMethod)) )))
				 ? _spouseFP + FoxMFReceiver
				 : _spouseFP + FoxIFReceiver)) - BytesPerWord) + ((_frameNumArgs - (_index - 1)) * BytesPerWord)));
	} else {
		{
			_value = (((_index - 1) < ((_frameNumArgs2 = byteAt((_spouseFP + FoxIFrameFlags) + 1))))
				 ? unsignedLongAt((_spouseFP + FoxCallerSavedIP) + ((_frameNumArgs2 - (_index - 1)) * BytesPerWord))
				 : unsignedLongAt(((_spouseFP + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs2 - (_index - 1)) * BytesPerWord)));
		}
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp3 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _value);
	GIV(stackPointer) = _sp3;
	/* end pop:thenPush: */
}
/*	Special version of primitiveAtPut for accessing contexts. 
	Written to be varargs for use from mirror primitives. */
/* StackInterpreterPrimitives>>#primitiveContextAtPut */
static void
primitiveContextAtPut(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aContext;
	sqInt _class;
	sqInt _classFormat;
	sqInt _fixedFields;
	usqLong _fmt;
	sqInt _frameNumArgs;
	sqInt _frameNumArgs2;
	sqLong _hdr;
	sqInt _index;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _senderOop;
	sqInt _signedValueToStore;
	char *_sp;
	char *_sp2;
	sqInt _sp3;
	char *_spouseFP;
	sqInt _stSize;
	char *_theSP;
	sqInt _totalLength;
	usqLong _unsigned64BitValueToStore;
	unsigned int _unsignedValueToStore;
	sqInt _value;

	/* begin stackTop */
	_value = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_aContext = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (!(((_index & 7) == 1))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		/* end primitiveFailFor: */
		return;
	}
	/* begin baseHeader: */
	_hdr = long64At(_aContext);
	/* end baseHeader: */
	_index = _index >> 3;
	if (!((_hdr & (classIndexMask())) == ClassMethodContextCompactIndex)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadReceiver;
		return;
		/* end primitiveFailFor: */
	}
	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	_theSP = GIV(stackPointer);
	assert(_theSP < GIV(framePointer));
	assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(GIV(stackPage)->headFP = GIV(framePointer));
		(GIV(stackPage)->headSP = _theSP);
	}
	/* end setHeadFP:andSP:inPage: */
	assert(pageListIsWellFormed());
	/* end writeBackHeadFramePointers */
	if (!(((((unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_aContext))))) {
		_fmt = (((unsigned sqLong) _hdr ) >> (formatShift())) & (formatMask());
		/* begin lengthOf:format: */
		/* begin numSlotsOfAny: */
		_numSlots2 = byteAt(_aContext + 7);
		_numSlots = ((_numSlots2 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_aContext - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots2);
		/* end numSlotsOfAny: */
		if (_fmt <= 5) {
			_totalLength = _numSlots;
			goto l12;
		}
		if (_fmt >= (firstByteFormat())) {
			_totalLength = (_numSlots << (shiftForWord())) - (_fmt & 7);
			goto l12;
		}
		if (_fmt >= (firstShortFormat())) {
			_totalLength = (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
			goto l12;
		}
		if (_fmt >= (firstLongFormat())) {
			_totalLength = (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
			goto l12;
		}
		if (_fmt == (sixtyFourBitIndexableFormat())) {
			_totalLength = _numSlots;
			goto l12;
		}
		_totalLength = 0;
		l12:
		;
		/* end lengthOf:format: */
		/* begin fixedFieldsOf:format:length: */
		if ((_fmt >= (sixtyFourBitIndexableFormat())) || (_fmt == 2)) {
			_fixedFields = 0;
			goto l13;
		}
		if (_fmt < 2) {
			_fixedFields = _totalLength;
			goto l13;
		}
		_class = fetchClassOfNonImm(_aContext);
		/* begin fixedFieldsOfClassFormat: */
		_classFormat = (unsignedLongAt((_class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
		_fixedFields = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
		/* end fixedFieldsOfClassFormat: */
		l13:
		;
		/* end fixedFieldsOf:format:length: */
		/* begin fetchStackPointerOf: */
		/* begin fetchPointer:ofObject: */
		_sp3 = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (!(((_sp3 & 7) == 1))) {
			_stSize = 0;
			goto l15;
		}
		assert((ReceiverIndex + (_sp3 >> 3)) < (lengthOf(_aContext)));
		_stSize = _sp3 >> 3;
		l15:
		;
		/* end fetchStackPointerOf: */
		if (!((_index >= 1) && (_index <= _stSize))) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadIndex;
			/* end primitiveFailFor: */
			return;
		}
		/* begin subscript:with:storing:format: */
		if (_fmt <= 5) {
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(_aContext)));
			if (((_aContext & (tagMask())) == 0) && ((_aContext & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((_value & (tagMask())) == 0) && (((_value & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_value >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(_aContext)) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), _aContext);
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(_aContext)) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l21;
			}
			if (_value & (tagMask())) {
				goto l21;
			}
			if (!(_aContext >= 0x20000000000LL)) {
				goto l21;
			}
			if (_value >= 0x20000000000LL) {
				goto l21;
			}
			if ((_value >= GIV(nilObj)) && (_value <= GIV(trueObj))) {
				goto l21;
			}
			if (!(_value >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l21;
			}
			remember(getFromPermToNewSpaceRememberedSet(), _aContext);
			l21:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << (shiftForWord())) ), _value);
			/* end storePointer:ofObject:withValue: */
			goto l22;
		}
		if (_fmt >= (firstByteFormat())) {
			if (!(((_value & 7) == 1))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l22;
			}
			_signedValueToStore = _value >> 3;
			if (!((_signedValueToStore >= 0) && (_signedValueToStore <= 0xFF))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l22;
			}
			/* begin storeByte:ofObject:withValue: */
			byteAtput((_aContext + BaseHeaderSize) + ((_index + _fixedFields) - 1), _signedValueToStore);
			/* end storeByte:ofObject:withValue: */
			goto l22;
		}
		if (_fmt >= (firstShortFormat())) {
			if (!(((_value & 7) == 1))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l22;
			}
			_signedValueToStore = _value >> 3;
			if (!((_signedValueToStore >= 0) && (_signedValueToStore <= 0xFFFF))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l22;
			}
			/* begin storeShort16:ofObject:withValue: */
			shortAtput((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 1) ), _signedValueToStore);
			/* end storeShort16:ofObject:withValue: */
			goto l22;
		}
		if (_fmt == (sixtyFourBitIndexableFormat())) {
			_unsigned64BitValueToStore = positive64BitValueOf(_value);
			if (!GIV(primFailCode)) {
				/* begin storeLong64:ofObject:withValue: */
				long64Atput((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 3) ), _unsigned64BitValueToStore);
				/* end storeLong64:ofObject:withValue: */
			}
			goto l22;
		}
		_unsignedValueToStore = positive32BitValueOf(_value);
		if (!GIV(primFailCode)) {
			/* begin storeLong32:ofObject:withValue: */
			uint32AtPointerput((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((_index + _fixedFields) - 1) ) << 2) ), _unsignedValueToStore);
			/* end storeLong32:ofObject:withValue: */
		}
		l22:
		;
		/* end subscript:with:storing:format: */
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _value);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
		return;
	}
	/* begin frameOfMarriedContext: */
	/* begin fetchPointer:ofObject: */
	_senderOop = unsignedLongAt((_aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	{
		assert(((_senderOop & 7) == 1));
		_spouseFP = pointerForOop(_senderOop - 1);
	}
	/* end frameOfMarriedContext: */
	if (!((_index >= 1) && (_index <= (stackPointerIndexForFrame(_spouseFP))))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		/* end primitiveFailFor: */
		return;
	}
	if (isMachineCodeIP(((usqInt) (unsignedLongAt(_spouseFP + FoxMethod)) ))) {
		unsignedLongAtput((((_index - 1) < ((_frameNumArgs = ((((CogMethod *) ((unsignedLongAt(_spouseFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs))))
			 ? (_spouseFP + FoxCallerSavedIP) + ((_frameNumArgs - (_index - 1)) * BytesPerWord)
			 : ((_spouseFP + FoxMFReceiver) - BytesPerWord) + ((_frameNumArgs - (_index - 1)) * BytesPerWord)), _value);
	} else {
		{
			if ((_index - 1) < ((_frameNumArgs2 = byteAt((_spouseFP + FoxIFrameFlags) + 1)))) {
				unsignedLongAtput((_spouseFP + FoxCallerSavedIP) + ((_frameNumArgs2 - (_index - 1)) * BytesPerWord), _value);
			}
 else {
				unsignedLongAtput(((_spouseFP + FoxIFReceiver) - BytesPerWord) + ((_frameNumArgs2 - (_index - 1)) * BytesPerWord), _value);
			}
		}
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp2 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _value);
	GIV(stackPointer) = _sp2;
	/* end pop:thenPush: */
}
/*	Special version of primitiveSize for accessing contexts. 
	Written to be varargs for use from mirror primitives. */
/* StackInterpreterPrimitives>>#primitiveContextSize */
static void
primitiveContextSize(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _class;
	sqInt _classFormat;
	sqInt _fixedFields;
	usqLong _fmt;
	sqLong _hdr;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _rcvr;
	char *_sp;
	sqInt _sp2;
	sqInt _sp3;
	sqInt _sz;
	char *_theSP;
	sqInt _totalLength;

	/* begin stackTop */
	_rcvr = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin baseHeader: */
	_hdr = long64At(_rcvr);
	/* end baseHeader: */
	_fmt = (((unsigned sqLong) _hdr ) >> (formatShift())) & (formatMask());
	/* begin lengthOf:format: */
	/* begin numSlotsOfAny: */
	_numSlots2 = byteAt(_rcvr + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOfAny: */
	if (_fmt <= 5) {
		_totalLength = _numSlots;
		goto l5;
	}
	if (_fmt >= (firstByteFormat())) {
		_totalLength = (_numSlots << (shiftForWord())) - (_fmt & 7);
		goto l5;
	}
	if (_fmt >= (firstShortFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
		goto l5;
	}
	if (_fmt >= (firstLongFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
		goto l5;
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		_totalLength = _numSlots;
		goto l5;
	}
	_totalLength = 0;
	l5:
	;
	/* end lengthOf:format: */
	/* begin fixedFieldsOf:format:length: */
	if ((_fmt >= (sixtyFourBitIndexableFormat())) || (_fmt == 2)) {
		_fixedFields = 0;
		goto l6;
	}
	if (_fmt < 2) {
		_fixedFields = _totalLength;
		goto l6;
	}
	_class = fetchClassOfNonImm(_rcvr);
	/* begin fixedFieldsOfClassFormat: */
	_classFormat = (unsignedLongAt((_class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	_fixedFields = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	/* end fixedFieldsOfClassFormat: */
	l6:
	;
	/* end fixedFieldsOf:format:length: */
	if ((_hdr & (classIndexMask())) == ClassMethodContextCompactIndex) {
		/* begin writeBackHeadFramePointers */
		assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
		assert(GIV(stackPage) == (mostRecentlyUsedPage()));
		assert(!(isFree(GIV(stackPage))));
		/* begin setHeadFP:andSP:inPage: */
		_theSP = GIV(stackPointer);
		assert(_theSP < GIV(framePointer));
		assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
		assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
		{
			(GIV(stackPage)->headFP = GIV(framePointer));
			(GIV(stackPage)->headSP = _theSP);
		}
		/* end setHeadFP:andSP:inPage: */
		assert(pageListIsWellFormed());
		/* end writeBackHeadFramePointers */
		/* begin stackPointerForMaybeMarriedContext: */
		if (((((unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_rcvr)))) {
			_sp3 = stackPointerIndexForFrame(frameOfMarriedContext(_rcvr));
			assert((ReceiverIndex + (_sp3 >> 3)) < (lengthOf(_rcvr)));
			_sz = _sp3;
			goto l8;
		}
		/* begin fetchStackPointerOf: */
		/* begin fetchPointer:ofObject: */
		_sp2 = unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (!(((_sp2 & 7) == 1))) {
			_sz = 0;
			goto l8;
		}
		assert((ReceiverIndex + (_sp2 >> 3)) < (lengthOf(_rcvr)));
		_sz = _sp2 >> 3;
		/* end fetchStackPointerOf: */
		l8:
		;
		/* end stackPointerForMaybeMarriedContext: */
	} else {
		_sz = _totalLength - _fixedFields;
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _sz ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Simulate an primitiveExternalCall invocation (e.g. for the Debugger). Do 
	not cache anything. 
	e.g. ContextPart>>tryNamedPrimitiveIn: aCompiledMethod for: aReceiver 
	withArgs: arguments */
/* StackInterpreterPrimitives>>#primitiveDoNamedPrimitiveWithArgs */
static void
primitiveDoNamedPrimitiveWithArgs(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	void (*_addr)();
	sqInt _argumentArray;
	usqInt _arraySize;
	sqInt _ccIndex;
	sqInt _classOop;
	sqInt _firstBytecode;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _functionLength;
	sqInt _functionName;
	sqInt _header;
	sqInt _index;
	sqInt _isArray;
	sqInt _methodArg;
	sqInt _methodHeader;
	sqInt _moduleLength;
	sqInt _moduleName;
	sqInt _nItems;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots22;
	usqInt _numSlots3;
	usqInt _numSlots4;
	sqInt _object;
	sqInt _object2;
	sqInt _object3;
	sqInt _object4;
	sqInt _object5;
	sqInt _primRcvr;
	char *_sp;
	char *_sp2;
	char *_sp3;
	char *_sp4;
	char *_sp5;
	char *_sp6;
	sqInt _spec;
	sqInt _successBoolean;
	sqInt _successBoolean2;
	sqInt _top;
	sqInt _top2;
	sqInt _val;
	sqInt _valuePointer;
	sqInt _valuePointer2;
	sqInt _valuePointer3;
	sqInt _valuePointer4;

	_val = 0;
	GIV(metaAccessorDepth) = -2;
	/* begin stackTop */
	_argumentArray = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_methodArg = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (!((((_argumentArray & (tagMask())) == 0) && (((((usqInt) (longAt(_argumentArray)) ) >> (formatShift())) & (formatMask())) == 2)) && (((_methodArg & (tagMask())) == 0) && (((((usqInt) (longAt(_methodArg)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()))))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = -2;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numSlotsOf: */
	assert((classIndexOf(_argumentArray)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_argumentArray + 7);
	_arraySize = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_argumentArray - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	if (!(_arraySize <= (LargeContextSlots - CtxtTempFrameStart))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = -2;
		return;
		/* end primitiveFailFor: */
	}
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_methodArg));
	/* begin fetchPointer:ofObject: */
	_header = unsignedLongAt((_methodArg + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header & 7) == 1)) {
		_methodHeader = _header;
	} else {
		assert(((usqInt) _header ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_methodHeader = ((((CogMethod *) _header ))->methodHeader);
	}
	/* end methodHeaderOf: */
	if (!(((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) > 2)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = -3;
		return;
		/* end primitiveFailFor: */
	}
	/* begin fetchPointer:ofObject: */
	_spec = unsignedLongAt((_methodArg + BaseHeaderSize) + (1U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	/* begin is:instanceOf:compactClassIndex: */
	_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ));
	if (_spec & (tagMask())) {
		_isArray = 0;
		goto l18;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	assert(!(isImmediate(_spec)));
	/* begin classIndexOf: */
	_ccIndex = (longAt(_spec)) & (classIndexMask());
	/* end classIndexOf: */
	{
		_isArray = ClassArrayCompactIndex == _ccIndex;
		goto l18;
	}
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	l18:
	;
	/* end is:instanceOf:compactClassIndex: */
	if (!(_isArray && (((numSlotsOf(_spec)) == 4) && ((((_methodHeader & AlternateHeaderHasPrimFlag)
		 ? ((_firstBytecode = (_methodArg + ((LiteralStart + ((_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) * BytesPerOop)) + BaseHeaderSize), (byteAt(_firstBytecode + 1)) + ((sqInt) (((usqInt) (byteAt(_firstBytecode + 2)) ) << 8) ))
		 : 0)) == PrimNumberExternalCall)))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = -3;
		return;
		/* end primitiveFailFor: */
	}
	if (!(((((usqInt) _methodHeader ) >> MethodHeaderArgCountShift) & 15) == _arraySize)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = -2;
		return;
		/* end primitiveFailFor: */
	}
	/* begin fetchPointer:ofObject: */
	_moduleName = unsignedLongAt((_spec + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	if (_moduleName == GIV(nilObj)) {
		_moduleLength = 0;
	} else {
		/* begin success: */
		_successBoolean = ((_moduleName & (tagMask())) == 0) && (((((usqInt) (longAt(_moduleName)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat()));
		if (!_successBoolean) {
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
		}
		/* end success: */
		/* begin lengthOf:format: */
		_fmt = (((usqInt) (longAt(_moduleName)) ) >> (formatShift())) & (formatMask());
		/* begin numSlotsOfAny: */
		_numSlots2 = byteAt(_moduleName + 7);
		_numSlots3 = ((_numSlots2 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_moduleName - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots2);
		/* end numSlotsOfAny: */
		if (_fmt <= 5) {
			_moduleLength = _numSlots3;
			goto l14;
		}
		if (_fmt >= (firstByteFormat())) {
			_moduleLength = (_numSlots3 << (shiftForWord())) - (_fmt & 7);
			goto l14;
		}
		if (_fmt >= (firstShortFormat())) {
			_moduleLength = (_numSlots3 << ((shiftForWord()) - 1)) - (_fmt & 3);
			goto l14;
		}
		if (_fmt >= (firstLongFormat())) {
			_moduleLength = (_numSlots3 << ((shiftForWord()) - 2)) - (_fmt & 1);
			goto l14;
		}
		if (_fmt == (sixtyFourBitIndexableFormat())) {
			_moduleLength = _numSlots3;
			goto l14;
		}
		_moduleLength = 0;
		l14:
		;
		/* end lengthOf:format: */
	}
	/* begin fetchPointer:ofObject: */
	_functionName = unsignedLongAt((_spec + BaseHeaderSize) + (1U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	/* begin success: */
	_successBoolean2 = ((_functionName & (tagMask())) == 0) && (((((usqInt) (longAt(_functionName)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat()));
	if (!_successBoolean2) {
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
	}
	/* end success: */
	/* begin lengthOf:format: */
	_fmt2 = (((usqInt) (longAt(_functionName)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOfAny: */
	_numSlots22 = byteAt(_functionName + 7);
	_numSlots4 = ((_numSlots22 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_functionName - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots22);
	/* end numSlotsOfAny: */
	if (_fmt2 <= 5) {
		_functionLength = _numSlots4;
		goto l20;
	}
	if (_fmt2 >= (firstByteFormat())) {
		_functionLength = (_numSlots4 << (shiftForWord())) - (_fmt2 & 7);
		goto l20;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_functionLength = (_numSlots4 << ((shiftForWord()) - 1)) - (_fmt2 & 3);
		goto l20;
	}
	if (_fmt2 >= (firstLongFormat())) {
		_functionLength = (_numSlots4 << ((shiftForWord()) - 2)) - (_fmt2 & 1);
		goto l20;
	}
	if (_fmt2 == (sixtyFourBitIndexableFormat())) {
		_functionLength = _numSlots4;
		goto l20;
	}
	_functionLength = 0;
	l20:
	;
	/* end lengthOf:format: */
	if (GIV(primFailCode)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = -3;
		return;
		/* end primitiveFailFor: */
	}
	_addr = ioLoadExternalFunctionOfLengthFromModuleOfLengthAccessorDepthInto(_functionName + BaseHeaderSize, _functionLength, _moduleName + BaseHeaderSize, _moduleLength, &GIV(metaAccessorDepth));
	if (_addr == 0) {
		GIV(metaAccessorDepth) = -2;
	}
	if (_addr == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = -1;
		return;
		/* end primitiveFailFor: */
	}
	/* begin eeInstantiateClassIndex:format:numSlots: */
	assert((knownClassAtIndex(ClassArrayCompactIndex)) != GIV(nilObj));
	assert(2 == (instSpecOfClass(knownClassAtIndex(ClassArrayCompactIndex))));
	GIV(tempOop) = allocateNewSpaceSlotsformatclassIndex(4, 2, ClassArrayCompactIndex);
	/* end eeInstantiateClassIndex:format:numSlots: */
	{
		/* begin storePointerUnchecked:ofObject:withValue: */
		_valuePointer = (_argumentArray = popStack());
		assert(!(isOopForwarded(GIV(tempOop))));
		longAtput((GIV(tempOop) + BaseHeaderSize) + (0U << (shiftForWord())), _valuePointer);
		/* end storePointerUnchecked:ofObject:withValue: */
		/* begin storePointerUnchecked:ofObject:withValue: */
		_valuePointer2 = (_primRcvr = popStack());
		assert(!(isOopForwarded(GIV(tempOop))));
		longAtput((GIV(tempOop) + BaseHeaderSize) + (1U << (shiftForWord())), _valuePointer2);
		/* end storePointerUnchecked:ofObject:withValue: */
		/* begin storePointerUnchecked:ofObject:withValue: */
		/* begin popStack */
		_top = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		_valuePointer3 = _top;
		/* end popStack */
		assert(!(isOopForwarded(GIV(tempOop))));
		longAtput((GIV(tempOop) + BaseHeaderSize) + (2U << (shiftForWord())), _valuePointer3);
		/* end storePointerUnchecked:ofObject:withValue: */
		/* begin storePointerUnchecked:ofObject:withValue: */
		/* begin popStack */
		_top2 = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		_valuePointer4 = _top2;
		/* end popStack */
		assert(!(isOopForwarded(GIV(tempOop))));
		longAtput((GIV(tempOop) + BaseHeaderSize) + (3U << (shiftForWord())), _valuePointer4);
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	/* begin push: */
	unsignedLongAtput((_sp6 = GIV(stackPointer) - BytesPerWord), _primRcvr);
	GIV(stackPointer) = _sp6;
	/* end push: */
	GIV(argumentCount) = _arraySize;
	for (_index = 1; _index <= _arraySize; _index += 1) {
		/* begin push: */
		_object = unsignedLongAt((_argumentArray + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << (shiftForWord())) ));
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
		GIV(stackPointer) = _sp;
		/* end push: */
	}
	/* begin callExternalPrimitive: */
	primitiveFunctionPointer = _addr;
	/* begin dispatchFunctionPointer: */
	_addr();
	/* end dispatchFunctionPointer: */
	/* begin maybeFailForLastObjectOverwrite */
	if (checkAllocFiller) {
		if (((freeStart0()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart0())) != (freeStart0()))) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrWritePastObject;
			/* end primitiveFailFor: */
		}
	}
	/* end maybeFailForLastObjectOverwrite */
	/* end callExternalPrimitive: */
	if (GIV(primFailCode)) {
		/* begin pop: */
		_nItems = _arraySize + 1;
		GIV(stackPointer) += _nItems * BytesPerWord;
		/* end pop: */
		/* begin push: */
		_object2 = unsignedLongAt((GIV(tempOop) + BaseHeaderSize) + (3U << (shiftForWord())));
		unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _object2);
		GIV(stackPointer) = _sp2;
		/* end push: */
		/* begin push: */
		_object3 = unsignedLongAt((GIV(tempOop) + BaseHeaderSize) + (2U << (shiftForWord())));
		unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), _object3);
		GIV(stackPointer) = _sp3;
		/* end push: */
		/* begin push: */
		_object4 = unsignedLongAt((GIV(tempOop) + BaseHeaderSize) + (1U << (shiftForWord())));
		unsignedLongAtput((_sp4 = GIV(stackPointer) - BytesPerWord), _object4);
		GIV(stackPointer) = _sp4;
		/* end push: */
		/* begin push: */
		_object5 = unsignedLongAt((GIV(tempOop) + BaseHeaderSize) + (0U << (shiftForWord())));
		unsignedLongAtput((_sp5 = GIV(stackPointer) - BytesPerWord), _object5);
		GIV(stackPointer) = _sp5;
		/* end push: */
		GIV(argumentCount) = 3;
		primitiveFunctionPointer = primitiveDoNamedPrimitiveWithArgs;
		if (GIV(primFailCode) == 1) {
			GIV(primFailCode) = -1;
		}
	}
}
/*	Implement either ProtoObject>>tryPrimitive: primIndex withArgs: argArray 
	or Context>>receiver: anObject tryPrimitive: primIndex withArgs: argArray. 
	If this primitive fails, arrange that its error code is a negative 
	integer, to 
	distinguish between this failing and the primitive it invokes failing.See checkForAndFollowForwardedPrimitiveState */
/* StackInterpreterPrimitives>>#primitiveDoPrimitiveWithArgs */
static void
primitiveDoPrimitiveWithArgs(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _argumentArray;
	usqInt _arraySize;
	int _index;
	sqInt _nArgs;
	usqInt _numSlots;
	sqInt _object;
	sqInt _primIdx;
	sqInt _rcvr;
	sqInt _referent;
	char *_savedFramePointer;
	sqInt _savedNumArgs;
	char *_savedStackPointer;
	sqInt _savedTempOop;
	sqInt _savedTempOop2;
	char *_sp;
	char *_sp2;
	char *_sp3;
	char *_sp4;
	char *_sp5;

	_nArgs = 0;
	_savedFramePointer = ((char *) 0 );
	_savedStackPointer = ((char *) 0 );
	_savedTempOop2 = 0;
	GIV(metaAccessorDepth) = -2;
	if (!((GIV(argumentCount) >= 2) && (GIV(argumentCount) <= 3))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = -PrimErrUnsupported;
		return;
		/* end primitiveFailFor: */
	}
	/* begin stackTop */
	_argumentArray = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_primIdx = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (!((((_argumentArray & (tagMask())) == 0) && (((((usqInt) (longAt(_argumentArray)) ) >> (formatShift())) & (formatMask())) == 2)) && (((_primIdx & 7) == 1)))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = -PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numSlotsOf: */
	assert((classIndexOf(_argumentArray)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_argumentArray + 7);
	_arraySize = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_argumentArray - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	if (!(_arraySize <= (LargeContextSlots - CtxtTempFrameStart))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = -PrimErrLimitExceeded;
		return;
		/* end primitiveFailFor: */
	}
	_primIdx = _primIdx >> 3;
	/* begin functionPointerFor: */
	primitiveFunctionPointer = ((void (*)(void)) (((_primIdx > MaxPrimitiveIndex)
		 ? 0
		 : primitiveTable[_primIdx])) );
	/* end functionPointerFor: */
	if (primitiveFunctionPointer == 0) {
		primitiveFunctionPointer = primitiveDoPrimitiveWithArgs;
		/* begin primitiveFailFor: */
		GIV(primFailCode) = -PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	if (((_savedNumArgs = GIV(argumentCount))) == 3) {
		_savedTempOop2 = GIV(tempOop2);
		/* begin stackValue: */
		GIV(tempOop2) = unsignedLongAt(GIV(stackPointer) + (3 * BytesPerWord));
		/* end stackValue: */
		/* begin stackValue: */
		_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
		/* end stackValue: */
		if (((_rcvr & (tagMask())) == 0) && (((long64At(_rcvr)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			/* begin followForwarded: */
			assert(isUnambiguouslyForwarder(_rcvr));
			/* begin fetchPointer:ofMaybeForwardedObject: */
			_referent = unsignedLongAt((_rcvr + BaseHeaderSize) + (0U << (shiftForWord())));
			/* end fetchPointer:ofMaybeForwardedObject: */
			while (((_referent & (tagMask())) == 0) && (((long64At(_referent)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				/* begin fetchPointer:ofMaybeForwardedObject: */
				_referent = unsignedLongAt((_referent + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofMaybeForwardedObject: */
			}
			_rcvr = _referent;
			/* end followForwarded: */
		}
		{
			/* begin pop: */
			GIV(stackPointer) += 4 * BytesPerWord;
			/* end pop: */
			/* begin push: */
			unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _rcvr);
			GIV(stackPointer) = _sp;
			/* end push: */
		}
	} else {
		/* begin pop: */
		GIV(stackPointer) += 2 * BytesPerWord;
		/* end pop: */
	}
	GIV(argumentCount) = _arraySize;
	_index = 1;
	while (_index <= _arraySize) {
		/* begin push: */
		_object = unsignedLongAt((_argumentArray + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << (shiftForWord())) ));
		unsignedLongAtput((_sp2 = GIV(stackPointer) - BytesPerWord), _object);
		GIV(stackPointer) = _sp2;
		/* end push: */
		_index += 1;
	}
	if (((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex) {
		executeQuickPrimitive();
		GIV(tempOop2) = _savedTempOop2;
		return;
	}
	_savedTempOop = GIV(tempOop);
	GIV(tempOop) = _argumentArray;
	GIV(metaAccessorDepth) = primitiveAccessorDepthTable[_primIdx];
	/* begin slowPrimitiveResponse */
	if (recordPrimTrace()) {
		/* begin fastLogPrim: */
		GIV(primTraceLog)[GIV(primTraceLogIndex)] = GIV(messageSelector);
		primTraceLogIndex(GIV(primTraceLogIndex) + 1);
		/* end fastLogPrim: */
	}
	assert((remapBufferCount()) == 0);
	{
		_nArgs = GIV(argumentCount);
		_savedStackPointer = GIV(stackPointer);
		_savedFramePointer = GIV(framePointer);
	}
	/* begin initPrimCall */
	GIV(primFailCode) = 0;
	/* end initPrimCall */
	/* begin dispatchFunctionPointer: */
	primitiveFunctionPointer();
	/* end dispatchFunctionPointer: */
	assert(maybeLeakCheckExternalPrimCall(GIV(newMethod)));
	/* begin maybeRetryPrimitiveOnFailure */
	if (GIV(primFailCode)) {
		retryPrimitiveOnFailure();
	}
	/* end maybeRetryPrimitiveOnFailure */
	/* begin maybeFailForLastObjectOverwrite */
	if (checkAllocFiller) {
		if (((freeStart0()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart0())) != (freeStart0()))) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrWritePastObject;
			/* end primitiveFailFor: */
		}
	}
	/* end maybeFailForLastObjectOverwrite */
	if (!GIV(primFailCode) && ((GIV(framePointer) == _savedFramePointer) && (!(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))))) {
		if (GIV(stackPointer) != (_savedStackPointer + (_nArgs * BytesPerWord))) {
			flag("Would be nice to make this a message send of e.g. unbalancedPrimitive to the current process or context");
			failUnbalancedPrimitive();
			GIV(stackPointer) = _savedStackPointer;
		}
	}
	if (GIV(nextProfileTick) > 0) {
		checkProfileTick(GIV(newMethod));
	}
	goto l18;
	l18:
	;
	/* end slowPrimitiveResponse */
	if (GIV(primFailCode)) {
		/* begin pop: */
		GIV(stackPointer) += _arraySize * BytesPerWord;
		/* end pop: */
		if (_savedNumArgs == 3) {
			/* begin stackTop */
			_rcvr = unsignedLongAt(GIV(stackPointer));
			/* end stackTop */
			/* begin stackTopPut: */
			unsignedLongAtput(GIV(stackPointer), GIV(tempOop2));
			/* end stackTopPut: */
			GIV(tempOop2) = _savedTempOop2;
			/* begin push: */
			unsignedLongAtput((_sp3 = GIV(stackPointer) - BytesPerWord), _rcvr);
			GIV(stackPointer) = _sp3;
			/* end push: */
		}
		/* begin pushInteger: */
		/* begin push: */
		unsignedLongAtput((_sp5 = GIV(stackPointer) - BytesPerWord), ((((usqInt) _primIdx ) << 3) | 1));
		GIV(stackPointer) = _sp5;
		/* end push: */
		/* end pushInteger: */
		/* begin push: */
		unsignedLongAtput((_sp4 = GIV(stackPointer) - BytesPerWord), GIV(tempOop));
		GIV(stackPointer) = _sp4;
		/* end push: */
		primitiveFunctionPointer = primitiveDoPrimitiveWithArgs;
		GIV(argumentCount) = _savedNumArgs;
		GIV(tempOop) = _savedTempOop;
	}
}
/*	receiver, args, then method are on top of stack. Execute method against 
	receiver and args. 
	Set primitiveFunctionPointer because no cache lookup has been done for the 
	method, and 
	hence primitiveFunctionPointer is stale. */
/* StackInterpreterPrimitives>>#primitiveExecuteMethod */
static void
primitiveExecuteMethod(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _firstBytecode;
	sqInt _header;
	sqInt _inInterpreter;
	sqInt _methodArgument;
	sqInt _methodHeader;
	sqInt _methodHeader2;
	sqInt _nArgs;
	sqInt _primitiveIndex;
	char *_savedFramePointer;
	char *_savedStackPointer;
	sqInt _succeeded;
	sqInt _top;

	/* begin stackTop */
	_methodArgument = unsignedLongAt(GIV(stackPointer));
	_nArgs = 0;
	_savedFramePointer = ((char *) 0 );
	_savedStackPointer = ((char *) 0 );
	/* end stackTop */
	if (!(((_methodArgument & (tagMask())) == 0) && (((((usqInt) (longAt(_methodArgument)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	if (!((GIV(argumentCount) - 1) == (argumentCountOf(_methodArgument)))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadNumArgs;
		return;
		/* end primitiveFailFor: */
	}
	/* begin popStack */
	_top = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	GIV(newMethod) = _top;
	/* end popStack */
	/* begin primitiveIndexOfMethod:header: */
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(GIV(newMethod)));
	/* begin fetchPointer:ofObject: */
	_header = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header & 7) == 1)) {
		_methodHeader = _header;
	} else {
		assert(((usqInt) _header ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_methodHeader = ((((CogMethod *) _header ))->methodHeader);
	}
	/* end methodHeaderOf: */
	if (_methodHeader & AlternateHeaderHasPrimFlag) {
		_firstBytecode = (GIV(newMethod) + ((LiteralStart + ((_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) * BytesPerOop)) + BaseHeaderSize;
		_primitiveIndex = (byteAt(_firstBytecode + 1)) + ((sqInt) (((usqInt) (byteAt(_firstBytecode + 2)) ) << 8) );
	} else {
		_primitiveIndex = 0;
	}
	/* end primitiveIndexOfMethod:header: */
	/* begin functionPointerFor: */
	primitiveFunctionPointer = ((void (*)(void)) (((_primitiveIndex > MaxPrimitiveIndex)
		 ? 0
		 : primitiveTable[_primitiveIndex])) );
	/* end functionPointerFor: */
	GIV(argumentCount) -= 1;
	/* begin executeNewMethod */
	/* begin executeNewMethod: */
	_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	/* begin executePrimitiveFromInterpreter:ifFail: */
	if (primitiveFunctionPointer != 0) {
		if (((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex) {
			executeQuickPrimitive();
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), _inInterpreter);
			/* end returnToExecutive: */
			goto l12;
		}
		/* begin slowPrimitiveResponse */
		if (recordPrimTrace()) {
			/* begin fastLogPrim: */
			GIV(primTraceLog)[GIV(primTraceLogIndex)] = GIV(messageSelector);
			primTraceLogIndex(GIV(primTraceLogIndex) + 1);
			/* end fastLogPrim: */
		}
		assert((remapBufferCount()) == 0);
		{
			_nArgs = GIV(argumentCount);
			_savedStackPointer = GIV(stackPointer);
			_savedFramePointer = GIV(framePointer);
		}
		/* begin initPrimCall */
		GIV(primFailCode) = 0;
		/* end initPrimCall */
		/* begin dispatchFunctionPointer: */
		primitiveFunctionPointer();
		/* end dispatchFunctionPointer: */
		assert(maybeLeakCheckExternalPrimCall(GIV(newMethod)));
		/* begin maybeRetryPrimitiveOnFailure */
		if (GIV(primFailCode)) {
			retryPrimitiveOnFailure();
		}
		/* end maybeRetryPrimitiveOnFailure */
		/* begin maybeFailForLastObjectOverwrite */
		if (checkAllocFiller) {
			if (((freeStart0()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart0())) != (freeStart0()))) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrWritePastObject;
				/* end primitiveFailFor: */
			}
		}
		/* end maybeFailForLastObjectOverwrite */
		if (!GIV(primFailCode) && ((GIV(framePointer) == _savedFramePointer) && (!(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))))) {
			if (GIV(stackPointer) != (_savedStackPointer + (_nArgs * BytesPerWord))) {
				flag("Would be nice to make this a message send of e.g. unbalancedPrimitive to the current process or context");
				failUnbalancedPrimitive();
				GIV(stackPointer) = _savedStackPointer;
			}
		}
		if (GIV(nextProfileTick) > 0) {
			checkProfileTick(GIV(newMethod));
		}
		_succeeded = !GIV(primFailCode);
		goto l8;
		l8:
		;
		/* end slowPrimitiveResponse */
		if (_succeeded) {
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), _inInterpreter);
			/* end returnToExecutive: */
			goto l12;
		}
	}
	{
		{
			/* begin fetchPointer:ofObject: */
			_methodHeader2 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (!((assert((((_methodHeader2 & 7) == 1)) || ((((usqInt) _methodHeader2 ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader2 ) >= (minCogMethodAddress())))), (_methodHeader2 & (smallIntegerTag())) == 0))) {
				if (((assert(((_methodHeader2 & 7) == 1)), (_methodHeader2 >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
					cogselector(GIV(newMethod), GIV(nilObj));
					/* begin fetchPointer:ofObject: */
					_methodHeader2 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
				} else {
					maybeFlagMethodAsInterpreted(GIV(newMethod));
				}
			}
		}
		activateNewMethod();
	}
	l12:
	;
	/* end executePrimitiveFromInterpreter:ifFail: */
	/* end executeNewMethod: */
	/* end executeNewMethod */
	/* begin initPrimCall */
	GIV(primFailCode) = 0;
	/* end initPrimCall */
}
/*	receiver, argsArray, then method are on top of stack. Execute method 
	against receiver and args. Allow for up to two extra arguments (e.g. for 
	mirror primitives). 
	Set primitiveFunctionPointer because no cache lookup has been done for the 
	method, and hence primitiveFunctionPointer is stale. */
/* StackInterpreterPrimitives>>#primitiveExecuteMethodArgsArray */
static void
primitiveExecuteMethodArgsArray(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _argCnt;
	sqInt _argumentArray;
	sqInt _firstBytecode;
	sqInt _header;
	sqInt _header2;
	sqInt _header3;
	sqInt _i;
	sqInt _inInterpreter;
	sqInt _methodArgument;
	sqInt _methodHeader;
	sqInt _methodHeader2;
	sqInt _nArgs;
	sqInt _object;
	sqInt _primitiveIndex;
	sqInt _rcvr;
	char *_savedFramePointer;
	char *_savedStackPointer;
	char *_sp;
	sqInt _succeeded;

	/* begin stackTop */
	_methodArgument = unsignedLongAt(GIV(stackPointer));
	_nArgs = 0;
	_savedFramePointer = ((char *) 0 );
	_savedStackPointer = ((char *) 0 );
	/* end stackTop */
	/* begin stackValue: */
	_argumentArray = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (!((((_methodArgument & (tagMask())) == 0) && (((((usqInt) (longAt(_methodArgument)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()))) && (((_argumentArray & (tagMask())) == 0) && (((((usqInt) (longAt(_argumentArray)) ) >> (formatShift())) & (formatMask())) == 2)))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin argumentCountOf: */
	/* begin argumentCountOfMethodHeader: */
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(_methodArgument));
	/* begin fetchPointer:ofObject: */
	_header2 = unsignedLongAt((_methodArgument + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header2 & 7) == 1)) {
		_header = _header2;
	} else {
		assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_header = ((((CogMethod *) _header2 ))->methodHeader);
	}
	/* end methodHeaderOf: */
	_argCnt = (((usqInt) _header ) >> MethodHeaderArgCountShift) & 15;
	/* end argumentCountOfMethodHeader: */
	/* end argumentCountOf: */
	if (!(_argCnt == (numSlotsOf(_argumentArray)))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadNumArgs;
		return;
		/* end primitiveFailFor: */
	}
	if (GIV(argumentCount) > 2) {
		/* begin stackValue: */
		_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
		/* end stackValue: */
		if ((GIV(argumentCount) > 4) || (((_rcvr & (tagMask())) == 0) && (((long64At(_rcvr)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrUnsupported;
			return;
			/* end primitiveFailFor: */
		}
		/* begin stackValue:put: */
		unsignedLongAtput(GIV(stackPointer) + (GIV(argumentCount) * BytesPerWord), _rcvr);
		/* end stackValue:put: */
	}
	/* begin pop: */
	GIV(stackPointer) += GIV(argumentCount) * BytesPerWord;
	/* end pop: */
	for (_i = 0; _i < _argCnt; _i += 1) {
		/* begin push: */
		_object = unsignedLongAt((_argumentArray + BaseHeaderSize) + ((sqInt) (((usqInt) _i ) << (shiftForWord())) ));
		unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), _object);
		GIV(stackPointer) = _sp;
		/* end push: */
	}
	GIV(newMethod) = _methodArgument;
	/* begin primitiveIndexOfMethod:header: */
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(GIV(newMethod)));
	/* begin fetchPointer:ofObject: */
	_header3 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((_header3 & 7) == 1)) {
		_methodHeader = _header3;
	} else {
		assert(((usqInt) _header3 ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) _header3 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		_methodHeader = ((((CogMethod *) _header3 ))->methodHeader);
	}
	/* end methodHeaderOf: */
	if (_methodHeader & AlternateHeaderHasPrimFlag) {
		_firstBytecode = (GIV(newMethod) + ((LiteralStart + ((_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) * BytesPerOop)) + BaseHeaderSize;
		_primitiveIndex = (byteAt(_firstBytecode + 1)) + ((sqInt) (((usqInt) (byteAt(_firstBytecode + 2)) ) << 8) );
	} else {
		_primitiveIndex = 0;
	}
	/* end primitiveIndexOfMethod:header: */
	/* begin functionPointerFor: */
	primitiveFunctionPointer = ((void (*)(void)) (((_primitiveIndex > MaxPrimitiveIndex)
		 ? 0
		 : primitiveTable[_primitiveIndex])) );
	/* end functionPointerFor: */
	GIV(argumentCount) = _argCnt;
	/* begin executeNewMethod */
	/* begin executeNewMethod: */
	_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	/* begin executePrimitiveFromInterpreter:ifFail: */
	if (primitiveFunctionPointer != 0) {
		if (((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex) {
			executeQuickPrimitive();
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), _inInterpreter);
			/* end returnToExecutive: */
			goto l18;
		}
		/* begin slowPrimitiveResponse */
		if (recordPrimTrace()) {
			/* begin fastLogPrim: */
			GIV(primTraceLog)[GIV(primTraceLogIndex)] = GIV(messageSelector);
			primTraceLogIndex(GIV(primTraceLogIndex) + 1);
			/* end fastLogPrim: */
		}
		assert((remapBufferCount()) == 0);
		{
			_nArgs = GIV(argumentCount);
			_savedStackPointer = GIV(stackPointer);
			_savedFramePointer = GIV(framePointer);
		}
		/* begin initPrimCall */
		GIV(primFailCode) = 0;
		/* end initPrimCall */
		/* begin dispatchFunctionPointer: */
		primitiveFunctionPointer();
		/* end dispatchFunctionPointer: */
		assert(maybeLeakCheckExternalPrimCall(GIV(newMethod)));
		/* begin maybeRetryPrimitiveOnFailure */
		if (GIV(primFailCode)) {
			retryPrimitiveOnFailure();
		}
		/* end maybeRetryPrimitiveOnFailure */
		/* begin maybeFailForLastObjectOverwrite */
		if (checkAllocFiller) {
			if (((freeStart0()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart0())) != (freeStart0()))) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrWritePastObject;
				/* end primitiveFailFor: */
			}
		}
		/* end maybeFailForLastObjectOverwrite */
		if (!GIV(primFailCode) && ((GIV(framePointer) == _savedFramePointer) && (!(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))))) {
			if (GIV(stackPointer) != (_savedStackPointer + (_nArgs * BytesPerWord))) {
				flag("Would be nice to make this a message send of e.g. unbalancedPrimitive to the current process or context");
				failUnbalancedPrimitive();
				GIV(stackPointer) = _savedStackPointer;
			}
		}
		if (GIV(nextProfileTick) > 0) {
			checkProfileTick(GIV(newMethod));
		}
		_succeeded = !GIV(primFailCode);
		goto l14;
		l14:
		;
		/* end slowPrimitiveResponse */
		if (_succeeded) {
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), _inInterpreter);
			/* end returnToExecutive: */
			goto l18;
		}
	}
	{
		{
			/* begin fetchPointer:ofObject: */
			_methodHeader2 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (!((assert((((_methodHeader2 & 7) == 1)) || ((((usqInt) _methodHeader2 ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader2 ) >= (minCogMethodAddress())))), (_methodHeader2 & (smallIntegerTag())) == 0))) {
				if (((assert(((_methodHeader2 & 7) == 1)), (_methodHeader2 >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
					cogselector(GIV(newMethod), GIV(nilObj));
					/* begin fetchPointer:ofObject: */
					_methodHeader2 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
				} else {
					maybeFlagMethodAsInterpreted(GIV(newMethod));
				}
			}
		}
		activateNewMethod();
	}
	l18:
	;
	/* end executePrimitiveFromInterpreter:ifFail: */
	/* end executeNewMethod: */
	/* end executeNewMethod */
	/* begin initPrimCall */
	GIV(primFailCode) = 0;
	/* end initPrimCall */
}
/*	Call an external primitive. External primitive methods first literals are 
	an array of 
	* The module name (String | Symbol) 
	* The function name (String | Symbol) 
	* The session ID (SmallInteger) [OBSOLETE], or in Spur, the accessorDepth 
	(Integer) * The function index (Integer) in the externalPrimitiveTable 
	For fast interpreter dispatch in subsequent invocations the 
	primitiveFunctionPointer in the method cache is rewritten, either to the 
	function itself, or to zero if the external 
	function is not found. This allows for fast responses as long as the 
	method stays in 
	the cache. The cache rewrite relies on lastMethodCacheProbeWrite which is 
	set in 
	addNewMethodToCache:. 
	Now that the VM flushes function addresses from its tables, the session ID 
	is obsolete, 
	but it is kept for backward compatibility. Also, a failed lookup is 
	reported specially. If a 
	method has been looked up and not been found, the function address is 
	stored as -1 
	(i.e., the SmallInteger -1 to distinguish from 16rFFFFFFFF which may be 
	returned from 
	lookup), and the primitive fails with PrimErrNotFound. */
/* StackInterpreterPrimitives>>#primitiveExternalCall */
static void
primitiveExternalCall(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _accessorDepth;
	void (*_addr)();
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _functionLength;
	sqInt _functionName;
	sqInt _i;
	sqInt _index;
	sqInt _lit;
	sqInt _moduleLength;
	sqInt _moduleName;
	usqInt _numSlots;
	usqInt _numSlots2;
	usqInt _numSlots22;
	usqInt _numSlots3;
	sqInt _val;

	_accessorDepth = 0;
	_val = 0;
	if (!((((GIV(newMethod) & (tagMask())) == 0) && (((((usqInt) (longAt(GIV(newMethod))) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()))) && (((literalCountOfMethodHeader(methodHeaderOf(GIV(newMethod)))) > 0) && (((_lit = literalofMethod(0, GIV(newMethod))), (((_lit & (tagMask())) == 0) && (((((usqInt) (longAt(_lit)) ) >> (formatShift())) & (formatMask())) == 2)) && (((numSlotsOf(_lit)) == 4) && (((_index = unsignedLongAt((_lit + BaseHeaderSize) + (3U << (shiftForWord())))), ((_index & 7) == 1))))))))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadMethod;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	if (_index < 0) {
		rewriteMethodCacheEntryForExternalPrimitiveToFunction(0);
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrNotFound;
		return;
		/* end primitiveFailFor: */
	}
	if ((_index > 0) && (_index <= MaxExternalPrimitiveTableSize)) {
		_addr = externalPrimitiveTable[_index - 1];
		if (_addr != 0) {
			rewriteMethodCacheEntryForExternalPrimitiveToFunction(_addr);
			/* begin callExternalPrimitive: */
			primitiveFunctionPointer = _addr;
			/* begin dispatchFunctionPointer: */
			_addr();
			/* end dispatchFunctionPointer: */
			/* begin maybeFailForLastObjectOverwrite */
			if (checkAllocFiller) {
				if (((freeStart0()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart0())) != (freeStart0()))) {
					/* begin primitiveFailFor: */
					GIV(primFailCode) = PrimErrWritePastObject;
					/* end primitiveFailFor: */
				}
			}
			/* end maybeFailForLastObjectOverwrite */
			/* end callExternalPrimitive: */
			/* begin maybeRetryPrimitiveOnFailure */
			if (GIV(primFailCode)) {
				retryPrimitiveOnFailure();
			}
			/* end maybeRetryPrimitiveOnFailure */
			return;
		}
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrNamedInternal;
		return;
		/* end primitiveFailFor: */
	}
	/* begin storePointerUnchecked:ofObject:withValue: */
	assert(!(isOopForwarded(_lit)));
	longAtput((_lit + BaseHeaderSize) + (2U << (shiftForWord())), ConstZero);
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	assert(!(isOopForwarded(_lit)));
	longAtput((_lit + BaseHeaderSize) + (3U << (shiftForWord())), ConstZero);
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin fetchPointer:ofObject: */
	_moduleName = unsignedLongAt((_lit + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	if (_moduleName == GIV(nilObj)) {
		_moduleLength = 0;
	} else {
		if (!(((_moduleName & (tagMask())) == 0) && (((((usqInt) (longAt(_moduleName)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())))) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadMethod;
			/* end primitiveFailFor: */
		}
		/* begin lengthOf:format: */
		_fmt = (((usqInt) (longAt(_moduleName)) ) >> (formatShift())) & (formatMask());
		/* begin numSlotsOfAny: */
		_numSlots2 = byteAt(_moduleName + 7);
		_numSlots = ((_numSlots2 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_moduleName - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots2);
		/* end numSlotsOfAny: */
		if (_fmt <= 5) {
			_moduleLength = _numSlots;
			goto l14;
		}
		if (_fmt >= (firstByteFormat())) {
			_moduleLength = (_numSlots << (shiftForWord())) - (_fmt & 7);
			goto l14;
		}
		if (_fmt >= (firstShortFormat())) {
			_moduleLength = (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
			goto l14;
		}
		if (_fmt >= (firstLongFormat())) {
			_moduleLength = (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
			goto l14;
		}
		if (_fmt == (sixtyFourBitIndexableFormat())) {
			_moduleLength = _numSlots;
			goto l14;
		}
		_moduleLength = 0;
		l14:
		;
		/* end lengthOf:format: */
	}
	/* begin fetchPointer:ofObject: */
	_functionName = unsignedLongAt((_lit + BaseHeaderSize) + (1U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	if (!(((_functionName & (tagMask())) == 0) && (((((usqInt) (longAt(_functionName)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadMethod;
		/* end primitiveFailFor: */
	}
	/* begin lengthOf:format: */
	_fmt2 = (((usqInt) (longAt(_functionName)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOfAny: */
	_numSlots22 = byteAt(_functionName + 7);
	_numSlots3 = ((_numSlots22 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_functionName - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots22);
	/* end numSlotsOfAny: */
	if (_fmt2 <= 5) {
		_functionLength = _numSlots3;
		goto l17;
	}
	if (_fmt2 >= (firstByteFormat())) {
		_functionLength = (_numSlots3 << (shiftForWord())) - (_fmt2 & 7);
		goto l17;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_functionLength = (_numSlots3 << ((shiftForWord()) - 1)) - (_fmt2 & 3);
		goto l17;
	}
	if (_fmt2 >= (firstLongFormat())) {
		_functionLength = (_numSlots3 << ((shiftForWord()) - 2)) - (_fmt2 & 1);
		goto l17;
	}
	if (_fmt2 == (sixtyFourBitIndexableFormat())) {
		_functionLength = _numSlots3;
		goto l17;
	}
	_functionLength = 0;
	l17:
	;
	/* end lengthOf:format: */
	_addr = ioLoadExternalFunctionOfLengthFromModuleOfLengthAccessorDepthInto(_functionName + BaseHeaderSize, _functionLength, _moduleName + BaseHeaderSize, _moduleLength, &_accessorDepth);
	if (_addr == 0) {
		_index = -1;
	} else {
		/* begin addToExternalPrimitiveTable: */
		for (_i = GIV(externalPrimitiveTableFirstFreeIndex); _i < MaxExternalPrimitiveTableSize; _i += 1) {
			if ((externalPrimitiveTable[_i]) == 0) {
				externalPrimitiveTable[_i] = ((void *) _addr );
				_index = (GIV(externalPrimitiveTableFirstFreeIndex) = _i + 1);
				goto l4;
			}
		}
		_index = 0;
		l4:
		;
		/* end addToExternalPrimitiveTable: */
		/* begin storePointerUnchecked:ofObject:withValue: */
		assert(!(isOopForwarded(_lit)));
		longAtput((_lit + BaseHeaderSize) + (2U << (shiftForWord())), ((((usqInt) _accessorDepth ) << 3) | 1));
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	/* begin storePointerUnchecked:ofObject:withValue: */
	assert(!(isOopForwarded(_lit)));
	longAtput((_lit + BaseHeaderSize) + (3U << (shiftForWord())), ((((usqInt) _index ) << 3) | 1));
	/* end storePointerUnchecked:ofObject:withValue: */
	if (_index >= 0) {
		rewriteMethodCacheEntryForExternalPrimitiveToFunction(_addr);
		/* begin callExternalPrimitive: */
		primitiveFunctionPointer = _addr;
		/* begin dispatchFunctionPointer: */
		_addr();
		/* end dispatchFunctionPointer: */
		/* begin maybeFailForLastObjectOverwrite */
		if (checkAllocFiller) {
			if (((freeStart0()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart0())) != (freeStart0()))) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrWritePastObject;
				/* end primitiveFailFor: */
			}
		}
		/* end maybeFailForLastObjectOverwrite */
		/* end callExternalPrimitive: */
		/* begin maybeRetryPrimitiveOnFailure */
		if (GIV(primFailCode)) {
			retryPrimitiveOnFailure();
		}
		/* end maybeRetryPrimitiveOnFailure */
	} else {
		rewriteMethodCacheEntryForExternalPrimitiveToFunction(0);
		assert((fetchPointerofObject(2, _lit)) == ConstZero);
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrNotFound;
		/* end primitiveFailFor: */
	}
}
/*	Primitive. Allocate an object on the external heap. */
/* StackInterpreterPrimitives>>#primitiveFFIAllocate */
EXPORT(void)
primitiveFFIAllocate(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _addr;
	sqInt _byteSize;
	sqInt _classObj;
	sqInt _integerPointer;
	sqInt _nElements;
	sqInt _oop;
	sqInt _oop2;
	void **_ptr;
	char *_sp;

	/* begin stackIntegerValue: */
	_integerPointer = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_byteSize = _integerPointer >> 3;
		goto l3;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_byteSize = 0;
		goto l3;
	}
	/* end checkedIntegerValueOf: */
	l3:
	;
	/* end stackIntegerValue: */
	if (GIV(primFailCode)) {
		return;
	}
	_addr = malloc(_byteSize);
	if (_addr == 0) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	/* begin newExternalAddressWithValue: */
	/* begin instantiateClass:indexableSize: */
	_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ));
	_nElements = sizeof(void*);
	_oop2 = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, _nElements, 0, 0);
	/* end instantiateClass:indexableSize: */
	_ptr = ((void **) (firstIndexableField(_oop2)) );
	_ptr[0] = ((sqIntptr_t) _addr );
	_oop = _oop2;
	/* end newExternalAddressWithValue: */
	{
		/* begin methodReturnValue: */
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
		/* end methodReturnValue: */
		return;
	}
}
/*	Primitive. Free the object pointed to on the external heap. */
/* StackInterpreterPrimitives>>#primitiveFFIFree */
EXPORT(void)
primitiveFFIFree(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	void * _addr;
	sqInt _oop;
	sqInt _oop2;
	char *_sp;
	sqInt _valuePointer;

	/* begin stackObjectValue: */
	_oop2 = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	if (_oop2 & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_oop = null;
		goto l2;
	}
	_oop = _oop2;
	l2:
	;
	/* end stackObjectValue: */
	/* begin readAddress: */
	if (!(isKindOfClass(_oop, unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ))))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_addr = null;
		goto l4;
	}
	/* begin fetchPointer:ofObject: */
	_addr = unsignedLongAt((_oop + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	l4:
	;
	/* end readAddress: */
	if (GIV(primFailCode)) {
		return;
	}
	if ((_addr == 0) || (((((usqIntptr_t) _addr ) & ((sizeof(sqIntptr_t)) - 1)) != 0) || (isInMemory(_addr)))) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	free(_addr);
	/* begin writeAddress:to: */
	if (!(isKindOfClass(_oop, unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ))))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		goto l6;
	}
	/* begin storePointer:ofObject:withValue: */
	_valuePointer = ((sqInt) 0 );
	assert(!(isForwarded(_oop)));
	if (((_oop & (tagMask())) == 0) && ((_oop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((_valuePointer & (tagMask())) == 0) && (((_valuePointer & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_valuePointer >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_oop)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _oop);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(_oop)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l5;
	}
	if (_valuePointer & (tagMask())) {
		goto l5;
	}
	if (!(_oop >= 0x20000000000LL)) {
		goto l5;
	}
	if (_valuePointer >= 0x20000000000LL) {
		goto l5;
	}
	if ((_valuePointer >= GIV(nilObj)) && (_valuePointer <= GIV(trueObj))) {
		goto l5;
	}
	if (!(_valuePointer >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l5;
	}
	remember(getFromPermToNewSpaceRememberedSet(), _oop);
	l5:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((_oop + BaseHeaderSize) + (0U << (shiftForWord())), _valuePointer);
	/* end storePointer:ofObject:withValue: */
	l6:
	;
	/* end writeAddress:to: */
	{
		/* begin methodReturnValue: */
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
		/* end methodReturnValue: */
		return;
	}
}
/*	Answer a (signed or unsigned) n byte integer from the given byte offset 
	in the receiver, using the platform's endianness. */
/* StackInterpreterPrimitives>>#primitiveFFIIntegerAt */
EXPORT(sqInt)
primitiveFFIIntegerAt(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _addr;
	sqInt _byteOffset;
	sqInt _byteSize;
	sqInt _integerPointer;
	sqInt _integerPointer2;
	sqInt _isSigned;
	usqLong _mask;
	sqInt _obj;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	usqLong _value;
	sqInt _valueOop;

	/* begin booleanValueOf: */
	_obj = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	if (_obj == GIV(trueObj)) {
		_isSigned = 1;
		goto l2;
	}
	if (_obj == GIV(falseObj)) {
		_isSigned = 0;
		goto l2;
	}
	/* begin success: */
	{
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
	}
	/* end success: */
	_isSigned = null;
	l2:
	;
	/* end booleanValueOf: */
	/* begin stackIntegerValue: */
	_integerPointer = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_byteSize = _integerPointer >> 3;
		goto l4;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_byteSize = 0;
		goto l4;
	}
	/* end checkedIntegerValueOf: */
	l4:
	;
	/* end stackIntegerValue: */
	/* begin stackIntegerValue: */
	_integerPointer2 = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer2 & 7) == 1)) {
		_byteOffset = _integerPointer2 >> 3;
		goto l5;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_byteOffset = 0;
		goto l5;
	}
	/* end checkedIntegerValueOf: */
	l5:
	;
	/* end stackIntegerValue: */
	/* begin stackObjectValue: */
	_oop = unsignedLongAt(GIV(stackPointer) + (3 * BytesPerWord));
	if (_oop & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_rcvr = null;
		goto l3;
	}
	_rcvr = _oop;
	l3:
	;
	/* end stackObjectValue: */
	if (GIV(primFailCode)) {
		return 0;
	}
	if (!((_byteOffset > 0) && (((_byteSize >= 1) && (_byteSize <= 8)) && ((_byteSize & (_byteSize - 1)) == 0)))) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadArgument);
		/* end primitiveFailFor: */
	}
	_addr = maybeExternalAddressOfstartingAtsize(_rcvr, _byteOffset, _byteSize);
	if (_addr == 0) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadArgument);
		/* end primitiveFailFor: */
	}
	if (_byteSize <= 2) {
		if (_byteSize == 1) {
			_value = ((unsigned char) (byteAt(_addr)) );
		}
 else {
			_value = ((unsigned short) (unalignedShortAt(_addr)) );
		}
	}
 else {
		if (_byteSize == 4) {
			_value = ((unsigned int) (unalignedLong32At(_addr)) );
		} else {
			_value = unalignedLong64At(_addr);
		}
	}
	if (_byteSize < BytesPerWord) {
		if (_isSigned) {
			_mask = ((unsigned long long) 1 ) << ((_byteSize * 8) - 1);
			_value = (_value & (_mask - 1)) - (_value & _mask);
		}
		_valueOop = ((_value << 3) | 1);
	} else {
		if (_isSigned) {
			if (_byteSize < 8) {
				_mask = ((unsigned long long) 1 ) << ((_byteSize * 8) - 1);
				_value = (_value & (_mask - 1)) - (_value & _mask);
			}
			_valueOop = signed64BitIntegerFor(_value);
		} else {
			_valueOop = positive64BitIntegerFor(_value);
		}
	}
	/* begin methodReturnValue: */
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueOop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	return 0;
	/* end methodReturnValue: */
}
/*	Store a (signed or unsigned) n byte integer at the given byte offset 
	in the receiver, using the platform's endianness. */
/* StackInterpreterPrimitives>>#primitiveFFIIntegerAtPut */
EXPORT(sqInt)
primitiveFFIIntegerAtPut(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _addr;
	sqInt _byteOffset;
	sqInt _byteSize;
	sqInt _integerPointer;
	sqInt _integerPointer2;
	sqInt _isSigned;
	sqLong _max;
	sqInt _obj;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	sqLong _value;
	sqInt _valueOop;

	/* begin booleanValueOf: */
	_obj = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	if (_obj == GIV(trueObj)) {
		_isSigned = 1;
		goto l2;
	}
	if (_obj == GIV(falseObj)) {
		_isSigned = 0;
		goto l2;
	}
	/* begin success: */
	{
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
	}
	/* end success: */
	_isSigned = null;
	l2:
	;
	/* end booleanValueOf: */
	/* begin stackIntegerValue: */
	_integerPointer = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_byteSize = _integerPointer >> 3;
		goto l5;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_byteSize = 0;
		goto l5;
	}
	/* end checkedIntegerValueOf: */
	l5:
	;
	/* end stackIntegerValue: */
	/* begin stackValue: */
	_valueOop = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	/* begin stackIntegerValue: */
	_integerPointer2 = unsignedLongAt(GIV(stackPointer) + (3 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer2 & 7) == 1)) {
		_byteOffset = _integerPointer2 >> 3;
		goto l6;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_byteOffset = 0;
		goto l6;
	}
	/* end checkedIntegerValueOf: */
	l6:
	;
	/* end stackIntegerValue: */
	/* begin stackObjectValue: */
	_oop = unsignedLongAt(GIV(stackPointer) + (4 * BytesPerWord));
	if (_oop & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_rcvr = null;
		goto l4;
	}
	_rcvr = _oop;
	l4:
	;
	/* end stackObjectValue: */
	if (GIV(primFailCode)) {
		return 0;
	}
	if (!((_byteOffset > 0) && (((_byteSize >= 1) && (_byteSize <= 8)) && ((_byteSize & (_byteSize - 1)) == 0)))) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadArgument);
		/* end primitiveFailFor: */
	}
	_addr = maybeExternalAddressOfstartingAtsize(_rcvr, _byteOffset, _byteSize);
	if (_addr == 0) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadArgument);
		/* end primitiveFailFor: */
	}
	_value = ((_isSigned)
		 ? signed64BitValueOf(_valueOop)
		 : positive64BitValueOf(_valueOop));
	if (GIV(primFailCode)) {
		return 0;
	}
	if (_byteSize < 8) {
		if (_isSigned) {
			_max = ((unsigned long long) 1 ) << ((8 * _byteSize) - 1);
			if (!((_value >= (0 - _max)) && (_value < _max))) {
				/* begin primitiveFailFor: */
				return (GIV(primFailCode) = PrimErrBadArgument);
				/* end primitiveFailFor: */
			}
		} else {
			if (!(((unsigned long long) _value ) < (((unsigned long long) 1 ) << (8 * _byteSize)))) {
				/* begin primitiveFailFor: */
				return (GIV(primFailCode) = PrimErrBadArgument);
				/* end primitiveFailFor: */
			}
		}
	}
	if (_byteSize <= 2) {
		if (_byteSize == 1) {
			byteAtput(_addr, _value);
		}
 else {
			unalignedShortAtput(_addr, _value);
		}
	}
 else {
		if (_byteSize == 4) {
			unalignedLong32Atput(_addr, _value);
		}
 else {
			unalignedLong64Atput(_addr, _value);
		}
	}
	/* begin methodReturnValue: */
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueOop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	return 0;
	/* end methodReturnValue: */
}
/*	Primitive. Search up the context stack for the next method context marked 
	for exception handling starting at the receiver. Return nil if none found */
/* StackInterpreterPrimitives>>#primitiveFindHandlerContext */
static void
primitiveFindHandlerContext(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _handlerOrNilOrZero;
	char *_sp;
	char *_theSP;

	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	_theSP = GIV(stackPointer);
	assert(_theSP < GIV(framePointer));
	assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(GIV(stackPage)->headFP = GIV(framePointer));
		(GIV(stackPage)->headSP = _theSP);
	}
	/* end setHeadFP:andSP:inPage: */
	assert(pageListIsWellFormed());
	/* end writeBackHeadFramePointers */
	_handlerOrNilOrZero = findMethodWithPrimitiveFromContextUpToContext(199, unsignedLongAt(GIV(stackPointer)), GIV(nilObj));
	if (_handlerOrNilOrZero == 0) {
		/* begin nilObject */
		_handlerOrNilOrZero = GIV(nilObj);
		/* end nilObject */
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), _handlerOrNilOrZero);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Primitive. Search up the context stack for the next method context marked 
	for unwind 
	handling from the receiver up to but not including the argument. Return 
	nil if none found. */
/* StackInterpreterPrimitives>>#primitiveFindNextUnwindContext */
static void
primitiveFindNextUnwindContext(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _calleeContext;
	sqInt _callerContextOrNil;
	sqInt _handlerOrNilOrZero;
	sqInt _senderContext;
	sqInt _senderOop;
	char *_sp;
	sqInt _startContext;
	char *_startFP;
	sqInt _stopContext;
	char *_theFP;
	char *_theFP2;
	char *_theFPAbove;
	sqInt _theMethod;
	StackPage *_thePage;
	char *_theSP;
	char *_theSP2;

	/* begin stackTop */
	_stopContext = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_calleeContext = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (!((_stopContext == GIV(nilObj)) || (((_stopContext & (tagMask())) == 0) && (((longAt(_stopContext)) & (classIndexMask())) == ClassMethodContextCompactIndex)))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return;
		/* end primitiveFail */
	}
	assert(_stopContext != _calleeContext);
	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	_theSP = GIV(stackPointer);
	assert(_theSP < GIV(framePointer));
	assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(GIV(stackPage)->headFP = GIV(framePointer));
		(GIV(stackPage)->headSP = _theSP);
	}
	/* end setHeadFP:andSP:inPage: */
	assert(pageListIsWellFormed());
	/* end writeBackHeadFramePointers */
	if (((((unsignedLongAt((_calleeContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_calleeContext)))) {
		/* begin frameOfMarriedContext: */
		/* begin fetchPointer:ofObject: */
		_senderOop = unsignedLongAt((_calleeContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		{
			assert(((_senderOop & 7) == 1));
			_theFP = pointerForOop(_senderOop - 1);
		}
		/* end frameOfMarriedContext: */
		if ((unsignedLongAt(_theFP + FoxSavedFP)) == 0) {
			_handlerOrNilOrZero = findMethodWithPrimitiveFromContextUpToContext(198, frameCallerContext(_theFP), _stopContext);
		} else {
			/* begin findMethodWithPrimitive:FromFP:UpToContext: */
			_startFP = pointerForOop(unsignedLongAt(_theFP + FoxSavedFP));
			_theFP2 = _startFP;
			_theFPAbove = _startFP;
			do {
				if ((((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP2 + FoxMethod)) )))
					 ? ((unsignedLongAt(_theFP2 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
					 : (byteAt((_theFP2 + FoxIFrameFlags) + 2)) != 0)) && (_stopContext == (unsignedLongAt(_theFP2 + FoxThisContext)))) {
					_handlerOrNilOrZero = 0;
					goto l10;
				}
				if (!(((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP2 + FoxMethod)) )))
					 ? ((unsignedLongAt(_theFP2 + FoxMethod)) & MFMethodFlagIsBlockFlag) != 0
					 : (byteAt((_theFP2 + FoxIFrameFlags) + 3)) != 0))) {
					_theMethod = ((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP2 + FoxMethod)) )))
						 ? ((mframeHomeMethod(_theFP2))->methodObject)
						 : unsignedLongAt(_theFP2 + FoxMethod));
					if ((primitiveIndexOfMethodheader(_theMethod, methodHeaderOf(_theMethod))) == 198) {
						if (_theFP2 == _theFPAbove) {
							_theSP2 = findSPOfon(_theFP2, stackPageFor(_theFP2));
						} else {
							{
								assert(!(isBaseFrame(_theFPAbove)));
								_theSP2 = (_theFPAbove + (frameStackedReceiverOffset(_theFPAbove))) + BytesPerWord;
							}
						}
						/* begin ensureFrameIsMarried:SP: */
						if (((isMachineCodeIP(((usqInt) (unsignedLongAt(_theFP2 + FoxMethod)) )))
							 ? ((unsignedLongAt(_theFP2 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
							 : (byteAt((_theFP2 + FoxIFrameFlags) + 2)) != 0)) {
							assert(isContext(frameContext(_theFP2)));
							_handlerOrNilOrZero = unsignedLongAt(_theFP2 + FoxThisContext);
							goto l10;
						}
						_handlerOrNilOrZero = marryFrameSP(_theFP2, _theSP2);
						goto l10;
						/* end ensureFrameIsMarried:SP: */
					}
				}
				_theFPAbove = _theFP2;
				_theFP2 = pointerForOop(unsignedLongAt(_theFP2 + FoxSavedFP));
			} while (_theFP2 != 0);
			/* begin frameCallerContext: */
			assert(isBaseFrame(_theFPAbove));
			/* begin stackPageFor: */
			/* begin stackPageAt: */
			_thePage = stackPageAtpages((assert((((char *) _theFPAbove ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFPAbove ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFPAbove, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
			/* end stackPageAt: */
			/* end stackPageFor: */
			_callerContextOrNil = unsignedLongAt((_thePage->baseAddress));
			assert(addressCouldBeObj(_callerContextOrNil));
			assert((_callerContextOrNil == (nilObject())) || (isContext(_callerContextOrNil)));
			_senderContext = _callerContextOrNil;
			/* end frameCallerContext: */
			if (!(((_senderContext & (tagMask())) == 0) && (((longAt(_senderContext)) & (classIndexMask())) == ClassMethodContextCompactIndex))) {
				/* begin nilObject */
				_handlerOrNilOrZero = GIV(nilObj);
				goto l10;
				/* end nilObject */
			}
			_handlerOrNilOrZero = findMethodWithPrimitiveFromContextUpToContext(198, _senderContext, _stopContext);
			l10:
			;
			/* end findMethodWithPrimitive:FromFP:UpToContext: */
		}
	} else {
		/* begin fetchPointer:ofObject: */
		_startContext = unsignedLongAt((_calleeContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_startContext & (tagMask())) == 0) && (((longAt(_startContext)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
			_handlerOrNilOrZero = findMethodWithPrimitiveFromContextUpToContext(198, _startContext, _stopContext);
		} else {
			_handlerOrNilOrZero = 0;
		}
	}
	if (_handlerOrNilOrZero == 0) {
		/* begin nilObject */
		_handlerOrNilOrZero = GIV(nilObj);
		/* end nilObject */
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), _handlerOrNilOrZero);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Do a full garbage collection. Answer the size of the largest free chunk.Do a full garbage collection. In SqueakV3ObjectMemory, answer the number 
	of bytes available (including swap space if dynamic memory management is 
	supported). In Spur, answer the size of the largest free chunk. */
/* StackInterpreterPrimitives>>#primitiveFullGC */
static void
primitiveFullGC(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerVal;
	char *_sp;
	char *_theSP;

	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	_theSP = GIV(stackPointer);
	assert(_theSP < GIV(framePointer));
	assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(GIV(stackPage)->headFP = GIV(framePointer));
		(GIV(stackPage)->headSP = _theSP);
	}
	/* end setHeadFP:andSP:inPage: */
	assert(pageListIsWellFormed());
	/* end writeBackHeadFramePointers */
	{
		/* begin pop:thenPushInteger: */
		_integerVal = fullGC();
		unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), ((((usqInt) _integerVal ) << 3) | 1));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushInteger: */
	}
}
/* StackInterpreterPrimitives>>#primitiveGetCurrentWorkingDirectory */
EXPORT(sqInt)
primitiveGetCurrentWorkingDirectory(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_aCString;
	sqInt _oop;
	char *_sp;

	_aCString = ((char *) (alloca(0xFF + 1)) );
	if ((ioGetCurrentWorkingDirectorymaxLength(_aCString, 0xFF + 1)) == -1) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	/* begin pop:thenPush: */
	_oop = stringForCString(_aCString);
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	return 0;
}
/*	See primitiveVMParameter method comment. 
	Return an OOP if success. 
	Return nil if no argument is available for the index */
/* StackInterpreterPrimitives>>#primitiveGetVMParameter: */
static sqInt NoDbgRegParms
primitiveGetVMParameter(sqInt _index)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	switch (_index) {
		case 1:
		{
			return positiveMachineIntegerFor(totalBytesInSegments());
		}
		case 2:
		{
			return ((((usqInt) ((GIV(freeStart) - (((eden()).start))) + (GIV(pastSpaceStart) - (((pastSpace()).start)))) ) << 3) | 1);
		}
		case 3:
		{
			return positiveMachineIntegerFor((newSpaceCapacity()) + (totalBytesInSegments()));
		}
		case 6:
		{
			return ((((usqInt) ((sqInt) (((scavengerTenuringProportion()) * (((GIV(pastSpace).limit)) - ((GIV(pastSpace).start)))) / (8 * BytesPerOop)) ) ) << 3) | 1);
		}
		case 7:
		{
			return ((((usqInt) GIV(statFullGCs) ) << 3) | 1);
		}
		case 8:
		{
			return ((((GIV(statFullGCUsecs) + 500) / 1000) << 3) | 1);
		}
		case 9:
		{
			return ((((usqInt) GIV(statScavenges) ) << 3) | 1);
		}
		case 10:
		{
			return ((((GIV(statScavengeGCUsecs) + 500) / 1000) << 3) | 1);
		}
		case 11:
		{
			return ((((usqInt) GIV(statTenures) ) << 3) | 1);
		}
		case 12:
		{
			return ((((usqInt) (((GIV(maxSlotsForNewSpaceAlloc) == 0)
				 ? (/* begin fixedFieldsOfClassFormatMask */ (1U << (fixedFieldsFieldWidth())) - 1 /* end fixedFieldsOfClassFormatMask */)
				 : GIV(maxSlotsForNewSpaceAlloc))) ) << 3) | 1);
		}
		case 13:
		case 14:
		case 15:
		case 39:
		case 57:
		{
			return ConstZero;
		}
		case 16:
		{
			return positive64BitIntegerFor(GIV(statIdleUsecs));
		}
		case 17:
		{
			return ConstZero;
		}
		case 18:
		{
			return ((((GIV(statCompactionUsecs) + 500) / 1000) << 3) | 1);
		}
		case 19:
		{
			return ((((usqInt) (GIV(scavengeThreshold) - (((eden()).start))) ) << 3) | 1);
		}
		case 20:
		{
			return positive64BitIntegerFor(ioUTCStartMicroseconds());
		}
		case 21:
		{
			return ((((usqInt) ((GIV(fromOldSpaceRememberedSet)->rememberedSetSize)) ) << 3) | 1);
		}
		case 22:
		{
			return ((((usqInt) GIV(statRootTableOverflows) ) << 3) | 1);
		}
		case 23:
		{
			return ((((usqInt) extraVMMemory ) << 3) | 1);
		}
		case 24:
		{
			return ((((usqInt) GIV(shrinkThreshold) ) << 3) | 1);
		}
		case 25:
		{
			return ((((usqInt) GIV(growHeadroom) ) << 3) | 1);
		}
		case 26:
		{
			return ((((usqInt) (ioHeartbeatMilliseconds()) ) << 3) | 1);
		}
		case 27:
		{
			return ((((usqInt) GIV(statMarkCount) ) << 3) | 1);
		}
		case 28:
		{
			return ((((usqInt) 0 ) << 3) | 1);
		}
		case 29:
		{
			return ((((usqInt) 0 ) << 3) | 1);
		}
		case 30:
		{
			return ((((usqInt) GIV(statCompactPassCount) ) << 3) | 1);
		}
		case 0x1F:
		{
			return ((((usqInt) GIV(statGrowMemory) ) << 3) | 1);
		}
		case 32:
		{
			return ((((usqInt) GIV(statShrinkMemory) ) << 3) | 1);
		}
		case 33:
		{
			return ((((usqInt) GIV(statRootTableCount) ) << 3) | 1);
		}
		case 34:
		{
			return positive64BitIntegerFor(currentAllocatedBytes());
		}
		case 35:
		{
			return ((((usqInt) GIV(statSurvivorCount) ) << 3) | 1);
		}
		case 36:
		{
			return ((((GIV(statGCEndUsecs) / 1000) & MillisecondClockMask) << 3) | 1);
		}
		case 37:
		{
			return ((((usqInt) 0 ) << 3) | 1);
		}
		case 38:
		{
			return ((((GIV(statIGCDeltaUsecs) + 500) / 1000) << 3) | 1);
		}
		case 40:
		{
			return ((((usqInt) BytesPerWord ) << 3) | 1);
		}
		case 41:
		{
			return ((((usqInt) 68021 ) << 3) | 1);
		}
		case 42:
		{
			return ((((usqInt) GIV(numStackPages) ) << 3) | 1);
		}
		case 43:
		{
			return ((((usqInt) desiredNumStackPages ) << 3) | 1);
		}
		case 44:
		{
			return ((((usqInt) (((GIV(eden).limit)) - ((GIV(eden).start))) ) << 3) | 1);
		}
		case 45:
		{
			return ((((usqInt) desiredEdenBytes ) << 3) | 1);
		}
		case 46:
		{
			return getCogCodeSize();
		}
		case 47:
		{
			return getDesiredCogCodeSize();
		}
		case 48:
		{
			return ((((usqInt) (((((GIV(flagInterpretedMethods))
				 ? 2
				 : 0)) + (((GIV(preemptionYields))
				 ? 0
				 : 4))) + (((((usqInt) GIV(imageHeaderFlags) ) >> 2) | (((2 + 4) + 16) + 32)) - (((2 + 4) + 16) + 32))) ) << 3) | 1);
		}
		case 49:
		{
			return ((((usqInt) (ioGetMaxExtSemTableSize()) ) << 3) | 1);
		}
		case 52:
		{
			return ((((usqInt) ((GIV(fromOldSpaceRememberedSet)->rememberedSetLimit)) ) << 3) | 1);
		}
		case 53:
		{
			return ((((usqInt) (numSegments()) ) << 3) | 1);
		}
		case 54:
		{
			return ((GIV(totalFreeOldSpace) << 3) | 1);
		}
		case 55:
		{
			return floatObjectOf(getHeapGrowthToSizeGCRatio());
		}
		case 56:
		{
			return positive64BitIntegerFor(GIV(statProcessSwitch));
		}
		case 58:
		{
			return positive64BitIntegerFor(GIV(statForceInterruptCheck));
		}
		case 59:
		{
			return positive64BitIntegerFor(GIV(statCheckForEvents));
		}
		case 60:
		{
			return positive64BitIntegerFor(GIV(statStackOverflow));
		}
		case 61:
		{
			return positive64BitIntegerFor(GIV(statStackPageDivorce));
		}
		case 0x3E:
		{
			return getCodeCompactionCount();
		}
		case 0x3F:
		{
			return getCodeCompactionMSecs();
		}
		case 64:
		{
			return ((((usqInt) (numMethodsOfType(CMMethod)) ) << 3) | 1);
		}
		case 65:
		{
			return ((((usqInt) ((((IMMUTABILITY)
				 ? 2
				 : 0)) + (
#        if ITIMER_HEARTBEAT
					4
#        else /* ITIMER_HEARTBEAT */
					0
#        endif /* ITIMER_HEARTBEAT */
					)) ) << 3) | 1);
		}
		case 66:
		{
			return ((((usqInt) (stackPageByteSize()) ) << 3) | 1);
		}
		case 67:
		{
			return (((maxOldSpaceSize()) << 3) | 1);
		}
		case 68:
		{
			return floatObjectOf(statAverageLivePagesWhenMapping0());
		}
		case 69:
		{
			return ((((usqInt) (statMaxPageCountWhenMapping0()) ) << 3) | 1);
		}
		case 70:
		{
			return ((((usqInt) (VM_PROXY_MAJOR) ) << 3) | 1);
		}
		case 71:
		{
			return ((((usqInt) (VM_PROXY_MINOR) ) << 3) | 1);
		}
		case 72:
		{
			return ((((GIV(statMarkUsecs) + 500) / 1000) << 3) | 1);
		}
		case 73:
		{
			return ((((GIV(statSweepUsecs) + 500) / 1000) << 3) | 1);
		}
		case 74:
		{
			return ((((usqInt) ((GIV(statMaxAllocSegmentTime) + 500) / 1000) ) << 3) | 1);
		}
		case 75:
		{
			return getMethodCompilationCount();
		}
		case 76:
		{
			return getMethodCompilationMSecs();
		}
		case 77:
		{
			return getBlockCompilationCount();
		}
		case 78:
		{
			return getBlockCompilationMSecs();
		}
		case 79:
		{
			return ((((usqInt) GIV(imageVersionNumber) ) << 3) | 1);
		}
		case 80:
		{
			return ((((usqInt) (((getFromOldSpaceRememberedSet())->rememberedSetSize)) ) << 3) | 1);
		}
		case 81:
		{
			return ((((usqInt) (((getFromOldSpaceRememberedSet())->rememberedSetLimit)) ) << 3) | 1);
		}
		case 82:
		{
			return ((((usqInt) (((getFromPermToOldSpaceRememberedSet())->rememberedSetSize)) ) << 3) | 1);
		}
		case 83:
		{
			return ((((usqInt) (((getFromPermToOldSpaceRememberedSet())->rememberedSetLimit)) ) << 3) | 1);
		}
		case 84:
		{
			return ((((usqInt) (((getFromPermToNewSpaceRememberedSet())->rememberedSetSize)) ) << 3) | 1);
		}
		case 85:
		{
			return ((((usqInt) (((getFromPermToNewSpaceRememberedSet())->rememberedSetLimit)) ) << 3) | 1);
		}
		case 86:
		{
			return ((GIV(avoidSearchingSegmentsWithPinnedObjects))
				 ? (/* begin trueObject */ GIV(trueObj) /* end trueObject */)
				 : (/* begin falseObject */ GIV(falseObj) /* end falseObject */));
		}
		default:
		{
			return null;
		}
	}
	return 0;
}
/*	Do a quick, incremental garbage collection and return the number of bytes 
	immediately available. 
	(Note: more space may be made available by doing a full garbage 
	collection. Do a quick, incremental garbage collection and return the number of bytes 
	immediately available. 
	(Note: more space may be made available by doing a full garbage 
	collection.  */
/* StackInterpreterPrimitives>>#primitiveIncrementalGC */
static void
primitiveIncrementalGC(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _integerVal;
	char *_sp;
	char *_theSP;

	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	_theSP = GIV(stackPointer);
	assert(_theSP < GIV(framePointer));
	assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(GIV(stackPage)->headFP = GIV(framePointer));
		(GIV(stackPage)->headSP = _theSP);
	}
	/* end setHeadFP:andSP:inPage: */
	assert(pageListIsWellFormed());
	/* end writeBackHeadFramePointers */
	{
		/* begin scavengingGC */
		scavengingGCTenuringIf(TenureByAge);
		/* end scavengingGC */
		/* begin pop:thenPushInteger: */
		_integerVal = (((GIV(totalFreeOldSpace) + ((((eden()).limit)) - GIV(freeStart))) + ((((pastSpace()).limit)) - GIV(pastSpaceStart))) + ((((futureSpace()).limit)) - (((futureSpace()).limit)))) - (interpreterAllocationReserveBytes());
		unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), ((((usqInt) _integerVal ) << 3) | 1));
		GIV(stackPointer) = _sp;
		/* end pop:thenPushInteger: */
	}
}
/* StackInterpreterPrimitives>>#primitiveInstVarAt */
static void
primitiveInstVarAt(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _class;
	sqInt _classFormat;
	sqInt _fixedFields;
	usqLong _fmt;
	sqLong _hdr;
	sqInt _index;
	unsigned int _integerValue;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _rcvr;
	char *_sp;
	sqInt _totalLength;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || ((GIV(argumentCount) > 1) && (((_rcvr & (tagMask())) == 0) && (((long64At(_rcvr)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	if (_rcvr & (tagMask())) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrInappropriate;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin baseHeader: */
	_hdr = long64At(_rcvr);
	/* end baseHeader: */
	_fmt = (((unsigned sqLong) _hdr ) >> (formatShift())) & (formatMask());
	/* begin lengthOf:format: */
	/* begin numSlotsOfAny: */
	_numSlots2 = byteAt(_rcvr + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOfAny: */
	if (_fmt <= 5) {
		_totalLength = _numSlots;
		goto l7;
	}
	if (_fmt >= (firstByteFormat())) {
		_totalLength = (_numSlots << (shiftForWord())) - (_fmt & 7);
		goto l7;
	}
	if (_fmt >= (firstShortFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
		goto l7;
	}
	if (_fmt >= (firstLongFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
		goto l7;
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		_totalLength = _numSlots;
		goto l7;
	}
	_totalLength = 0;
	l7:
	;
	/* end lengthOf:format: */
	/* begin fixedFieldsOf:format:length: */
	if ((_fmt >= (sixtyFourBitIndexableFormat())) || (_fmt == 2)) {
		_fixedFields = 0;
		goto l8;
	}
	if (_fmt < 2) {
		_fixedFields = _totalLength;
		goto l8;
	}
	_class = fetchClassOfNonImm(_rcvr);
	/* begin fixedFieldsOfClassFormat: */
	_classFormat = (unsignedLongAt((_class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	_fixedFields = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	/* end fixedFieldsOfClassFormat: */
	l8:
	;
	/* end fixedFieldsOf:format:length: */
	if (!((_index >= 1) && (_index <= _fixedFields))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	if ((_fmt == (indexablePointersFormat())) && ((_hdr & (classIndexMask())) == ClassMethodContextCompactIndex)) {
		_value = instVarofContext(_index - 1, _rcvr);
	} else {
		/* begin subscript:with:format: */
		if (_fmt <= 5) {
			/* begin fetchPointer:ofObject: */
			_value = unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << (shiftForWord())) ));
			goto l5;
			/* end fetchPointer:ofObject: */
		}
		if (_fmt >= (firstByteFormat())) {
			_value = ((((usqInt) (byteAt((_rcvr + BaseHeaderSize) + (_index - 1))) ) << 3) | 1);
			goto l5;
		}
		if (_fmt >= (firstShortFormat())) {
			_value = ((((usqInt) ((unsigned short) (shortAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << 1) ))) ) ) << 3) | 1);
			goto l5;
		}
		if (_fmt == (sixtyFourBitIndexableFormat())) {
			_value = positive64BitIntegerFor(long64At((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << 3) )));
			goto l5;
		}
		/* begin positive32BitIntegerFor: */
		_integerValue = long32At((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << 2) ));
		{
			_value = (((((usqInt) _integerValue ) & 0xFFFFFFFFU) << 3) | 1);
			goto l5;
		}
		/* end positive32BitIntegerFor: */
		l5:
		;
		/* end subscript:with:format: */
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _value);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveInstVarAtPut */
static void
primitiveInstVarAtPut(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _class;
	sqInt _classFormat;
	sqInt _fixedFields;
	usqLong _fmt;
	sqLong _hdr;
	sqInt _index;
	sqInt _newValue;
	usqInt _numSlots;
	usqInt _numSlots2;
	int _onCurrentPage;
	sqInt _rcvr;
	sqInt _senderOop;
	sqInt _signedValueToStore;
	char *_sp;
	char * _theFP;
	StackPage * _thePage;
	StackPage *_thePage2;
	sqInt _thePC;
	char *_theSP;
	sqInt _totalLength;
	usqLong _unsigned64BitValueToStore;
	unsigned int _unsignedValueToStore;

	/* begin stackTop */
	_newValue = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || ((GIV(argumentCount) > 2) && (((_rcvr & (tagMask())) == 0) && (((long64At(_rcvr)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	if (_rcvr & (tagMask())) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadReceiver;
		return;
		/* end primitiveFailFor: */
	}
	if (
#    if IMMUTABILITY
			(/* begin isImmutable: */ ((((usqInt) (longAt(_rcvr)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#    else /* IMMUTABILITY */
			0
#    endif /* IMMUTABILITY */
			) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrNoModification;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin baseHeader: */
	_hdr = long64At(_rcvr);
	/* end baseHeader: */
	_fmt = (((unsigned sqLong) _hdr ) >> (formatShift())) & (formatMask());
	/* begin lengthOf:format: */
	/* begin numSlotsOfAny: */
	_numSlots2 = byteAt(_rcvr + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOfAny: */
	if (_fmt <= 5) {
		_totalLength = _numSlots;
		goto l8;
	}
	if (_fmt >= (firstByteFormat())) {
		_totalLength = (_numSlots << (shiftForWord())) - (_fmt & 7);
		goto l8;
	}
	if (_fmt >= (firstShortFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 1)) - (_fmt & 3);
		goto l8;
	}
	if (_fmt >= (firstLongFormat())) {
		_totalLength = (_numSlots << ((shiftForWord()) - 2)) - (_fmt & 1);
		goto l8;
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		_totalLength = _numSlots;
		goto l8;
	}
	_totalLength = 0;
	l8:
	;
	/* end lengthOf:format: */
	/* begin fixedFieldsOf:format:length: */
	if ((_fmt >= (sixtyFourBitIndexableFormat())) || (_fmt == 2)) {
		_fixedFields = 0;
		goto l9;
	}
	if (_fmt < 2) {
		_fixedFields = _totalLength;
		goto l9;
	}
	_class = fetchClassOfNonImm(_rcvr);
	/* begin fixedFieldsOfClassFormat: */
	_classFormat = (unsignedLongAt((_class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	_fixedFields = _classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	/* end fixedFieldsOfClassFormat: */
	l9:
	;
	/* end fixedFieldsOf:format:length: */
	if (!((_index >= 1) && (_index <= _fixedFields))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	if ((_fmt == (indexablePointersFormat())) && ((_hdr & (classIndexMask())) == ClassMethodContextCompactIndex)) {
		/* begin instVar:ofContext:put: */
		assert(!(isObjImmutable(_rcvr)));
		/* begin writeBackHeadFramePointers */
		assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
		assert(GIV(stackPage) == (mostRecentlyUsedPage()));
		assert(!(isFree(GIV(stackPage))));
		/* begin setHeadFP:andSP:inPage: */
		_theSP = GIV(stackPointer);
		assert(_theSP < GIV(framePointer));
		assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
		assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
		{
			(GIV(stackPage)->headFP = GIV(framePointer));
			(GIV(stackPage)->headSP = _theSP);
		}
		/* end setHeadFP:andSP:inPage: */
		assert(pageListIsWellFormed());
		/* end writeBackHeadFramePointers */
		if (!(((((unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_rcvr))))) {
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(_rcvr)));
			if (((_rcvr & (tagMask())) == 0) && ((_rcvr & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((_newValue & (tagMask())) == 0) && (((_newValue & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_newValue >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), _rcvr);
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l17;
			}
			if (_newValue & (tagMask())) {
				goto l17;
			}
			if (!(_rcvr >= 0x20000000000LL)) {
				goto l17;
			}
			if (_newValue >= 0x20000000000LL) {
				goto l17;
			}
			if ((_newValue >= GIV(nilObj)) && (_newValue <= GIV(trueObj))) {
				goto l17;
			}
			if (!(_newValue >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l17;
			}
			remember(getFromPermToNewSpaceRememberedSet(), _rcvr);
			l17:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << (shiftForWord())) ), _newValue);
			/* end storePointer:ofObject:withValue: */
			if ((_index - 1) == StackPointerIndex) {
				ensureContextIsExecutionSafeAfterAssignToStackPointer(_rcvr);
			}
			goto l24;
		}
		/* begin frameOfMarriedContext: */
		/* begin fetchPointer:ofObject: */
		_senderOop = unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		{
			assert(((_senderOop & 7) == 1));
			_theFP = pointerForOop(_senderOop - 1);
		}
		/* end frameOfMarriedContext: */
		if ((_index - 1) == SenderIndex) {
			/* begin stackPageFor: */
			/* begin stackPageAt: */
			_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
			/* end stackPageAt: */
			/* end stackPageFor: */
			assert(GIV(stackPage) == (mostRecentlyUsedPage()));
			_onCurrentPage = _thePage == GIV(stackPage);
			storeSenderOfFramewithValue(_theFP, _newValue);
			if (_onCurrentPage) {
				/* begin setStackPointersFromPage: */
				_thePage2 = GIV(stackPage);
				GIV(stackPointer) = (_thePage2->headSP);
				GIV(framePointer) = (_thePage2->headFP);
				/* end setStackPointersFromPage: */
			} else {
				markStackPageMostRecentlyUsed(GIV(stackPage));
			}
			goto l24;
		}
		divorceFrameandContext(_theFP, _rcvr);
		if (((_index - 1) == MethodIndex) && ((((int) ((_thePC = unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )))) ) < 0) && (((_thePC & 7) == 1)))) {
			ensureContextHasBytecodePC(_rcvr);
		}
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_rcvr)));
		if (((_rcvr & (tagMask())) == 0) && ((_rcvr & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_newValue & (tagMask())) == 0) && (((_newValue & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_newValue >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _rcvr);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l23;
		}
		if (_newValue & (tagMask())) {
			goto l23;
		}
		if (!(_rcvr >= 0x20000000000LL)) {
			goto l23;
		}
		if (_newValue >= 0x20000000000LL) {
			goto l23;
		}
		if ((_newValue >= GIV(nilObj)) && (_newValue <= GIV(trueObj))) {
			goto l23;
		}
		if (!(_newValue >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l23;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _rcvr);
		l23:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << (shiftForWord())) ), _newValue);
		/* end storePointer:ofObject:withValue: */
		if ((_index - 1) == StackPointerIndex) {
			ensureContextIsExecutionSafeAfterAssignToStackPointer(_rcvr);
		}
		markStackPageMostRecentlyUsed(GIV(stackPage));
		l24:
		;
		/* end instVar:ofContext:put: */
	} else {
		/* begin subscript:with:storing:format: */
		if (_fmt <= 5) {
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(_rcvr)));
			if (((_rcvr & (tagMask())) == 0) && ((_rcvr & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((_newValue & (tagMask())) == 0) && (((_newValue & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_newValue >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), _rcvr);
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l15;
			}
			if (_newValue & (tagMask())) {
				goto l15;
			}
			if (!(_rcvr >= 0x20000000000LL)) {
				goto l15;
			}
			if (_newValue >= 0x20000000000LL) {
				goto l15;
			}
			if ((_newValue >= GIV(nilObj)) && (_newValue <= GIV(trueObj))) {
				goto l15;
			}
			if (!(_newValue >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l15;
			}
			remember(getFromPermToNewSpaceRememberedSet(), _rcvr);
			l15:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << (shiftForWord())) ), _newValue);
			/* end storePointer:ofObject:withValue: */
			goto l16;
		}
		if (_fmt >= (firstByteFormat())) {
			if (!(((_newValue & 7) == 1))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l16;
			}
			_signedValueToStore = _newValue >> 3;
			if (!((_signedValueToStore >= 0) && (_signedValueToStore <= 0xFF))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l16;
			}
			/* begin storeByte:ofObject:withValue: */
			byteAtput((_rcvr + BaseHeaderSize) + (_index - 1), _signedValueToStore);
			/* end storeByte:ofObject:withValue: */
			goto l16;
		}
		if (_fmt >= (firstShortFormat())) {
			if (!(((_newValue & 7) == 1))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l16;
			}
			_signedValueToStore = _newValue >> 3;
			if (!((_signedValueToStore >= 0) && (_signedValueToStore <= 0xFFFF))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l16;
			}
			/* begin storeShort16:ofObject:withValue: */
			shortAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << 1) ), _signedValueToStore);
			/* end storeShort16:ofObject:withValue: */
			goto l16;
		}
		if (_fmt == (sixtyFourBitIndexableFormat())) {
			_unsigned64BitValueToStore = positive64BitValueOf(_newValue);
			if (!GIV(primFailCode)) {
				/* begin storeLong64:ofObject:withValue: */
				long64Atput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << 3) ), _unsigned64BitValueToStore);
				/* end storeLong64:ofObject:withValue: */
			}
			goto l16;
		}
		_unsignedValueToStore = positive32BitValueOf(_newValue);
		if (!GIV(primFailCode)) {
			/* begin storeLong32:ofObject:withValue: */
			uint32AtPointerput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (_index - 1) ) << 2) ), _unsignedValueToStore);
			/* end storeLong32:ofObject:withValue: */
		}
		l16:
		;
		/* end subscript:with:storing:format: */
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _newValue);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveIsInPermSpace */
static void
primitiveIsInPermSpace(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _rcvr;
	char *_sp;
	sqInt _trueOrFalse;

	/* begin stackTop */
	_rcvr = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin pop:thenPushBool: */
	_trueOrFalse = ((_rcvr & (tagMask())) == 0) && (_rcvr >= 0x20000000000LL);
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((_trueOrFalse)
		 ? GIV(trueObj)
		 : GIV(falseObj)));
	GIV(stackPointer) = _sp;
	/* end pop:thenPushBool: */
}
/* StackInterpreterPrimitives>>#primitiveLoadBoolean8FromBytes */
static void
primitiveLoadBoolean8FromBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l4;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l4:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l6;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l6;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l6;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l6:
	;
	/* end numBytesOf: */
	if ((_index < 0) || (_index >= _byteSize)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	_value = uint8AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	_oop = ((_value != 0)
		 ? GIV(trueObj)
		 : GIV(falseObj));
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadBoolean8FromExternalAddress */
static void
primitiveLoadBoolean8FromExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_value = uint8AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	_oop = ((_value != 0)
		 ? GIV(trueObj)
		 : GIV(falseObj));
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadChar16FromBytes */
static void
primitiveLoadChar16FromBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l4;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l4:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l6;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l6;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l6;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l6:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 1)) || (_byteSize < 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	_value = uint16AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	_oop = ((sqInt) (((usqInt) _value ) << (numTagBits())) ) + (characterTag());
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadChar16FromExternalAddress */
static void
primitiveLoadChar16FromExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_value = uint16AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	_oop = ((sqInt) (((usqInt) _value ) << (numTagBits())) ) + (characterTag());
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadChar32FromBytes */
static void
primitiveLoadChar32FromBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l4;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l4:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l6;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l6;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l6;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l6:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 3)) || (_byteSize < 4))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	_value = uint32AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	_oop = ((sqInt) (((usqInt) _value ) << (numTagBits())) ) + (characterTag());
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadChar32FromExternalAddress */
static void
primitiveLoadChar32FromExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_value = uint32AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	_oop = ((sqInt) (((usqInt) _value ) << (numTagBits())) ) + (characterTag());
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadChar8FromBytes */
static void
primitiveLoadChar8FromBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l4;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l4:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l6;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l6;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l6;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l6:
	;
	/* end numBytesOf: */
	if ((_index < 0) || (_index >= _byteSize)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	_value = uint8AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	_oop = ((sqInt) (((usqInt) _value ) << (numTagBits())) ) + (characterTag());
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadChar8FromExternalAddress */
static void
primitiveLoadChar8FromExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_value = uint8AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	_oop = ((sqInt) (((usqInt) _value ) << (numTagBits())) ) + (characterTag());
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadFloat32FromBytes */
static void
primitiveLoadFloat32FromBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	float _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l4;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l4:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l6;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l6;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l6;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l6:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 3)) || (_byteSize < 4))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	_value = singleFloatAtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	_oop = floatObjectOf(_value);
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadFloat32FromExternalAddress */
static void
primitiveLoadFloat32FromExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	float _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_value = singleFloatAtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	_oop = floatObjectOf(_value);
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadFloat64FromBytes */
static void
primitiveLoadFloat64FromBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _anOop;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	double _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l5;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l5:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l7;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l7;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l7;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l7:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 7)) || (_byteSize < 8))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	/* begin floatAtPointer: */
	_anOop = ((sqInt) (_bytes + _index) );
	_value = float64At(_anOop);
	/* end floatAtPointer: */
	/* begin pop:thenPush: */
	_oop = floatObjectOf(_value);
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadFloat64FromExternalAddress */
static void
primitiveLoadFloat64FromExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _anOop;
	char *_bytes;
	sqInt _index;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	double _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin floatAtPointer: */
	_anOop = ((sqInt) (_bytes + _index) );
	_value = float64At(_anOop);
	/* end floatAtPointer: */
	/* begin pop:thenPush: */
	_oop = floatObjectOf(_value);
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadInt16FromBytes */
static void
primitiveLoadInt16FromBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l4;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l4:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l6;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l6;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l6;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l6:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 1)) || (_byteSize < 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	_value = int16AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _value ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadInt16FromExternalAddress */
static void
primitiveLoadInt16FromExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_value = int16AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _value ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadInt32FromBytes */
static void
primitiveLoadInt32FromBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l4;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l4:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l6;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l6;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l6;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l6:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 3)) || (_byteSize < 4))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	_value = int32AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	/* begin signed32BitIntegerFor: */
	{
		_oop = ((((usqInt) ((int) _value ) ) << 3) | 1);
		goto l7;
	}
	l7:
	;
	/* end signed32BitIntegerFor: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadInt32FromExternalAddress */
static void
primitiveLoadInt32FromExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_value = int32AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	/* begin signed32BitIntegerFor: */
	{
		_oop = ((((usqInt) ((int) _value ) ) << 3) | 1);
		goto l4;
	}
	l4:
	;
	/* end signed32BitIntegerFor: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadInt64FromBytes */
static void
primitiveLoadInt64FromBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	sqLong _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l4;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l4:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l6;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l6;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l6;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l6:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 7)) || (_byteSize < 8))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	_value = int64AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	_oop = signed64BitIntegerFor(_value);
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadInt64FromExternalAddress */
static void
primitiveLoadInt64FromExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	sqLong _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_value = int64AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	_oop = signed64BitIntegerFor(_value);
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadInt8FromBytes */
static void
primitiveLoadInt8FromBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l4;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l4:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l6;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l6;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l6;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l6:
	;
	/* end numBytesOf: */
	if ((_index < 0) || (_index >= _byteSize)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	_value = int8AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _value ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadInt8FromExternalAddress */
static void
primitiveLoadInt8FromExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_value = int8AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _value ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadPointerFromBytes */
static void
primitiveLoadPointerFromBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _classObj;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _object;
	sqInt _rcvr;
	char *_sp;
	char *_value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l4;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l4:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l6;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l6;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l6;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l6:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - (BytesPerWord - 1))) || (_byteSize < BytesPerWord))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	_value = pointerAtPointer(_bytes + _index);
	/* begin instantiateClass:indexableSize: */
	_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ));
	_object = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, BytesPerWord, 0, 0);
	/* end instantiateClass:indexableSize: */
	pointerAtPointerput(firstIndexableField(_object), _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _object);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadPointerFromExternalAddress */
static void
primitiveLoadPointerFromExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _classObj;
	sqInt _index;
	sqInt _object;
	sqInt _rcvr;
	char *_sp;
	char *_value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_value = pointerAtPointer(_bytes + _index);
	/* begin instantiateClass:indexableSize: */
	_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ));
	_object = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, BytesPerWord, 0, 0);
	/* end instantiateClass:indexableSize: */
	pointerAtPointerput(firstIndexableField(_object), _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _object);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Attempt to find the address of a symbol in a loaded library. */
/* StackInterpreterPrimitives>>#primitiveLoadSymbolFromModule */
EXPORT(sqInt)
primitiveLoadSymbolFromModule(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	void *_address;
	sqInt _classObj;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _module;
	void * _moduleHandle;
	char *_moduleNameString;
	sqInt _moduleNameStringSize;
	sqInt _nElements;
	usqInt _numBytes;
	usqInt _numBytes2;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _oop;
	sqInt _oop2;
	void **_ptr;
	char *_sp;
	sqInt _symbol;
	char *_symbolString;
	sqInt _symbolStringSize;

	_moduleHandle = ((void *) 0 );
	if (!(GIV(argumentCount) == 2)) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadNumArgs);
		/* end primitiveFailFor: */
	}
	/* begin stackValue: */
	_module = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_symbol = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (!(((_symbol & (tagMask())) == 0) && (((((usqInt) (longAt(_symbol)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())))) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadArgument);
		/* end primitiveFailFor: */
	}
	if (!(GIV(nilObj) == _module)) {
		if (!((GIV(nilObj) == _module) || (((_module & (tagMask())) == 0) && (((((usqInt) (longAt(_module)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat()))))) {
			/* begin primitiveFailFor: */
			return (GIV(primFailCode) = PrimErrBadArgument);
			/* end primitiveFailFor: */
		}
		/* begin loadModuleByName: */
		_moduleNameString = firstIndexableField(_module);
		/* begin byteSizeOf: */
		if (_module & (tagMask())) {
			_moduleNameStringSize = 0;
			goto l4;
		}
		/* begin numBytesOf: */
		_fmt = (((usqInt) (longAt(_module)) ) >> (formatShift())) & (formatMask());
		/* begin numSlotsOf: */
		assert((classIndexOf(_module)) > (isForwardedObjectClassIndexPun()));
		_numSlots = byteAt(_module + 7);
		_numBytes = ((_numSlots == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_module - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots);
		/* end numSlotsOf: */
		_numBytes = _numBytes << (shiftForWord());
		if (_fmt >= (firstByteFormat())) {
			_moduleNameStringSize = _numBytes - (_fmt & 7);
			goto l4;
		}
		if (_fmt <= (sixtyFourBitIndexableFormat())) {
			_moduleNameStringSize = _numBytes;
			goto l4;
		}
		if (_fmt >= (firstShortFormat())) {
			_moduleNameStringSize = _numBytes - ((sqInt) (((usqInt) (_fmt & 3) ) << 1) );
			goto l4;
		}
		_moduleNameStringSize = _numBytes - ((sqInt) (((usqInt) (_fmt & 1) ) << 2) );
		/* end numBytesOf: */
		l4:
		;
		/* end byteSizeOf: */
		_moduleHandle = ((void *) (ioLoadModuleOfLength(_moduleNameString, _moduleNameStringSize)) );
		/* end loadModuleByName: */
		if (GIV(primFailCode)) {
			return 0;
		}
	}
	_symbolString = firstIndexableField(_symbol);
	/* begin byteSizeOf: */
	if (_symbol & (tagMask())) {
		_symbolStringSize = 0;
		goto l8;
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_symbol)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_symbol)) > (isForwardedObjectClassIndexPun()));
	_numSlots2 = byteAt(_symbol + 7);
	_numBytes2 = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_symbol - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOf: */
	_numBytes2 = _numBytes2 << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_symbolStringSize = _numBytes2 - (_fmt2 & 7);
		goto l8;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_symbolStringSize = _numBytes2;
		goto l8;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_symbolStringSize = _numBytes2 - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l8;
	}
	_symbolStringSize = _numBytes2 - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	/* end numBytesOf: */
	l8:
	;
	/* end byteSizeOf: */
	_address = ioLoadSymbolOfLengthFromModule(_symbolString, _symbolStringSize, _moduleHandle);
	if (_address == 0) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrNotFound);
		/* end primitiveFailFor: */
	}
	/* begin newExternalAddressWithValue: */
	/* begin instantiateClass:indexableSize: */
	_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ));
	_nElements = sizeof(void*);
	_oop2 = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, _nElements, 0, 0);
	/* end instantiateClass:indexableSize: */
	_ptr = ((void **) (firstIndexableField(_oop2)) );
	_ptr[0] = ((sqIntptr_t) _address );
	_oop = _oop2;
	/* end newExternalAddressWithValue: */
	/* begin methodReturnValue: */
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	return 0;
	/* end methodReturnValue: */
}
/* StackInterpreterPrimitives>>#primitiveLoadUInt16FromBytes */
static void
primitiveLoadUInt16FromBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l4;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l4:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l6;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l6;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l6;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l6:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 1)) || (_byteSize < 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	_value = uint16AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _value ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadUInt16FromExternalAddress */
static void
primitiveLoadUInt16FromExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_value = uint16AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _value ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadUInt32FromBytes */
static void
primitiveLoadUInt32FromBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l4;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l4:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l6;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l6;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l6;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l6:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 3)) || (_byteSize < 4))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	_value = uint32AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	/* begin positive32BitIntegerFor: */
	{
		_oop = (((((usqInt) ((unsigned int) _value ) ) & 0xFFFFFFFFU) << 3) | 1);
		goto l7;
	}
	l7:
	;
	/* end positive32BitIntegerFor: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadUInt32FromExternalAddress */
static void
primitiveLoadUInt32FromExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_value = uint32AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	/* begin positive32BitIntegerFor: */
	{
		_oop = (((((usqInt) ((unsigned int) _value ) ) & 0xFFFFFFFFU) << 3) | 1);
		goto l4;
	}
	l4:
	;
	/* end positive32BitIntegerFor: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadUInt64FromBytes */
static void
primitiveLoadUInt64FromBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	usqLong _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l4;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l4:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l6;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l6;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l6;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l6:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 7)) || (_byteSize < 8))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	_value = uint64AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	_oop = positive64BitIntegerFor(_value);
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadUInt64FromExternalAddress */
static void
primitiveLoadUInt64FromExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _oop;
	sqInt _rcvr;
	char *_sp;
	usqLong _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_value = uint64AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	_oop = positive64BitIntegerFor(_value);
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadUInt8FromBytes */
static void
primitiveLoadUInt8FromBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l4;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l4:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l6;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l6;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l6;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l6:
	;
	/* end numBytesOf: */
	if ((_index < 0) || (_index >= _byteSize)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	_value = uint8AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _value ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveLoadUInt8FromExternalAddress */
static void
primitiveLoadUInt8FromExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 1)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_value = uint8AtPointer(_bytes + _index);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _value ) << 3) | 1));
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Primitive. Answer an Array with the current long-running primitive method 
	identified by 
	the heartbeat, the minimum number of milliseconds it was active for, and 
	the milliseconds 
	of GC activity there-in, or nil if none. Since the 
	longRunningPrimitiveCheckMethod is 
	sampled at interrupt time be careful to validate it before returning it. */
/* StackInterpreterPrimitives>>#primitiveLongRunningPrimitive */
EXPORT(sqInt)
primitiveLongRunningPrimitive(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _classObj;
	usqLong _gcms;
	sqInt _lrpcm;
	sqLong _primms;
	sqInt _result;
	char *_sp;

	if (!(GIV(argumentCount) == 0)) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	sqLowLevelMFence();
	if ((GIV(longRunningPrimitiveStopUsecs) > GIV(longRunningPrimitiveStartUsecs)) && ((((_lrpcm = GIV(longRunningPrimitiveCheckMethod))) != null) && ((addressCouldBeObj(_lrpcm)) && ((!(((longAt(_lrpcm)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) && (((((usqInt) (longAt(_lrpcm)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())))))) {
		/* begin instantiateClass:indexableSize: */
		/* begin splObj: */
		/* begin fetchPointer:ofObject: */
		_classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		_result = instantiateClassindexableSizeisPinnedisOldSpace(_classObj, 3, 0, 0);
		/* end instantiateClass:indexableSize: */
		_primms = ((GIV(longRunningPrimitiveStopUsecs) - GIV(longRunningPrimitiveStartUsecs)) + 500) / 1000;
		_gcms = (GIV(longRunningPrimitiveGCUsecs) + 500) / 1000;
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(_result)));
		if (((_result & (tagMask())) == 0) && ((_result & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			if (((_lrpcm & (tagMask())) == 0) && (((_lrpcm & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_lrpcm >= ((GIV(memoryMap)->newSpaceStart))))) {
				/* begin possibleOldObjectStoreInto: */
				if (!(((((usqInt) (long64At(_result)) ) >> (rememberedBitShift())) & 1) != 0)) {
					remember(GIV(fromOldSpaceRememberedSet), _result);
				}
				/* end possibleOldObjectStoreInto: */
			}
		}
		/* begin possiblePermObjectStoreInto:value: */
		if (((((usqInt) (long64At(_result)) ) >> (rememberedBitShift())) & 1) != 0) {
			goto l5;
		}
		if (_lrpcm & (tagMask())) {
			goto l5;
		}
		if (!(_result >= 0x20000000000LL)) {
			goto l5;
		}
		if (_lrpcm >= 0x20000000000LL) {
			goto l5;
		}
		if ((_lrpcm >= GIV(nilObj)) && (_lrpcm <= GIV(trueObj))) {
			goto l5;
		}
		if (!(_lrpcm >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l5;
		}
		remember(getFromPermToNewSpaceRememberedSet(), _result);
		l5:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((_result + BaseHeaderSize) + (0U << (shiftForWord())), _lrpcm);
		/* end storePointer:ofObject:withValue: */
		/* begin storePointerUnchecked:ofObject:withValue: */
		assert(!(isOopForwarded(_result)));
		longAtput((_result + BaseHeaderSize) + (1U << (shiftForWord())), ((((usqInt) _primms ) << 3) | 1));
		/* end storePointerUnchecked:ofObject:withValue: */
		/* begin storePointerUnchecked:ofObject:withValue: */
		assert(!(isOopForwarded(_result)));
		longAtput((_result + BaseHeaderSize) + (2U << (shiftForWord())), ((_gcms << 3) | 1));
		/* end storePointerUnchecked:ofObject:withValue: */
	} else {
		/* begin nilObject */
		_result = GIV(nilObj);
		/* end nilObject */
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), _result);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
	voidLongRunningPrimitive("get");
	return 0;
}
/* StackInterpreterPrimitives>>#primitiveMoveToPermSpace */
static void
primitiveMoveToPermSpace(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _permObject;
	sqInt _rcvr;
	char *_sp;

	/* begin stackTop */
	_rcvr = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	if (_rcvr >= 0x20000000000LL) {
		return;
	}
	_permObject = moveToPermSpace(_rcvr);
	if (GIV(primFailCode)) {
		return;
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _permObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveMoveToPermSpaceAllOldObjects */
static void
primitiveMoveToPermSpaceAllOldObjects(void)
{
	moveToPermSpaceAllOldObjects();
}
/* StackInterpreterPrimitives>>#primitiveMoveToPermSpaceInBulk */
static void
primitiveMoveToPermSpaceInBulk(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _rcvr;
	char *_sp;

	/* begin stackTop */
	_rcvr = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	if (!(((((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask())) == 2)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadReceiver;
		/* end primitiveFailFor: */
		return;
	}
	moveToPermSpaceInBulk(_rcvr);
	if (GIV(primFailCode)) {
		return;
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _rcvr);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	This primitive is assumed to be fast (see e.g. 
	MethodDictionary>>includesKey:) so make it so. 
	N.B. Works forrectly for cogged methods too. */
/* StackInterpreterPrimitives>>#primitiveObjectPointsTo */
static void
primitiveObjectPointsTo(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong _fmt;
	sqLong _header;
	sqInt _header2;
	sqInt _i;
	sqInt _methodHeader;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _rcvr;
	char *_sp;
	char *_sp2;
	char *_sp3;
	char *_sp4;
	char *_sp5;
	char *_sp6;
	sqInt _thang;
	char *_theSP;
	sqInt _trueOrFalse;

	/* begin stackTop */
	_thang = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (_rcvr & (tagMask())) {
		{
			/* begin pop:thenPushBool: */
			unsignedLongAtput((_sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), GIV(falseObj));
			GIV(stackPointer) = _sp;
			/* end pop:thenPushBool: */
			return;
		}
	}
	/* begin baseHeader: */
	_header = long64At(_rcvr);
	/* end baseHeader: */
	_fmt = (((unsigned sqLong) _header ) >> (formatShift())) & (formatMask());
	if (_fmt <= 5) {
		if ((_fmt == (indexablePointersFormat())) && ((_header & (classIndexMask())) == ClassMethodContextCompactIndex)) {
			if ((((unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
				/* begin writeBackHeadFramePointers */
				assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
				assert(GIV(stackPage) == (mostRecentlyUsedPage()));
				assert(!(isFree(GIV(stackPage))));
				/* begin setHeadFP:andSP:inPage: */
				_theSP = GIV(stackPointer);
				assert(_theSP < GIV(framePointer));
				assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
				assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
				{
					(GIV(stackPage)->headFP = GIV(framePointer));
					(GIV(stackPage)->headSP = _theSP);
				}
				/* end setHeadFP:andSP:inPage: */
				assert(pageListIsWellFormed());
				/* end writeBackHeadFramePointers */
				if (((((unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_rcvr)))) {
					{
						/* begin pop:thenPushBool: */
						_trueOrFalse = marriedContextpointsTostackDeltaForCurrentFrame(_rcvr, _thang, 2);
						unsignedLongAtput((_sp2 = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((_trueOrFalse)
							 ? GIV(trueObj)
							 : GIV(falseObj)));
						GIV(stackPointer) = _sp2;
						/* end pop:thenPushBool: */
						return;
					}
				}
			}
			_numSlots = CtxtTempFrameStart + (fetchStackPointerOf(_rcvr));
		} else {
			/* begin numSlotsOf: */
			assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
			_numSlots2 = byteAt(_rcvr + 7);
			_numSlots = ((_numSlots2 == (numSlotsMask()))
				 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
				 : _numSlots2);
			/* end numSlotsOf: */
		}
	} else {
		if (_fmt < (firstCompiledMethodFormat())) {
			{
				/* begin pop:thenPushBool: */
				unsignedLongAtput((_sp3 = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), GIV(falseObj));
				GIV(stackPointer) = _sp3;
				/* end pop:thenPushBool: */
				return;
			}
		}
		/* begin methodHeaderOf: */
		assert(isCompiledMethod(_rcvr));
		/* begin fetchPointer:ofObject: */
		_header2 = unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((_header2 & 7) == 1)) {
			_methodHeader = _header2;
		} else {
			assert(((usqInt) _header2 ) < ((GIV(memoryMap)->newSpaceStart)));
			assert((((((CogMethod *) _header2 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
			_methodHeader = ((((CogMethod *) _header2 ))->methodHeader);
		}
		/* end methodHeaderOf: */
		if (_methodHeader == _thang) {
			{
				/* begin pop:thenPushBool: */
				unsignedLongAtput((_sp4 = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), GIV(trueObj));
				GIV(stackPointer) = _sp4;
				/* end pop:thenPushBool: */
				return;
			}
		}
		_numSlots = ((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) + LiteralStart;
	}
	assert((((_numSlots - 1) * BytesPerOop) + BaseHeaderSize) == (lastPointerOf(_rcvr)));
	for (_i = BaseHeaderSize; _i <= (((_numSlots - 1) * BytesPerOop) + BaseHeaderSize); _i += BytesPerOop) {
		if ((longAt(_rcvr + _i)) == _thang) {
			{
				/* begin pop:thenPushBool: */
				unsignedLongAtput((_sp5 = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), GIV(trueObj));
				GIV(stackPointer) = _sp5;
				/* end pop:thenPushBool: */
				return;
			}
		}
	}
	/* begin pop:thenPushBool: */
	unsignedLongAtput((_sp6 = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), GIV(falseObj));
	GIV(stackPointer) = _sp6;
	/* end pop:thenPushBool: */
}
/* StackInterpreterPrimitives>>#primitivePerform */
static void
primitivePerform(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _i;
	sqInt _inInterpreter;
	sqInt _lookupClassTag;
	sqInt _methodHeader;
	sqInt _nArgs;
	sqInt _newReceiver;
	usqInt _performMethod;
	char *_savedFramePointer;
	char *_savedStackPointer;
	sqInt _succeeded;
	sqInt _tagBits;

	_nArgs = 0;
	_savedFramePointer = ((char *) 0 );
	_savedStackPointer = ((char *) 0 );
	_performMethod = GIV(newMethod);
	/* begin stackValue: */
	GIV(messageSelector) = unsignedLongAt(GIV(stackPointer) + ((GIV(argumentCount) - 1) * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_newReceiver = unsignedLongAt(GIV(stackPointer) + (GIV(argumentCount) * BytesPerWord));
	/* end stackValue: */
	GIV(argumentCount) -= 1;
	for (_i = GIV(argumentCount); _i >= 1; _i += -1) {
		unsignedLongAtput(GIV(stackPointer) + (_i * BytesPerWord), unsignedLongAt(GIV(stackPointer) + ((_i - 1) * BytesPerWord)));
	}
	/* begin pop: */
	GIV(stackPointer) += 1 * BytesPerWord;
	/* end pop: */
	_lookupClassTag = ((((_tagBits = _newReceiver & (tagMask()))) != 0)
		 ? _tagBits
		 : (longAt(_newReceiver)) & (classIndexMask()));
	/* begin sendBreakpoint:receiver: */
	sendBreakpointreceiver(firstFixedFieldOfMaybeImmediate(GIV(messageSelector)), lengthOfMaybeImmediate(GIV(messageSelector)), _newReceiver);
	/* end sendBreakpoint:receiver: */
	if (printOnTrace()) {
		{
			printActivationNameForSelectorstartClass(GIV(messageSelector), classAtIndex(_lookupClassTag));
			/* begin cr */
			print("\n");
			/* end cr */
		}
	}
	findNewMethodInClassTag(_lookupClassTag);
	if (!((((GIV(newMethod) & (tagMask())) == 0) && (((((usqInt) (longAt(GIV(newMethod))) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()))) && ((argumentCountOf(GIV(newMethod))) == GIV(argumentCount)))) {
		/* begin unPop: */
		GIV(stackPointer) -= 1 * BytesPerWord;
		/* end unPop: */
		for (_i = 1; _i <= GIV(argumentCount); _i += 1) {
			unsignedLongAtput(GIV(stackPointer) + ((_i - 1) * BytesPerWord), unsignedLongAt(GIV(stackPointer) + (_i * BytesPerWord)));
		}
		unsignedLongAtput(GIV(stackPointer) + (GIV(argumentCount) * BytesPerWord), GIV(messageSelector));
		GIV(argumentCount) += 1;
		GIV(newMethod) = _performMethod;
		primitiveFunctionPointer = primitivePerform;
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadNumArgs;
			/* end primitiveFailFor: */
			return;
		}
	}
	/* begin executeNewMethod */
	/* begin executeNewMethod: */
	_inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	/* begin executePrimitiveFromInterpreter:ifFail: */
	if (primitiveFunctionPointer != 0) {
		if (((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex) {
			executeQuickPrimitive();
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), _inInterpreter);
			/* end returnToExecutive: */
			goto l11;
		}
		/* begin slowPrimitiveResponse */
		if (recordPrimTrace()) {
			/* begin fastLogPrim: */
			GIV(primTraceLog)[GIV(primTraceLogIndex)] = GIV(messageSelector);
			primTraceLogIndex(GIV(primTraceLogIndex) + 1);
			/* end fastLogPrim: */
		}
		assert((remapBufferCount()) == 0);
		{
			_nArgs = GIV(argumentCount);
			_savedStackPointer = GIV(stackPointer);
			_savedFramePointer = GIV(framePointer);
		}
		/* begin initPrimCall */
		GIV(primFailCode) = 0;
		/* end initPrimCall */
		/* begin dispatchFunctionPointer: */
		primitiveFunctionPointer();
		/* end dispatchFunctionPointer: */
		assert(maybeLeakCheckExternalPrimCall(GIV(newMethod)));
		/* begin maybeRetryPrimitiveOnFailure */
		if (GIV(primFailCode)) {
			retryPrimitiveOnFailure();
		}
		/* end maybeRetryPrimitiveOnFailure */
		/* begin maybeFailForLastObjectOverwrite */
		if (checkAllocFiller) {
			if (((freeStart0()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart0())) != (freeStart0()))) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrWritePastObject;
				/* end primitiveFailFor: */
			}
		}
		/* end maybeFailForLastObjectOverwrite */
		if (!GIV(primFailCode) && ((GIV(framePointer) == _savedFramePointer) && (!(isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))))) {
			if (GIV(stackPointer) != (_savedStackPointer + (_nArgs * BytesPerWord))) {
				flag("Would be nice to make this a message send of e.g. unbalancedPrimitive to the current process or context");
				failUnbalancedPrimitive();
				GIV(stackPointer) = _savedStackPointer;
			}
		}
		if (GIV(nextProfileTick) > 0) {
			checkProfileTick(GIV(newMethod));
		}
		_succeeded = !GIV(primFailCode);
		goto l7;
		l7:
		;
		/* end slowPrimitiveResponse */
		if (_succeeded) {
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), _inInterpreter);
			/* end returnToExecutive: */
			goto l11;
		}
	}
	{
		{
			/* begin fetchPointer:ofObject: */
			_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (!((assert((((_methodHeader & 7) == 1)) || ((((usqInt) _methodHeader ) < (startOfObjectMemory(getMemoryMap()))) && (((usqInt) _methodHeader ) >= (minCogMethodAddress())))), (_methodHeader & (smallIntegerTag())) == 0))) {
				if (((assert(((_methodHeader & 7) == 1)), (_methodHeader >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
					cogselector(GIV(newMethod), GIV(nilObj));
					/* begin fetchPointer:ofObject: */
					_methodHeader = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
				} else {
					maybeFlagMethodAsInterpreted(GIV(newMethod));
				}
			}
		}
		activateNewMethod();
	}
	l11:
	;
	/* end executePrimitiveFromInterpreter:ifFail: */
	/* end executeNewMethod: */
	/* end executeNewMethod */
	/* begin initPrimCall */
	GIV(primFailCode) = 0;
	/* end initPrimCall */
}
/*	Pin or unpin the receiver, i.e. make it immobile or mobile, based on the 
	argument. Answer whether the object was already pinned. N.B. pinning does 
	*not* prevent 
	an object from being garbage collected. */
/* StackInterpreterPrimitives>>#primitivePin */
static void
primitivePin(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _boolean;
	sqInt _obj;
	char *_sp;
	sqInt _wasPinned;

	/* begin stackValue: */
	_obj = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if ((_obj & (tagMask())) || (((long64At(_obj)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadReceiver;
		return;
		/* end primitiveFailFor: */
	}
	/* begin stackTop */
	_boolean = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	if (!((_boolean == GIV(falseObj)) || (_boolean == GIV(trueObj)))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	if (((((usqInt) (longAt(_obj)) ) >> (pinnedBitShift())) & 1) != 0) {
		/* begin trueObject */
		_wasPinned = GIV(trueObj);
		/* end trueObject */
		if (_boolean != _wasPinned) {
			/* begin setIsPinnedOf:to: */
			longAtput(_obj, (longAt(_obj)) & (~((usqIntptr_t) (1U << (pinnedBitShift())) )));
			/* end setIsPinnedOf:to: */
		}
	} else {
		/* begin falseObject */
		_wasPinned = GIV(falseObj);
		/* end falseObject */
		if (_boolean == GIV(trueObj)) {
			if ((((_obj & (tagMask())) == 0) && (((longAt(_obj)) & (classIndexMask())) == ClassMethodContextCompactIndex)) && (((((unsignedLongAt((_obj + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_obj))))) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadReceiver;
				return;
				/* end primitiveFailFor: */
			}
			if ((pinObject(_obj)) == 0) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrNoMemory;
				return;
				/* end primitiveFailFor: */
			}
		}
	}
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _wasPinned);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Because of Slang restrictions, making FFI optional requires cutting the 
	primitive in two different methods. Otherwise slang will unconditionally 
	do all local declarations which may refer to invalid types if FFI is not 
	enabled.  
	Method primitiveSameThreadCallout checks if the feature is available. If 
	so, it calls the actual implementation: doPrimitiveSameThreadCallout. */
/* StackInterpreterPrimitives>>#primitiveSameThreadCallout */
EXPORT(void)
primitiveSameThreadCallout(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	
#  if FEATURE_FFI
	{
		doPrimitiveSameThreadCallout();
	}
#  else /* FEATURE_FFI */
	{
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrUnsupported;
		/* end primitiveFailFor: */
	}
#  endif /* FEATURE_FFI */
}
/*	Primitive. Indicate the semaphore to be signalled for upon garbage 
	collection  */
/* StackInterpreterPrimitives>>#primitiveSetGCSemaphore */
EXPORT(void)
primitiveSetGCSemaphore(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _index;
	sqInt _integerPointer;

	/* begin stackIntegerValue: */
	_integerPointer = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_index = _integerPointer >> 3;
		goto l3;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_index = 0;
		goto l3;
	}
	/* end checkedIntegerValueOf: */
	l3:
	;
	/* end stackIntegerValue: */
	if (!GIV(primFailCode)) {
		GIV(gcSemaphoreIndex) = _index;
		/* begin pop: */
		GIV(stackPointer) += GIV(argumentCount) * BytesPerWord;
		/* end pop: */
	}
}
/*	Cause the time semaphore, if one has been registered, to be 
	signalled when the microsecond clock is greater than or equal to 
	the given tick value. A tick value of zero turns off timer interrupts. */
/* StackInterpreterPrimitives>>#primitiveSignalAtMilliseconds */
static void
primitiveSignalAtMilliseconds(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqLong _deltaMsecs;
	usqInt _msecs;
	sqInt _msecsObj;
	sqInt _sema;

	/* begin stackTop */
	_msecsObj = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_sema = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	_msecs = positive32BitValueOf(_msecsObj);
	if (!GIV(primFailCode)) {
		if (((_sema & (tagMask())) == 0) && (((longAt(_sema)) & (classIndexMask())) == (rawHashBitsOf(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassSemaphore ) << (shiftForWord())) )))))) {
			/* begin splObj:put: */
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(GIV(specialObjectsOop))));
			if (((GIV(specialObjectsOop) & (tagMask())) == 0) && ((GIV(specialObjectsOop) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((_sema & (tagMask())) == 0) && (((_sema & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_sema >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), GIV(specialObjectsOop));
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l8;
			}
			if (_sema & (tagMask())) {
				goto l8;
			}
			if (!(GIV(specialObjectsOop) >= 0x20000000000LL)) {
				goto l8;
			}
			if (_sema >= 0x20000000000LL) {
				goto l8;
			}
			if ((_sema >= GIV(nilObj)) && (_sema <= GIV(trueObj))) {
				goto l8;
			}
			if (!(_sema >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l8;
			}
			remember(getFromPermToNewSpaceRememberedSet(), GIV(specialObjectsOop));
			l8:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) TheTimerSemaphore ) << (shiftForWord())) ), _sema);
			/* end storePointer:ofObject:withValue: */
			/* end splObj:put: */
			_deltaMsecs = _msecs - ((ioMSecs()) & MillisecondClockMask);
			if (_deltaMsecs < 0) {
				_deltaMsecs = (_deltaMsecs + MillisecondClockMask) + 1;
			}
			GIV(nextWakeupUsecs) = (ioUTCMicroseconds()) + (_deltaMsecs * 1000);
			/* begin pop: */
			GIV(stackPointer) += 2 * BytesPerWord;
			return;
			/* end pop: */
		}
		if (_sema == GIV(nilObj)) {
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(GIV(specialObjectsOop))));
			if (((GIV(specialObjectsOop) & (tagMask())) == 0) && ((GIV(specialObjectsOop) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((GIV(nilObj) & (tagMask())) == 0) && (((GIV(nilObj) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (GIV(nilObj) >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), GIV(specialObjectsOop));
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l5;
			}
			if (GIV(nilObj) & (tagMask())) {
				goto l5;
			}
			if (!(GIV(specialObjectsOop) >= 0x20000000000LL)) {
				goto l5;
			}
			if (GIV(nilObj) >= 0x20000000000LL) {
				goto l5;
			}
			if ((GIV(nilObj) >= GIV(nilObj)) && (GIV(nilObj) <= GIV(trueObj))) {
				goto l5;
			}
			if (!(GIV(nilObj) >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l5;
			}
			remember(getFromPermToNewSpaceRememberedSet(), GIV(specialObjectsOop));
			l5:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) TheTimerSemaphore ) << (shiftForWord())) ), GIV(nilObj));
			/* end storePointer:ofObject:withValue: */
			GIV(nextWakeupUsecs) = 0;
			/* begin pop: */
			GIV(stackPointer) += 2 * BytesPerWord;
			return;
			/* end pop: */
		}
	}
	/* begin primitiveFailFor: */
	GIV(primFailCode) = PrimErrBadArgument;
	/* end primitiveFailFor: */
}
/*	Cause the time semaphore, if one has been registered, to be 
	signalled when the microsecond clock is greater than or equal to 
	the given tick value. A tick value of zero turns off timer interrupts. */
/* StackInterpreterPrimitives>>#primitiveSignalAtUTCMicroseconds */
static void
primitiveSignalAtUTCMicroseconds(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _sema;
	usqLong _usecs;
	sqInt _usecsObj;

	/* begin stackTop */
	_usecsObj = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_sema = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	_usecs = positive64BitValueOf(_usecsObj);
	if (!GIV(primFailCode)) {
		if (((_sema & (tagMask())) == 0) && (((longAt(_sema)) & (classIndexMask())) == (rawHashBitsOf(unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassSemaphore ) << (shiftForWord())) )))))) {
			/* begin splObj:put: */
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(GIV(specialObjectsOop))));
			if (((GIV(specialObjectsOop) & (tagMask())) == 0) && ((GIV(specialObjectsOop) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((_sema & (tagMask())) == 0) && (((_sema & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_sema >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), GIV(specialObjectsOop));
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l8;
			}
			if (_sema & (tagMask())) {
				goto l8;
			}
			if (!(GIV(specialObjectsOop) >= 0x20000000000LL)) {
				goto l8;
			}
			if (_sema >= 0x20000000000LL) {
				goto l8;
			}
			if ((_sema >= GIV(nilObj)) && (_sema <= GIV(trueObj))) {
				goto l8;
			}
			if (!(_sema >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l8;
			}
			remember(getFromPermToNewSpaceRememberedSet(), GIV(specialObjectsOop));
			l8:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) TheTimerSemaphore ) << (shiftForWord())) ), _sema);
			/* end storePointer:ofObject:withValue: */
			/* end splObj:put: */
			GIV(nextWakeupUsecs) = _usecs;
			/* begin pop: */
			GIV(stackPointer) += 2 * BytesPerWord;
			return;
			/* end pop: */
		}
		if (_sema == GIV(nilObj)) {
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(GIV(specialObjectsOop))));
			if (((GIV(specialObjectsOop) & (tagMask())) == 0) && ((GIV(specialObjectsOop) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				if (((GIV(nilObj) & (tagMask())) == 0) && (((GIV(nilObj) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (GIV(nilObj) >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), GIV(specialObjectsOop));
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l5;
			}
			if (GIV(nilObj) & (tagMask())) {
				goto l5;
			}
			if (!(GIV(specialObjectsOop) >= 0x20000000000LL)) {
				goto l5;
			}
			if (GIV(nilObj) >= 0x20000000000LL) {
				goto l5;
			}
			if ((GIV(nilObj) >= GIV(nilObj)) && (GIV(nilObj) <= GIV(trueObj))) {
				goto l5;
			}
			if (!(GIV(nilObj) >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l5;
			}
			remember(getFromPermToNewSpaceRememberedSet(), GIV(specialObjectsOop));
			l5:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) TheTimerSemaphore ) << (shiftForWord())) ), GIV(nilObj));
			/* end storePointer:ofObject:withValue: */
			GIV(nextWakeupUsecs) = 0;
			/* begin pop: */
			GIV(stackPointer) += 2 * BytesPerWord;
			return;
			/* end pop: */
		}
	}
	/* begin primitiveFailFor: */
	GIV(primFailCode) = PrimErrBadArgument;
	/* end primitiveFailFor: */
}
/*	Answer a slot in an object. This numbers all slots from 1, ignoring the 
	distinction between 
	named and indexed inst vars. In objects with both named and indexed inst 
	vars, the named 
	inst vars precede the indexed ones. In non-object indexed objects (objects 
	that contain 
	bits, not object references) this primitive answers the raw integral value 
	at each slot.  
	e.g. for Strings it answers the character code, not the Character object 
	at each slot. */
/* StackInterpreterPrimitives>>#primitiveSlotAt */
static void
primitiveSlotAt(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	sqInt _integerVal;
	unsigned int _integerValue;
	sqInt _numLiveSlots;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _oop;
	sqInt _oop2;
	sqInt _rcvr;
	char *_sp;
	char *_sp2;
	char *_sp3;
	char *_sp4;
	char *_sp5;
	char *_theSP;
	sqInt _value;

	/* begin stackTop */
	_index = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	if (!(((_index & 7) == 1))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	if (_rcvr & (tagMask())) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadReceiver;
		return;
		/* end primitiveFailFor: */
	}
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	_index = (_index >> 3) - 1;
	if (_fmt <= 5) {
		/* begin numSlotsOf: */
		assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
		_numSlots2 = byteAt(_rcvr + 7);
		_numSlots = ((_numSlots2 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots2);
		/* end numSlotsOf: */
		if (((usqInt) _index ) < _numSlots) {
			if (((longAt(_rcvr)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
				/* begin writeBackHeadFramePointers */
				assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
				assert(GIV(stackPage) == (mostRecentlyUsedPage()));
				assert(!(isFree(GIV(stackPage))));
				/* begin setHeadFP:andSP:inPage: */
				_theSP = GIV(stackPointer);
				assert(_theSP < GIV(framePointer));
				assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
				assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
				{
					(GIV(stackPage)->headFP = GIV(framePointer));
					(GIV(stackPage)->headSP = _theSP);
				}
				/* end setHeadFP:andSP:inPage: */
				assert(pageListIsWellFormed());
				/* end writeBackHeadFramePointers */
				_numLiveSlots = (stackPointerForMaybeMarriedContext(_rcvr)) + CtxtTempFrameStart;
				if (((usqInt) _index ) < _numLiveSlots) {
					_value = instVarofContext(_index, _rcvr);
				} else {
					/* begin nilObject */
					_value = GIV(nilObj);
					/* end nilObject */
				}
			} else {
				/* begin fetchPointer:ofObject: */
				_value = unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
			}
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _value);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
			return;
		}
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	if (_fmt >= (firstByteFormat())) {
		if (_fmt >= (firstCompiledMethodFormat())) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrUnsupported;
			return;
			/* end primitiveFailFor: */
		}
		/* begin numBytesOfBytes: */
		_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
		assert(_fmt2 >= (firstByteFormat()));
		_numSlots = ((numSlotsOf(_rcvr)) << (shiftForWord())) - (_fmt2 & 7);
		/* end numBytesOfBytes: */
		if (((usqInt) _index ) < _numSlots) {
			/* begin pop:thenPushInteger: */
			unsignedLongAtput((_sp4 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) (byteAt((_rcvr + BaseHeaderSize) + _index)) ) << 3) | 1));
			GIV(stackPointer) = _sp4;
			/* end pop:thenPushInteger: */
			return;
		}
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	if (_fmt >= (firstShortFormat())) {
		_numSlots = ((usqInt) (numBytesOf(_rcvr)) ) >> 1;
		if (((usqInt) _index ) < _numSlots) {
			/* begin pop:thenPushInteger: */
			_integerVal = ((unsigned short) (shortAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << 1) ))) );
			unsignedLongAtput((_sp5 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) _integerVal ) << 3) | 1));
			GIV(stackPointer) = _sp5;
			/* end pop:thenPushInteger: */
			return;
		}
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		_numSlots = ((usqInt) (numBytesOf(_rcvr)) ) >> 3;
		if (((usqInt) _index ) < _numSlots) {
			/* begin pop:thenPush: */
			_oop = positive64BitIntegerFor(long64At((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << 3) )));
			unsignedLongAtput((_sp2 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
			GIV(stackPointer) = _sp2;
			/* end pop:thenPush: */
			return;
		}
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	if (_fmt >= (firstLongFormat())) {
		_numSlots = ((usqInt) (numBytesOf(_rcvr)) ) >> 2;
		if (((usqInt) _index ) < _numSlots) {
			/* begin pop:thenPush: */
			/* begin positive32BitIntegerFor: */
			_integerValue = long32At((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << 2) ));
			{
				_oop2 = (((((usqInt) _integerValue ) & 0xFFFFFFFFU) << 3) | 1);
				goto l8;
			}
			l8:
			;
			/* end positive32BitIntegerFor: */
			unsignedLongAtput((_sp3 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop2);
			GIV(stackPointer) = _sp3;
			/* end pop:thenPush: */
			return;
		}
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	/* begin primitiveFailFor: */
	GIV(primFailCode) = PrimErrBadReceiver;
	return;
	/* end primitiveFailFor: */
}
/*	Assign a slot in an object. This numbers all slots from 1, ignoring the 
	distinction between 
	named and indexed inst vars. In objects with both named and indexed inst 
	vars, the named 
	inst vars precede the indexed ones. In non-object indexed objects (objects 
	that contain 
	bits, not object references) this primitive assigns a raw integral value 
	at each slot. */
/* StackInterpreterPrimitives>>#primitiveSlotAtPut */
static void
primitiveSlotAtPut(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _bs;
	sqInt _ccIndex;
	sqInt _classOop;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _fmt3;
	sqInt _index;
	sqInt _newValue;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _ok;
	int _onCurrentPage;
	sqInt _rcvr;
	sqInt _senderOop;
	char *_sp;
	char *_sp2;
	char *_sp3;
	char *_sp4;
	char *_sp5;
	char * _theFP;
	StackPage * _thePage;
	StackPage *_thePage2;
	sqInt _thePC;
	char *_theSP;
	usqIntptr_t _value;
	sqInt _value2;

	/* begin stackTop */
	_newValue = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (!(((_index & 7) == 1))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	if (_rcvr & (tagMask())) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadReceiver;
		return;
		/* end primitiveFailFor: */
	}
	if (
#    if IMMUTABILITY
			(/* begin isImmutable: */ ((((usqInt) (longAt(_rcvr)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#    else /* IMMUTABILITY */
			0
#    endif /* IMMUTABILITY */
			) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrNoModification;
		return;
		/* end primitiveFailFor: */
	}
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	_index = (_index >> 3) - 1;
	if (_fmt <= 5) {
		/* begin numSlotsOf: */
		assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
		_numSlots2 = byteAt(_rcvr + 7);
		_numSlots = ((_numSlots2 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : _numSlots2);
		/* end numSlotsOf: */
		if (((usqInt) _index ) < _numSlots) {
			if (((longAt(_rcvr)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
				/* begin instVar:ofContext:put: */
				assert(!(isObjImmutable(_rcvr)));
				/* begin writeBackHeadFramePointers */
				assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
				assert(GIV(stackPage) == (mostRecentlyUsedPage()));
				assert(!(isFree(GIV(stackPage))));
				/* begin setHeadFP:andSP:inPage: */
				_theSP = GIV(stackPointer);
				assert(_theSP < GIV(framePointer));
				assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
				assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
				{
					(GIV(stackPage)->headFP = GIV(framePointer));
					(GIV(stackPage)->headSP = _theSP);
				}
				/* end setHeadFP:andSP:inPage: */
				assert(pageListIsWellFormed());
				/* end writeBackHeadFramePointers */
				if (!(((((unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_rcvr))))) {
					/* begin storePointer:ofObject:withValue: */
					assert(!(isForwarded(_rcvr)));
					if (((_rcvr & (tagMask())) == 0) && ((_rcvr & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
						if (((_newValue & (tagMask())) == 0) && (((_newValue & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_newValue >= ((GIV(memoryMap)->newSpaceStart))))) {
							/* begin possibleOldObjectStoreInto: */
							if (!(((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0)) {
								remember(GIV(fromOldSpaceRememberedSet), _rcvr);
							}
							/* end possibleOldObjectStoreInto: */
						}
					}
					/* begin possiblePermObjectStoreInto:value: */
					if (((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0) {
						goto l18;
					}
					if (_newValue & (tagMask())) {
						goto l18;
					}
					if (!(_rcvr >= 0x20000000000LL)) {
						goto l18;
					}
					if (_newValue >= 0x20000000000LL) {
						goto l18;
					}
					if ((_newValue >= GIV(nilObj)) && (_newValue <= GIV(trueObj))) {
						goto l18;
					}
					if (!(_newValue >= (startOfObjectMemory(GIV(memoryMap))))) {
						goto l18;
					}
					remember(getFromPermToNewSpaceRememberedSet(), _rcvr);
					l18:
					;
					/* end possiblePermObjectStoreInto:value: */
					unsignedLongAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ), _newValue);
					/* end storePointer:ofObject:withValue: */
					if (_index == StackPointerIndex) {
						ensureContextIsExecutionSafeAfterAssignToStackPointer(_rcvr);
					}
					goto l25;
				}
				/* begin frameOfMarriedContext: */
				/* begin fetchPointer:ofObject: */
				_senderOop = unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				{
					assert(((_senderOop & 7) == 1));
					_theFP = pointerForOop(_senderOop - 1);
				}
				/* end frameOfMarriedContext: */
				if (_index == SenderIndex) {
					/* begin stackPageFor: */
					/* begin stackPageAt: */
					_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
					/* end stackPageAt: */
					/* end stackPageFor: */
					assert(GIV(stackPage) == (mostRecentlyUsedPage()));
					_onCurrentPage = _thePage == GIV(stackPage);
					storeSenderOfFramewithValue(_theFP, _newValue);
					if (_onCurrentPage) {
						/* begin setStackPointersFromPage: */
						_thePage2 = GIV(stackPage);
						GIV(stackPointer) = (_thePage2->headSP);
						GIV(framePointer) = (_thePage2->headFP);
						/* end setStackPointersFromPage: */
					} else {
						markStackPageMostRecentlyUsed(GIV(stackPage));
					}
					goto l25;
				}
				divorceFrameandContext(_theFP, _rcvr);
				if ((_index == MethodIndex) && ((((int) ((_thePC = unsignedLongAt((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )))) ) < 0) && (((_thePC & 7) == 1)))) {
					ensureContextHasBytecodePC(_rcvr);
				}
				/* begin storePointer:ofObject:withValue: */
				assert(!(isForwarded(_rcvr)));
				if (((_rcvr & (tagMask())) == 0) && ((_rcvr & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
					if (((_newValue & (tagMask())) == 0) && (((_newValue & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_newValue >= ((GIV(memoryMap)->newSpaceStart))))) {
						/* begin possibleOldObjectStoreInto: */
						if (!(((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0)) {
							remember(GIV(fromOldSpaceRememberedSet), _rcvr);
						}
						/* end possibleOldObjectStoreInto: */
					}
				}
				/* begin possiblePermObjectStoreInto:value: */
				if (((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0) {
					goto l24;
				}
				if (_newValue & (tagMask())) {
					goto l24;
				}
				if (!(_rcvr >= 0x20000000000LL)) {
					goto l24;
				}
				if (_newValue >= 0x20000000000LL) {
					goto l24;
				}
				if ((_newValue >= GIV(nilObj)) && (_newValue <= GIV(trueObj))) {
					goto l24;
				}
				if (!(_newValue >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l24;
				}
				remember(getFromPermToNewSpaceRememberedSet(), _rcvr);
				l24:
				;
				/* end possiblePermObjectStoreInto:value: */
				unsignedLongAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ), _newValue);
				/* end storePointer:ofObject:withValue: */
				if (_index == StackPointerIndex) {
					ensureContextIsExecutionSafeAfterAssignToStackPointer(_rcvr);
				}
				markStackPageMostRecentlyUsed(GIV(stackPage));
				l25:
				;
				/* end instVar:ofContext:put: */
			} else {
				/* begin storePointer:ofObject:withValue: */
				assert(!(isForwarded(_rcvr)));
				if (((_rcvr & (tagMask())) == 0) && ((_rcvr & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
					if (((_newValue & (tagMask())) == 0) && (((_newValue & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_newValue >= ((GIV(memoryMap)->newSpaceStart))))) {
						/* begin possibleOldObjectStoreInto: */
						if (!(((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0)) {
							remember(GIV(fromOldSpaceRememberedSet), _rcvr);
						}
						/* end possibleOldObjectStoreInto: */
					}
				}
				/* begin possiblePermObjectStoreInto:value: */
				if (((((usqInt) (long64At(_rcvr)) ) >> (rememberedBitShift())) & 1) != 0) {
					goto l11;
				}
				if (_newValue & (tagMask())) {
					goto l11;
				}
				if (!(_rcvr >= 0x20000000000LL)) {
					goto l11;
				}
				if (_newValue >= 0x20000000000LL) {
					goto l11;
				}
				if ((_newValue >= GIV(nilObj)) && (_newValue <= GIV(trueObj))) {
					goto l11;
				}
				if (!(_newValue >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l11;
				}
				remember(getFromPermToNewSpaceRememberedSet(), _rcvr);
				l11:
				;
				/* end possiblePermObjectStoreInto:value: */
				unsignedLongAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << (shiftForWord())) ), _newValue);
				/* end storePointer:ofObject:withValue: */
			}
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _newValue);
			GIV(stackPointer) = _sp;
			/* end pop:thenPush: */
			return;
		}
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	/* begin positiveMachineIntegerValueOf: */
	if (((_newValue & 7) == 1)) {
		_value2 = _newValue >> 3;
		if (_value2 < 0) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			_value = null;
			goto l17;
			/* end primitiveFail */
		}
		_value = _value2;
		goto l17;
	}
	if (_newValue & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_value = 0;
		goto l17;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	_classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(_newValue)));
	/* begin classIndexOf: */
	_ccIndex = (longAt(_newValue)) & (classIndexMask());
	/* end classIndexOf: */
	{
		_ok = ClassLargePositiveIntegerCompactIndex == _ccIndex;
		goto l14;
	}
	l14:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (!_ok) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_value = 0;
		goto l17;
	}
	/* begin numBytesOfBytes: */
	_fmt3 = (((usqInt) (longAt(_newValue)) ) >> (formatShift())) & (formatMask());
	assert(_fmt3 >= (firstByteFormat()));
	_bs = ((numSlotsOf(_newValue)) << (shiftForWord())) - (_fmt3 & 7);
	/* end numBytesOfBytes: */
	if (_bs > (sizeof(usqIntptr_t))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_value = 0;
		goto l17;
	}
	if (((sizeof(usqIntptr_t)) == 8) && (_bs > 4)) {
		_value = SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((_newValue + BaseHeaderSize) + (0U << 3)));
		goto l17;
	} else {
		_value = ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((_newValue + BaseHeaderSize) + (0U << 2)))) );
		goto l17;
	}
	l17:
	;
	/* end positiveMachineIntegerValueOf: */
	if (GIV(primFailCode)) {
		GIV(primFailCode) = PrimErrBadArgument;
		return;
	}
	if (_fmt >= (firstByteFormat())) {
		if (_fmt >= (firstCompiledMethodFormat())) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrUnsupported;
			return;
			/* end primitiveFailFor: */
		}
		if (((usqInt) _value ) > 0xFF) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			return;
			/* end primitiveFailFor: */
		}
		/* begin numBytesOfBytes: */
		_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
		assert(_fmt2 >= (firstByteFormat()));
		_numSlots = ((numSlotsOf(_rcvr)) << (shiftForWord())) - (_fmt2 & 7);
		/* end numBytesOfBytes: */
		if (((usqInt) _index ) < _numSlots) {
			/* begin storeByte:ofObject:withValue: */
			byteAtput((_rcvr + BaseHeaderSize) + _index, _value);
			/* end storeByte:ofObject:withValue: */
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp2 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _newValue);
			GIV(stackPointer) = _sp2;
			/* end pop:thenPush: */
			return;
		}
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	if (_fmt >= (firstShortFormat())) {
		if (((usqInt) _value ) > 0xFFFF) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			return;
			/* end primitiveFailFor: */
		}
		_numSlots = ((usqInt) (numBytesOf(_rcvr)) ) >> 1;
		if (((usqInt) _index ) < _numSlots) {
			/* begin storeShort16:ofObject:withValue: */
			shortAtput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << 1) ), _value);
			/* end storeShort16:ofObject:withValue: */
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp3 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _newValue);
			GIV(stackPointer) = _sp3;
			/* end pop:thenPush: */
			return;
		}
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	if (_fmt == (sixtyFourBitIndexableFormat())) {
		_numSlots = ((usqInt) (numBytesOf(_rcvr)) ) >> 3;
		if (((usqInt) _index ) < _numSlots) {
			/* begin storeLong64:ofObject:withValue: */
			long64Atput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << 3) ), _value);
			/* end storeLong64:ofObject:withValue: */
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp4 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _newValue);
			GIV(stackPointer) = _sp4;
			/* end pop:thenPush: */
			return;
		}
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	if (_fmt >= (firstLongFormat())) {
		if (((usqInt) _value ) > 0xFFFFFFFFU) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			return;
			/* end primitiveFailFor: */
		}
		_numSlots = ((usqInt) (numBytesOf(_rcvr)) ) >> 2;
		if (((usqInt) _index ) < _numSlots) {
			/* begin storeLong32:ofObject:withValue: */
			uint32AtPointerput((_rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) _index ) << 2) ), _value);
			/* end storeLong32:ofObject:withValue: */
			/* begin pop:thenPush: */
			unsignedLongAtput((_sp5 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _newValue);
			GIV(stackPointer) = _sp5;
			/* end pop:thenPush: */
			return;
		}
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	/* begin primitiveFailFor: */
	GIV(primFailCode) = PrimErrBadReceiver;
	return;
	/* end primitiveFailFor: */
}
/* StackInterpreterPrimitives>>#primitiveStoreBoolean8IntoBytes */
static void
primitiveStoreBoolean8IntoBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	int _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	_value = 0;
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l5;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l5:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	if (_valueObject == GIV(trueObj)) {
		_value = 1;
	} else {
		if (_valueObject == GIV(falseObj)) {
			_value = 0;
		} else {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			return;
			/* end primitiveFailFor: */
		}
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l7;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l7;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l7;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l7:
	;
	/* end numBytesOf: */
	if ((_index < 0) || (_index >= _byteSize)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	uint8AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreBoolean8IntoExternalAddress */
static void
primitiveStoreBoolean8IntoExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	int _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	_value = 0;
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	if (_valueObject == GIV(trueObj)) {
		_value = 1;
	} else {
		if (_valueObject == GIV(falseObj)) {
			_value = 0;
		} else {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			return;
			/* end primitiveFailFor: */
		}
	}
	uint8AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreChar16IntoBytes */
static void
primitiveStoreChar16IntoBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	usqInt _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || ((!(_valueObject & (characterTag()))) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin characterValueOf: */
	_value = ((usqInt) ((usqInt) _valueObject ) ) >> (numTagBits());
	/* end characterValueOf: */
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l6;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l6:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l8;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l8;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l8;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l8:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 1)) || (_byteSize < 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	uint16AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreChar16IntoExternalAddress */
static void
primitiveStoreChar16IntoExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	usqInt _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || ((!(_valueObject & (characterTag()))) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin characterValueOf: */
	_value = ((usqInt) ((usqInt) _valueObject ) ) >> (numTagBits());
	/* end characterValueOf: */
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	uint16AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreChar32IntoBytes */
static void
primitiveStoreChar32IntoBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	usqInt _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || ((!(_valueObject & (characterTag()))) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin characterValueOf: */
	_value = ((usqInt) ((usqInt) _valueObject ) ) >> (numTagBits());
	/* end characterValueOf: */
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l6;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l6:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l8;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l8;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l8;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l8:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 3)) || (_byteSize < 4))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	uint32AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreChar32IntoExternalAddress */
static void
primitiveStoreChar32IntoExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	usqInt _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || ((!(_valueObject & (characterTag()))) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin characterValueOf: */
	_value = ((usqInt) ((usqInt) _valueObject ) ) >> (numTagBits());
	/* end characterValueOf: */
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	uint32AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreChar8IntoBytes */
static void
primitiveStoreChar8IntoBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	usqInt _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || ((!(_valueObject & (characterTag()))) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin characterValueOf: */
	_value = ((usqInt) ((usqInt) _valueObject ) ) >> (numTagBits());
	/* end characterValueOf: */
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l6;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l6:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l8;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l8;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l8;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l8:
	;
	/* end numBytesOf: */
	if ((_index < 0) || (_index >= _byteSize)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	uint8AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreChar8IntoExternalAddress */
static void
primitiveStoreChar8IntoExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	usqInt _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || ((!(_valueObject & (characterTag()))) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin characterValueOf: */
	_value = ((usqInt) ((usqInt) _valueObject ) ) >> (numTagBits());
	/* end characterValueOf: */
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	uint8AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreFloat32IntoBytes */
static void
primitiveStoreFloat32IntoBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	sqInt _tagBits;
	double _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || ((!(((((_tagBits = _valueObject & (tagMask()))) != 0)
		 ? _tagBits == (smallFloatTag())
		 : ((longAt(_valueObject)) & (classIndexMask())) == ClassFloatCompactIndex))) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = floatValueOf(_valueObject);
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l5;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l5:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l7;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l7;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l7;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l7:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 3)) || (_byteSize < 4))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	singleFloatAtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreFloat32IntoExternalAddress */
static void
primitiveStoreFloat32IntoExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	sqInt _tagBits;
	double _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || ((!(((((_tagBits = _valueObject & (tagMask()))) != 0)
		 ? _tagBits == (smallFloatTag())
		 : ((longAt(_valueObject)) & (classIndexMask())) == ClassFloatCompactIndex))) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = floatValueOf(_valueObject);
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	singleFloatAtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreFloat64IntoBytes */
static void
primitiveStoreFloat64IntoBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _anOop;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	sqInt _tagBits;
	double _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || ((!(((((_tagBits = _valueObject & (tagMask()))) != 0)
		 ? _tagBits == (smallFloatTag())
		 : ((longAt(_valueObject)) & (classIndexMask())) == ClassFloatCompactIndex))) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = floatValueOf(_valueObject);
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l5;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l5:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l7;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l7;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l7;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l7:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 7)) || (_byteSize < 8))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	/* begin floatAtPointer:put: */
	_anOop = ((sqInt) (_bytes + _index) );
	float64Atput(_anOop, _value);
	/* end floatAtPointer:put: */
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreFloat64IntoExternalAddress */
static void
primitiveStoreFloat64IntoExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _anOop;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	sqInt _tagBits;
	double _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || ((!(((((_tagBits = _valueObject & (tagMask()))) != 0)
		 ? _tagBits == (smallFloatTag())
		 : ((longAt(_valueObject)) & (classIndexMask())) == ClassFloatCompactIndex))) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = floatValueOf(_valueObject);
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin floatAtPointer:put: */
	_anOop = ((sqInt) (_bytes + _index) );
	float64Atput(_anOop, _value);
	/* end floatAtPointer:put: */
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreInt16IntoBytes */
static void
primitiveStoreInt16IntoBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (((_valueObject & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = _valueObject >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l5;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l5:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l7;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l7;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l7;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l7:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 1)) || (_byteSize < 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	int16AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreInt16IntoExternalAddress */
static void
primitiveStoreInt16IntoExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (((_valueObject & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = _valueObject >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	int16AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreInt32IntoBytes */
static void
primitiveStoreInt32IntoBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	int _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (((_valueObject & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = signed32BitValueOf(_valueObject);
	if (GIV(primFailCode)) {
		return;
	}
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l5;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l5:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l7;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l7;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l7;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l7:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 3)) || (_byteSize < 4))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	int32AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreInt32IntoExternalAddress */
static void
primitiveStoreInt32IntoExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	int _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (((_valueObject & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = signed32BitValueOf(_valueObject);
	if (GIV(primFailCode)) {
		return;
	}
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	int32AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreInt64IntoBytes */
static void
primitiveStoreInt64IntoBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	sqLong _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (((_valueObject & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = signed64BitValueOf(_valueObject);
	if (GIV(primFailCode)) {
		return;
	}
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l5;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l5:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l7;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l7;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l7;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l7:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 7)) || (_byteSize < 8))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	int64AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreInt64IntoExternalAddress */
static void
primitiveStoreInt64IntoExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	sqLong _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (((_valueObject & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = signed64BitValueOf(_valueObject);
	if (GIV(primFailCode)) {
		return;
	}
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	int64AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreInt8IntoBytes */
static void
primitiveStoreInt8IntoBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (((_valueObject & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = _valueObject >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l5;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l5:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l7;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l7;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l7;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l7:
	;
	/* end numBytesOf: */
	if ((_index < 0) || (_index >= _byteSize)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	int8AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreInt8IntoExternalAddress */
static void
primitiveStoreInt8IntoExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (((_valueObject & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = _valueObject >> 3;
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	int8AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStorePointerIntoBytes */
static void
primitiveStorePointerIntoBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _fmt3;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	char *_valueBytes;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_valueObject)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_valueBytes = ((void *) 0 );
		goto l5;
	}
	/* begin firstFixedField: */
	_valueBytes = ((void *) (pointerForOop(_valueObject + BaseHeaderSize)) );
	/* end firstFixedField: */
	l5:
	;
	/* end firstBytePointerOfDataObject: */
	if (_valueBytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin firstBytePointerOfDataObject: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt2 < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l6;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l6:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt3 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt3 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt3 & 7);
		goto l8;
	}
	if (_fmt3 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l8;
	}
	if (_fmt3 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt3 & 3) ) << 1) );
		goto l8;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt3 & 1) ) << 2) );
	l8:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - (BytesPerWord - 1))) || (_byteSize < BytesPerWord))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	pointerAtPointerput(_bytes + _index, pointerAtPointer(_valueBytes));
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStorePointerIntoExternalAddress */
static void
primitiveStorePointerIntoExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _fmt;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	char *_valueBytes;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_valueObject)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_valueBytes = ((void *) 0 );
		goto l5;
	}
	/* begin firstFixedField: */
	_valueBytes = ((void *) (pointerForOop(_valueObject + BaseHeaderSize)) );
	/* end firstFixedField: */
	l5:
	;
	/* end firstBytePointerOfDataObject: */
	if (_valueBytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	pointerAtPointerput(_bytes + _index, pointerAtPointer(_valueBytes));
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Atomic store into context stackPointer.  
	Also ensures that any newly accessible cells are initialized to nil */
/* StackInterpreterPrimitives>>#primitiveStoreStackp */
static void
primitiveStoreStackp(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _ctxt;
	sqInt _i;
	sqInt _integerPointer;
	sqInt _newStackp;
	int _onCurrentPage;
	sqInt _senderOop;
	sqInt _sp;
	sqInt _stackp;
	char *_theFP;
	StackPage *_thePage;
	StackPage *_thePage2;
	char *_theSP;
	sqInt _valuePointer;

	/* begin stackValue: */
	_ctxt = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackIntegerValue: */
	_integerPointer = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((_integerPointer & 7) == 1)) {
		_newStackp = _integerPointer >> 3;
		goto l7;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		_newStackp = 0;
		goto l7;
	}
	/* end checkedIntegerValueOf: */
	l7:
	;
	/* end stackIntegerValue: */
	if (!(!GIV(primFailCode) && ((_newStackp >= 0) && (_newStackp <= ((numSlotsOf(_ctxt)) - CtxtTempFrameStart))))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return;
		/* end primitiveFail */
	}
	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	_theSP = GIV(stackPointer);
	assert(_theSP < GIV(framePointer));
	assert((_theSP < ((GIV(stackPage)->baseAddress))) && (_theSP > (((GIV(stackPage)->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((GIV(framePointer) < ((GIV(stackPage)->baseAddress))) && (GIV(framePointer) > (((GIV(stackPage)->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(GIV(stackPage)->headFP = GIV(framePointer));
		(GIV(stackPage)->headSP = _theSP);
	}
	/* end setHeadFP:andSP:inPage: */
	assert(pageListIsWellFormed());
	/* end writeBackHeadFramePointers */
	if (((((unsignedLongAt((_ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(_ctxt)))) {
		/* begin frameOfMarriedContext: */
		/* begin fetchPointer:ofObject: */
		_senderOop = unsignedLongAt((_ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		{
			assert(((_senderOop & 7) == 1));
			_theFP = pointerForOop(_senderOop - 1);
		}
		/* end frameOfMarriedContext: */
		/* begin stackPageFor: */
		/* begin stackPageAt: */
		_thePage = stackPageAtpages((assert((((char *) _theFP ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _theFP ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_theFP, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
		/* end stackPageAt: */
		/* end stackPageFor: */
		if (((_onCurrentPage = _thePage == GIV(stackPage))) && (_theFP == GIV(framePointer))) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			return;
			/* end primitiveFail */
		}
		divorceFrameandContext(_theFP, _ctxt);
		if (_onCurrentPage) {
			/* begin setStackPointersFromPage: */
			_thePage2 = GIV(stackPage);
			GIV(stackPointer) = (_thePage2->headSP);
			GIV(framePointer) = (_thePage2->headFP);
			/* end setStackPointersFromPage: */
		} else {
			assert(GIV(stackPage) == (stackPageFor(GIV(framePointer))));
			markStackPageMostRecentlyUsed(GIV(stackPage));
		}
	}
	/* begin fetchStackPointerOf: */
	/* begin fetchPointer:ofObject: */
	_sp = unsignedLongAt((_ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (!(((_sp & 7) == 1))) {
		_stackp = 0;
		goto l9;
	}
	assert((ReceiverIndex + (_sp >> 3)) < (lengthOf(_ctxt)));
	_stackp = _sp >> 3;
	l9:
	;
	/* end fetchStackPointerOf: */
	for (_i = _stackp + 1; _i <= _newStackp; _i += 1) {
		/* begin storePointerUnchecked:ofObject:withValue: */
		_valuePointer = GIV(nilObj);
		assert(!(isOopForwarded(_ctxt)));
		longAtput((_ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) ((_i + CtxtTempFrameStart) - 1) ) << (shiftForWord())) ), _valuePointer);
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	/* begin storeStackPointerValue:inContext: */
	assert((ReceiverIndex + _newStackp) < (lengthOf(_ctxt)));
	/* begin storePointerUnchecked:ofObject:withValue: */
	assert(!(isOopForwarded(_ctxt)));
	longAtput((_ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ), ((((usqInt) _newStackp ) << 3) | 1));
	/* end storePointerUnchecked:ofObject:withValue: */
	/* end storeStackPointerValue:inContext: */
	ensureContextIsExecutionSafeAfterAssignToStackPointer(_ctxt);
	/* begin pop: */
	GIV(stackPointer) += 1 * BytesPerWord;
	/* end pop: */
}
/* StackInterpreterPrimitives>>#primitiveStoreUInt16IntoBytes */
static void
primitiveStoreUInt16IntoBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (((_valueObject & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = _valueObject >> 3;
	if (_value < 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l5;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l5:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l7;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l7;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l7;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l7:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 1)) || (_byteSize < 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	uint16AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreUInt16IntoExternalAddress */
static void
primitiveStoreUInt16IntoExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (((_valueObject & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = _valueObject >> 3;
	if (_value < 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	uint16AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreUInt32IntoBytes */
static void
primitiveStoreUInt32IntoBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	unsigned int _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (((_valueObject & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = positive32BitValueOf(_valueObject);
	if (GIV(primFailCode)) {
		return;
	}
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l5;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l5:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l7;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l7;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l7;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l7:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 3)) || (_byteSize < 4))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	uint32AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreUInt32IntoExternalAddress */
static void
primitiveStoreUInt32IntoExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	unsigned int _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (((_valueObject & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = positive32BitValueOf(_valueObject);
	if (GIV(primFailCode)) {
		return;
	}
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	uint32AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreUInt64IntoBytes */
static void
primitiveStoreUInt64IntoBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	usqLong _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (((_valueObject & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = positive64BitValueOf(_valueObject);
	if (GIV(primFailCode)) {
		return;
	}
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l5;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l5:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l7;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l7;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l7;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l7:
	;
	/* end numBytesOf: */
	if ((_index < 0) || ((_index >= (_byteSize - 7)) || (_byteSize < 8))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	uint64AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreUInt64IntoExternalAddress */
static void
primitiveStoreUInt64IntoExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	usqLong _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (((_valueObject & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = positive64BitValueOf(_valueObject);
	if (GIV(primFailCode)) {
		return;
	}
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	uint64AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreUInt8IntoBytes */
static void
primitiveStoreUInt8IntoBytes(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _byteSize;
	char *_bytes;
	sqInt _fmt;
	sqInt _fmt2;
	sqInt _index;
	usqInt _numBytes;
	usqInt _numSlots;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (((_valueObject & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = _valueObject >> 3;
	if (_value < 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin firstBytePointerOfDataObject: */
	_fmt = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	if (_fmt < (sixtyFourBitIndexableFormat())) {
		_bytes = ((void *) 0 );
		goto l5;
	}
	/* begin firstFixedField: */
	_bytes = ((void *) (pointerForOop(_rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l5:
	;
	/* end firstBytePointerOfDataObject: */
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	/* begin numBytesOf: */
	_fmt2 = (((usqInt) (longAt(_rcvr)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(_rcvr)) > (isForwardedObjectClassIndexPun()));
	_numSlots = byteAt(_rcvr + 7);
	_numBytes = ((_numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_rcvr - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots);
	/* end numSlotsOf: */
	_numBytes = _numBytes << (shiftForWord());
	if (_fmt2 >= (firstByteFormat())) {
		_byteSize = _numBytes - (_fmt2 & 7);
		goto l7;
	}
	if (_fmt2 <= (sixtyFourBitIndexableFormat())) {
		_byteSize = _numBytes;
		goto l7;
	}
	if (_fmt2 >= (firstShortFormat())) {
		_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 3) ) << 1) );
		goto l7;
	}
	_byteSize = _numBytes - ((sqInt) (((usqInt) (_fmt2 & 1) ) << 2) );
	l7:
	;
	/* end numBytesOf: */
	if ((_index < 0) || (_index >= _byteSize)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	uint8AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/* StackInterpreterPrimitives>>#primitiveStoreUInt8IntoExternalAddress */
static void
primitiveStoreUInt8IntoExternalAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *_bytes;
	sqInt _index;
	sqInt _rcvr;
	char *_sp;
	sqInt _value;
	sqInt _valueObject;

	/* begin stackTop */
	_valueObject = unsignedLongAt(GIV(stackPointer));
	/* end stackTop */
	/* begin stackValue: */
	_index = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* end stackValue: */
	/* begin stackValue: */
	_rcvr = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* end stackValue: */
	if (((_index & (smallIntegerTag())) == 0) || (((_valueObject & (smallIntegerTag())) == 0) || (GIV(argumentCount) > 2))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	_value = _valueObject >> 3;
	if (_value < 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_bytes = pointerAtPointer(firstBytePointerOfDataObject(_rcvr));
	if (_bytes == 0) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	uint8AtPointerput(_bytes + _index, _value);
	/* begin pop:thenPush: */
	unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _valueObject);
	GIV(stackPointer) = _sp;
	/* end pop:thenPush: */
}
/*	Behaviour depends on argument count: 
	0 args:	return an Array of VM parameter values; 
	1 arg:	 return the indicated VM parameter; 
	2 args:	set the VM indicated parameter. 
	 
	The description of each parameter is available in the Image 
	(`VirtualMachine>>#parameterLabels`) Do not forget to update it when new 
	parameters are added. 
	Otherwise the *real* list is in the code: 
	`StackInterpreterPrimitives>>#primitiveGetVMParameter:`  */
/* StackInterpreterPrimitives>>#primitiveVMParameter */
static void
primitiveVMParameter(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	double _aDouble;
	double _aFloat;
	double _aProportion;
	sqInt _arg;
	sqInt _argOop;
	sqLong _delta;
	sqInt _index;
	sqInt _index2;
	sqInt _knownClassIndex;
	sqInt _offset;
	sqInt _oop;
	int _paramsArraySize;
	sqInt _result;
	sqInt _result2;
	sqInt _result3;
	char *_sp;
	char *_sp2;
	char *_sp3;
	sqInt _tagBits;
	sqInt _valuePointer;

	_paramsArraySize = 86;
	if (GIV(argumentCount) == 0) {
		/* begin primitiveAllVMParameters: */
		/* begin eeInstantiateClassIndex:format:numSlots: */
		_knownClassIndex = arrayClassIndexPun();
		assert((_paramsArraySize >= 0) && ((_knownClassIndex != 0) && ((knownClassAtIndex(_knownClassIndex)) != GIV(nilObj))));
		assert(2 == (instSpecOfClass(knownClassAtIndex(_knownClassIndex))));
		_result3 = allocateNewSpaceSlotsformatclassIndex(_paramsArraySize, 2, _knownClassIndex);
		/* end eeInstantiateClassIndex:format:numSlots: */
		for (_index2 = 1; _index2 <= _paramsArraySize; _index2 += 1) {
			/* begin storePointerUnchecked:ofObject:withValue: */
			_valuePointer = ((!(primitiveGetVMParameter(_index2)))
				 ? (/* begin nilObject */ GIV(nilObj) /* end nilObject */)
				 : primitiveGetVMParameter(_index2));
			assert(!(isOopForwarded(_result3)));
			longAtput((_result3 + BaseHeaderSize) + ((sqInt) (((usqInt) (_index2 - 1) ) << (shiftForWord())) ), _valuePointer);
			/* end storePointerUnchecked:ofObject:withValue: */
		}
		beRootIfOld(_result3);
		/* begin methodReturnValue: */
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp3 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _result3);
		GIV(stackPointer) = _sp3;
		/* end pop:thenPush: */
		return;
		/* end methodReturnValue: */
		/* end primitiveAllVMParameters: */
	}
	if (GIV(argumentCount) > 2) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadNumArgs;
		return;
		/* end primitiveFailFor: */
	}
	/* begin stackValue: */
	_offset = ((GIV(argumentCount) == 1)
		 ? 0
		 : 1);
	_index = unsignedLongAt(GIV(stackPointer) + (_offset * BytesPerWord));
	/* end stackValue: */
	if (!(((_index & 7) == 1))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		return;
		/* end primitiveFailFor: */
	}
	_index = _index >> 3;
	if ((_index < 1) || (_index > _paramsArraySize)) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	if (GIV(argumentCount) == 1) {
		_result = primitiveGetVMParameter(_index);
		/* begin methodReturnValue: */
		_oop = ((!_result)
			 ? (/* begin nilObject */ GIV(nilObj) /* end nilObject */)
			 : _result);
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _oop);
		GIV(stackPointer) = _sp;
		/* end pop:thenPush: */
		return;
		/* end methodReturnValue: */
	}
	/* begin primitiveSetVMParameter:arg: */
	_argOop = unsignedLongAt(GIV(stackPointer));
	switch (_index) {
		case 17:
		case 55:
		case 68:
		{
			if (!((((((_tagBits = _argOop & (tagMask()))) != 0)
				 ? _tagBits == (smallFloatTag())
				 : ((longAt(_argOop)) & (classIndexMask())) == ClassFloatCompactIndex)) || (((_argOop & 7) == 1)))) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l16;
				/* end primitiveFailFor: */
			}
		}
		break;
		case 86:
		{
			if (!((_argOop == GIV(trueObj)) || (_argOop == GIV(falseObj)))) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l16;
				/* end primitiveFailFor: */
			}
			/* begin booleanValueOf: */
			if (_argOop == GIV(trueObj)) {
				_arg = 1;
				goto l15;
			}
			if (_argOop == GIV(falseObj)) {
				_arg = 0;
				goto l15;
			}
			/* begin success: */
			{
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
			}
			/* end success: */
			_arg = null;
			l15:
			;
			/* end booleanValueOf: */
		}
		break;
		default:
		{
			if (!(((_argOop & 7) == 1))) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l16;
				/* end primitiveFailFor: */
			}
			_arg = _argOop >> 3;
		}
	}
	/* begin primitiveFailFor: */
	GIV(primFailCode) = PrimErrBadArgument;
	/* end primitiveFailFor: */
	switch (_index) {
		case 5:
		{
		}
		break;
		case 6:
		{
			_result2 = ((((usqInt) ((sqInt) (((scavengerTenuringProportion()) * (((GIV(pastSpace).limit)) - ((GIV(pastSpace).start)))) / (8 * BytesPerOop)) ) ) << 3) | 1);
			/* begin tenuringThreshold: */
			if (_arg < 0) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l11;
			}
			/* begin scavengerTenuringProportionToKeepInPastSpace: */
			_aProportion = ((double) (_arg * (8 * BytesPerOop)) ) / ((double) (((GIV(pastSpace).limit)) - ((GIV(pastSpace).start))) );
			GIV(tenuringProportion) = _aProportion;
			if (_aProportion == 0.0) {
				GIV(tenureThreshold) = 0;
			} else {
				GIV(tenureThreshold) = (round((((GIV(pastSpace).limit)) - ((GIV(pastSpace).start))) * (1.0 - GIV(tenuringProportion)))) + ((GIV(pastSpace).start));
			}
			/* end scavengerTenuringProportionToKeepInPastSpace: */
			GIV(primFailCode) = 0;
			l11:
			;
			/* end tenuringThreshold: */
		}
		break;
		case 11:
		{
			if (_arg >= 0) {
				_result2 = ((((usqInt) GIV(statTenures) ) << 3) | 1);
				/* begin statTenures: */
				GIV(statTenures) = _arg;
				/* end statTenures: */
				/* begin initPrimCall */
				GIV(primFailCode) = 0;
				/* end initPrimCall */
			}
		}
		break;
		case 12:
		{
			_result2 = ((((usqInt) (((GIV(maxSlotsForNewSpaceAlloc) == 0)
				 ? (/* begin fixedFieldsOfClassFormatMask */ (1U << (fixedFieldsFieldWidth())) - 1 /* end fixedFieldsOfClassFormatMask */)
				 : GIV(maxSlotsForNewSpaceAlloc))) ) << 3) | 1);
			/* begin setMaxSlotsForNewSpaceAlloc: */
			GIV(maxSlotsForNewSpaceAlloc) = _arg;
			/* end setMaxSlotsForNewSpaceAlloc: */
			/* begin initPrimCall */
			GIV(primFailCode) = 0;
			/* end initPrimCall */
		}
		break;
		case 17:
		{
		}
		break;
		case 23:
		{
			_result2 = ((((usqInt) extraVMMemory ) << 3) | 1);
			extraVMMemory = _arg;
			/* begin initPrimCall */
			GIV(primFailCode) = 0;
			/* end initPrimCall */
		}
		break;
		case 24:
		{
			if (_arg > 0) {
				_result2 = ((((usqInt) GIV(shrinkThreshold) ) << 3) | 1);
				/* begin shrinkThreshold: */
				GIV(shrinkThreshold) = _arg;
				/* end shrinkThreshold: */
				/* begin initPrimCall */
				GIV(primFailCode) = 0;
				/* end initPrimCall */
			}
		}
		break;
		case 25:
		{
			if (_arg > 0) {
				_result2 = ((((usqInt) GIV(growHeadroom) ) << 3) | 1);
				/* begin growHeadroom: */
				GIV(growHeadroom) = _arg;
				/* end growHeadroom: */
				/* begin initPrimCall */
				GIV(primFailCode) = 0;
				/* end initPrimCall */
			}
		}
		break;
		case 26:
		{
			if (_arg >= 0) {
				_result2 = ((((usqInt) (ioHeartbeatMilliseconds()) ) << 3) | 1);
				ioSetHeartbeatMilliseconds(_arg);
				/* begin initPrimCall */
				GIV(primFailCode) = 0;
				/* end initPrimCall */
			}
		}
		break;
		case 34:
		{
			if (_arg >= 0) {
				_result2 = positive64BitIntegerFor(currentAllocatedBytes());
				/* begin setCurrentAllocatedBytesTo: */
				_delta = (currentAllocatedBytes()) - GIV(statAllocatedBytes);
				GIV(statAllocatedBytes) = _arg;
				GIV(oldSpaceUsePriorToScavenge) += _delta;
				assert((currentAllocatedBytes()) == _arg);
				/* end setCurrentAllocatedBytesTo: */
				/* begin initPrimCall */
				GIV(primFailCode) = 0;
				/* end initPrimCall */
			}
		}
		break;
		case 43:
		{
			if ((_arg >= 0) && (_arg <= 0xFFFF)) {
				_result2 = ((((usqInt) desiredNumStackPages ) << 3) | 1);
				desiredNumStackPages = _arg;
				/* begin initPrimCall */
				GIV(primFailCode) = 0;
				/* end initPrimCall */
			}
		}
		break;
		case 45:
		{
			if (_arg >= 0) {
				_result2 = ((((usqInt) desiredEdenBytes ) << 3) | 1);
				desiredEdenBytes = _arg;
				/* begin initPrimCall */
				GIV(primFailCode) = 0;
				/* end initPrimCall */
			}
		}
		break;
		case 47:
		{
			if ((_arg >= 0) && (_arg <= (maxCogCodeSize()))) {
				_result2 = ((((usqInt) (getDesiredCogCodeSize()) ) << 3) | 1);
				/* begin setDesiredCogCodeSize: */
				desiredCogCodeSize = _arg;
				/* end setDesiredCogCodeSize: */
				/* begin initPrimCall */
				GIV(primFailCode) = 0;
				/* end initPrimCall */
			}
		}
		break;
		case 48:
		{
			if (_arg >= 0) {
				_result2 = ((((usqInt) (((((usqInt) (((((GIV(flagInterpretedMethods))
					 ? 2
					 : 0)) + (((GIV(preemptionYields))
					 ? 0
					 : 4))) + (((((usqInt) GIV(imageHeaderFlags) ) >> 2) | (((2 + 4) + 16) + 32)) - (((2 + 4) + 16) + 32))) ) << 3) | 1)) ) << 3) | 1);
				/* begin initPrimCall */
				GIV(primFailCode) = 0;
				/* end initPrimCall */
				/* begin setCogVMFlags: */
				if (((usqInt) _arg ) > 0x3F) {
					GIV(primFailCode) = PrimErrUnsupported;
					goto l4;
				}
				GIV(flagInterpretedMethods) = _arg & 2;
				GIV(preemptionYields) = (_arg & 4) == 0;
				l4:
				;
				/* end setCogVMFlags: */
			}
		}
		break;
		case 49:
		{
			if ((_arg >= 0) && (_arg <= 0xFFFF)) {
				_result2 = ((((usqInt) (ioGetMaxExtSemTableSize()) ) << 3) | 1);
				/* begin initPrimCall */
				GIV(primFailCode) = 0;
				/* end initPrimCall */
				/* begin setMaxExtSemSizeTo: */
				GIV(maxExtSemTabSizeSet) = 1;
				ioSetMaxExtSemTableSize(_arg);
				/* end setMaxExtSemSizeTo: */
			}
		}
		break;
		case 55:
		{
			_result2 = floatObjectOf(getHeapGrowthToSizeGCRatio());
			/* begin setHeapGrowthToSizeGCRatio: */
			_aDouble = noInlineLoadFloatOrIntFrom(_argOop);
			GIV(heapGrowthToSizeGCRatio) = _aDouble;
			GIV(primFailCode) = 0;
			/* end setHeapGrowthToSizeGCRatio: */
		}
		break;
		case 67:
		{
			if (_arg >= 0) {
				_result2 = (((maxOldSpaceSize()) << 3) | 1);
				/* begin setMaxOldSpaceSize: */
				maxOldSpaceSize = _arg;
				GIV(primFailCode) = 0;
				/* end setMaxOldSpaceSize: */
			}
		}
		break;
		case 68:
		{
			_result2 = floatObjectOf(statAverageLivePagesWhenMapping0());
			/* begin initPrimCall */
			GIV(primFailCode) = 0;
			/* end initPrimCall */
			/* begin statAverageLivePagesWhenMapping: */
			_aFloat = noInlineLoadFloatOrIntFrom(_argOop);
			if (_aFloat == 0.0) {
				GIV(statPageCountWhenMappingSum) = (GIV(statNumMaps) = 0);
			} else {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				/* end primitiveFailFor: */
			}
			/* end statAverageLivePagesWhenMapping: */
		}
		break;
		case 69:
		{
			if (_arg >= 0) {
				_result2 = ((((usqInt) (statMaxPageCountWhenMapping0()) ) << 3) | 1);
				/* begin statMaxPageCountWhenMapping: */
				GIV(statMaxPageCountWhenMapping) = _arg;
				/* end statMaxPageCountWhenMapping: */
				/* begin initPrimCall */
				GIV(primFailCode) = 0;
				/* end initPrimCall */
			}
		}
		break;
		case 74:
		{
			if (_arg >= 0) {
				_result2 = ((((usqInt) ((GIV(statMaxAllocSegmentTime) + 500) / 1000) ) << 3) | 1);
				/* begin statMaxAllocSegmentTime: */
				GIV(statMaxAllocSegmentTime) = _arg;
				/* end statMaxAllocSegmentTime: */
				/* begin initPrimCall */
				GIV(primFailCode) = 0;
				/* end initPrimCall */
			}
		}
		break;
		case 79:
		{
			if ((_arg >= 0) && (_arg <= 0xFFFF)) {
				_result2 = ((((usqInt) GIV(imageVersionNumber) ) << 3) | 1);
				/* begin setImageVersion: */
				GIV(imageVersionNumber) = _arg & 0xFFFF;
				/* end setImageVersion: */
				/* begin initPrimCall */
				GIV(primFailCode) = 0;
				/* end initPrimCall */
			}
		}
		break;
		case 86:
		{
			if (GIV(avoidSearchingSegmentsWithPinnedObjects)) {
				/* begin trueObject */
				_result2 = GIV(trueObj);
				/* end trueObject */
			} else {
				/* begin falseObject */
				_result2 = GIV(falseObj);
				/* end falseObject */
			}
			/* begin setAvoidSearchingSegmentsWithPinnedObjects: */
			GIV(avoidSearchingSegmentsWithPinnedObjects) = _arg;
			/* end setAvoidSearchingSegmentsWithPinnedObjects: */
			/* begin initPrimCall */
			GIV(primFailCode) = 0;
			/* end initPrimCall */
		}
		break;
		default:
		{
		}
	}
	if (!GIV(primFailCode)) {
		/* begin methodReturnValue: */
		/* begin pop:thenPush: */
		unsignedLongAtput((_sp2 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), _result2);
		GIV(stackPointer) = _sp2;
		/* end pop:thenPush: */
		/* end methodReturnValue: */
	} else {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrInappropriate;
		/* end primitiveFailFor: */
	}
	l16:
	;
	/* end primitiveSetVMParameter:arg: */
}
/*	Potentially crash the VM by voiding the receiver. A subsequent inst var 
	access in the caller's frame should indirect through a null pointer. */
/* StackInterpreterPrimitives>>#primitiveVoidReceiver */
EXPORT(void)
primitiveVoidReceiver(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	longAtPointerput(((isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))
		 ? GIV(framePointer) + FoxMFReceiver
		 : GIV(framePointer) + FoxIFReceiver), 0);
}
/*	Because of Slang restrictions, making FFI optional requires cutting the 
	primitive in two different methods. Otherwise slang will unconditionally 
	do all local declarations which may refer to invalid types if FFI is not 
	enabled.  
	Method primitiveWorkerCallout checks if the feature is available. If so, 
	it calls the actual implementation: doPrimitiveWorkerCallout. */
/* StackInterpreterPrimitives>>#primitiveWorkerCallout */
EXPORT(void)
primitiveWorkerCallout(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	
#  if FEATURE_THREADED_FFI
	{
		doPrimitiveWorkerCallout();
	}
#  else /* FEATURE_THREADED_FFI */
	{
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrUnsupported;
		/* end primitiveFailFor: */
	}
#  endif /* FEATURE_THREADED_FFI */
}
/*	Because of Slang restrictions, making FFI optional requires cutting the 
	primitive in two different methods. Otherwise slang will unconditionally 
	do all local declarations which may refer to invalid types if FFI is not 
	enabled.  
	Method primitiveWorkerExtractReturnValue checks if the feature is 
	available. If so, it calls the actual implementation: 
	doPrimitiveWorkerExtractReturnValue.  */
/* StackInterpreterPrimitives>>#primitiveWorkerExtractReturnValue */
EXPORT(void)
primitiveWorkerExtractReturnValue(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	
#  if FEATURE_THREADED_FFI
	{
		doPrimitiveWorkerExtractReturnValue();
	}
#  else /* FEATURE_THREADED_FFI */
	{
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrUnsupported;
		/* end primitiveFailFor: */
	}
#  endif /* FEATURE_THREADED_FFI */
}
/*	Enter the interpreter from a callback in the VM thread. 
	The VM is suspended in a callout or primitive, which are not safe 
	suspension points.  
	The callback has been put in a queue for further processing from the 
	image. We first put the VM in a runnable state by putting it in a safe 
	suspension point first 
	=> we suspend the active process and store it for further resuming 
	Then we enter the interpreter. */
/* StackInterpreterPrimitives>>#ptEnterInterpreterFromCallback: */
sqInt
ptEnterInterpreterFromCallback(void *_aPointer)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _activeProc;
	sqInt _objOop;
	sqInt _objOop2;
	char *_sp;
	sqInt _suspendedProcess;
	sqInt _valuePointer;
	VMCallbackContext *_vmCallbackContext;

	_vmCallbackContext = ((VMCallbackContext *) _aPointer );
	(_vmCallbackContext->savedPrimFunctionPointer = primitiveFunctionPointer);
	/* begin saveCStackStateForCallbackContext: */
	{
		(_vmCallbackContext->savedCStackPointer = getCStackPointer());
		(_vmCallbackContext->savedCFramePointer = getCFramePointer());
	}
	{
		memcpy(((void *) ((_vmCallbackContext->savedReenterInterpreter)) ), reenterInterpreter, sizeof(jmp_buf));
	}
	/* end saveCStackStateForCallbackContext: */
	/* begin push: */
	unsignedLongAtput((_sp = GIV(stackPointer) - BytesPerWord), GIV(newMethod));
	GIV(stackPointer) = _sp;
	/* end push: */
	/* begin supendActiveProcess */
	/* begin memoryActiveProcess */
	/* begin fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_objOop2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	_objOop = unsignedLongAt((_objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	_activeProc = unsignedLongAt((_objOop + BaseHeaderSize) + ((sqInt) (((usqInt) ActiveProcessIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end memoryActiveProcess */
	transferTofrom(wakeHighestPriority(), CSCallbackEnter);
	_suspendedProcess = _activeProc;
	/* end supendActiveProcess */
	/* begin pushSameThreadCalloutSuspendedProcess: */
	/* begin storePointer:ofObject:withValue: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_valuePointer = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SuspendedProcessInCallout ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	assert(!(isForwarded(_suspendedProcess)));
	if (((_suspendedProcess & (tagMask())) == 0) && ((_suspendedProcess & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((_valuePointer & (tagMask())) == 0) && (((_valuePointer & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_valuePointer >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_suspendedProcess)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _suspendedProcess);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(_suspendedProcess)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l2;
	}
	if (_valuePointer & (tagMask())) {
		goto l2;
	}
	if (!(_suspendedProcess >= 0x20000000000LL)) {
		goto l2;
	}
	if (_valuePointer >= 0x20000000000LL) {
		goto l2;
	}
	if ((_valuePointer >= GIV(nilObj)) && (_valuePointer <= GIV(trueObj))) {
		goto l2;
	}
	if (!(_valuePointer >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l2;
	}
	remember(getFromPermToNewSpaceRememberedSet(), _suspendedProcess);
	l2:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((_suspendedProcess + BaseHeaderSize) + ((sqInt) (((usqInt) NextLinkIndex ) << (shiftForWord())) ), _valuePointer);
	/* end storePointer:ofObject:withValue: */
	/* begin splObj:put: */
	/* begin storePointer:ofObject:withValue: */
	assert(!(isForwarded(GIV(specialObjectsOop))));
	if (((GIV(specialObjectsOop) & (tagMask())) == 0) && ((GIV(specialObjectsOop) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((_suspendedProcess & (tagMask())) == 0) && (((_suspendedProcess & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_suspendedProcess >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), GIV(specialObjectsOop));
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l6;
	}
	if (_suspendedProcess & (tagMask())) {
		goto l6;
	}
	if (!(GIV(specialObjectsOop) >= 0x20000000000LL)) {
		goto l6;
	}
	if (_suspendedProcess >= 0x20000000000LL) {
		goto l6;
	}
	if ((_suspendedProcess >= GIV(nilObj)) && (_suspendedProcess <= GIV(trueObj))) {
		goto l6;
	}
	if (!(_suspendedProcess >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l6;
	}
	remember(getFromPermToNewSpaceRememberedSet(), GIV(specialObjectsOop));
	l6:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SuspendedProcessInCallout ) << (shiftForWord())) ), _suspendedProcess);
	/* end storePointer:ofObject:withValue: */
	/* end splObj:put: */
	/* end pushSameThreadCalloutSuspendedProcess: */
	enterSmalltalkExecutive();
	return 1;
}
/* StackInterpreterPrimitives>>#ptExitInterpreterToCallback: */
sqInt
ptExitInterpreterToCallback(void *_aPointer)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _anObject;
	sqInt _aProcess;
	sqInt _suspendedProcess;
	sqInt _top;
	VMCallbackContext *_vmCallbackContext;

	_vmCallbackContext = ((VMCallbackContext *) _aPointer );
	/* begin popSameThreadCalloutSuspendedProcess */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	_aProcess = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SuspendedProcessInCallout ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	if (_aProcess == GIV(nilObj)) {
		error("SameThreadCalloutSuspendedProcessStack is empty");
	}
	/* begin splObj:put: */
	_anObject = unsignedLongAt((_aProcess + BaseHeaderSize) + ((sqInt) (((usqInt) NextLinkIndex ) << (shiftForWord())) ));
	/* begin storePointer:ofObject:withValue: */
	assert(!(isForwarded(GIV(specialObjectsOop))));
	if (((GIV(specialObjectsOop) & (tagMask())) == 0) && ((GIV(specialObjectsOop) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((_anObject & (tagMask())) == 0) && (((_anObject & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_anObject >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), GIV(specialObjectsOop));
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(GIV(specialObjectsOop))) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l6;
	}
	if (_anObject & (tagMask())) {
		goto l6;
	}
	if (!(GIV(specialObjectsOop) >= 0x20000000000LL)) {
		goto l6;
	}
	if (_anObject >= 0x20000000000LL) {
		goto l6;
	}
	if ((_anObject >= GIV(nilObj)) && (_anObject <= GIV(trueObj))) {
		goto l6;
	}
	if (!(_anObject >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l6;
	}
	remember(getFromPermToNewSpaceRememberedSet(), GIV(specialObjectsOop));
	l6:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SuspendedProcessInCallout ) << (shiftForWord())) ), _anObject);
	/* end storePointer:ofObject:withValue: */
	/* end splObj:put: */
	/* begin storePointer:ofObject:withValue: */
	assert(!(isForwarded(_aProcess)));
	if (((_aProcess & (tagMask())) == 0) && ((_aProcess & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((GIV(nilObj) & (tagMask())) == 0) && (((GIV(nilObj) & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (GIV(nilObj) >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_aProcess)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _aProcess);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(_aProcess)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l3;
	}
	if (GIV(nilObj) & (tagMask())) {
		goto l3;
	}
	if (!(_aProcess >= 0x20000000000LL)) {
		goto l3;
	}
	if (GIV(nilObj) >= 0x20000000000LL) {
		goto l3;
	}
	if ((GIV(nilObj) >= GIV(nilObj)) && (GIV(nilObj) <= GIV(trueObj))) {
		goto l3;
	}
	if (!(GIV(nilObj) >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l3;
	}
	remember(getFromPermToNewSpaceRememberedSet(), _aProcess);
	l3:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((_aProcess + BaseHeaderSize) + ((sqInt) (((usqInt) NextLinkIndex ) << (shiftForWord())) ), GIV(nilObj));
	/* end storePointer:ofObject:withValue: */
	_suspendedProcess = _aProcess;
	/* end popSameThreadCalloutSuspendedProcess */
	putToSleepyieldingIf(memoryActiveProcess(), GIV(preemptionYields));
	transferTofrom(_suspendedProcess, CSCallbackLeave);
	/* begin popStack */
	_top = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	GIV(newMethod) = _top;
	/* end popStack */
	/* begin restoreCStackStateForCallbackContext: */
	{
		setCStackPointer((_vmCallbackContext->savedCStackPointer));
		setCFramePointer((_vmCallbackContext->savedCFramePointer));
	}
	{
		memcpy(reenterInterpreter, ((void *) ((_vmCallbackContext->savedReenterInterpreter)) ), sizeof(jmp_buf));
	}
	/* end restoreCStackStateForCallbackContext: */
	primitiveFunctionPointer = (_vmCallbackContext->savedPrimFunctionPointer);
	siglongjmp((_vmCallbackContext->trampoline), 1);
	return 1;
}
/* StackInterpreterPrimitives>>#readAddress: */
void *
readAddress(sqInt _anOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (!(isKindOfClass(_anOop, unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ))))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return null;
	}
	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((_anOop + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
}
/* StackInterpreterPrimitives>>#writeAddress:to: */
sqInt
writeAddressto(sqInt _anOop, void *_aValue)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _valuePointer;

	if (!(isKindOfClass(_anOop, unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ))))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		return null;
	}
	/* begin storePointer:ofObject:withValue: */
	_valuePointer = ((sqInt) _aValue );
	assert(!(isForwarded(_anOop)));
	if (((_anOop & (tagMask())) == 0) && ((_anOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		if (((_valuePointer & (tagMask())) == 0) && (((_valuePointer & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (_valuePointer >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(_anOop)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), _anOop);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(_anOop)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l2;
	}
	if (_valuePointer & (tagMask())) {
		goto l2;
	}
	if (!(_anOop >= 0x20000000000LL)) {
		goto l2;
	}
	if (_valuePointer >= 0x20000000000LL) {
		goto l2;
	}
	if ((_valuePointer >= GIV(nilObj)) && (_valuePointer <= GIV(trueObj))) {
		goto l2;
	}
	if (!(_valuePointer >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l2;
	}
	remember(getFromPermToNewSpaceRememberedSet(), _anOop);
	l2:
	;
	/* end possiblePermObjectStoreInto:value: */
	return unsignedLongAtput((_anOop + BaseHeaderSize) + (0U << (shiftForWord())), _valuePointer);
	/* end storePointer:ofObject:withValue: */
}
/* VMImageReaderWriter>>#hasToUseComposedFormat */
static sqInt
hasToUseComposedFormat(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (GIV(formatToUse) == AutodetectFormat) {
		error("I couldn't detect the format before using it");
	}
	return (GIV(formatToUse) == ComposedFormatDetected) || (GIV(formatToUse) == ComposedFormatForced);
}
/* VMImageReaderWriter>>#readImageNamed: */
sqInt
readImageNamed(char *_imageName)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aCharacter;
	SpurImageHeaderStruct _aHeader;
	char _buffer[255];
	char _fieldName[255];
	long long _fieldValue;
	sqImageFile _file;
	sqInt _file2;
	sqInt _fn;
	SpurImageHeaderStruct _header;
	SpurImageHeaderStruct _header2;
	SpurImageHeaderStruct _header3;
	SpurImageHeaderStruct *_headerPtr;
	char _lineBuffer[1024];
	char _lineBuffer2[1024];
	VMRememberedSet *_newRememberedSet;
	VMRememberedSet *_newRememberedSet2;
	VMRememberedSet *_newRememberedSet22;
	VMRememberedSet *_newRememberedSet3;
	VMRememberedSet *_newRememberedSet32;
	VMRememberedSet *_newRememberedSet4;
	char _structName[255];
	sqInt _swapFlag;
	sqInt _version;
	int _w;
	usqInt _w2;

	/* begin autodetectFormat: */
	if (GIV(formatToUse) == AutodetectFormat) {
		if (sqImageIsDirectory(_imageName)) {
			logDebug("Composed Image Format detected");
			GIV(formatToUse) = ComposedFormatDetected;
		} else {
			logDebug("Spur Image Format detected");
			GIV(formatToUse) = SpurFormatDetected;
		}
	}
	_fieldValue = 0;
	_fn = 0;
	/* end autodetectFormat: */
	if (hasToUseComposedFormat()) {
		/* begin CIR_readImageNamed: */
		/* begin ensureAuxiliarStructures */
		{
			if (!GIV(fromOldSpaceRememberedSet)) {
				/* begin allocateRememberedSetWithRootIndex: */
				_newRememberedSet = ((VMRememberedSet *) (malloc(sizeof(VMRememberedSet))) );
				(_newRememberedSet->rootIndex = OldRememberedSetRootIndex);
				GIV(fromOldSpaceRememberedSet) = _newRememberedSet;
				/* end allocateRememberedSetWithRootIndex: */
			}
			if (!GIV(fromPermToOldSpaceRememberedSet)) {
				/* begin allocateRememberedSetWithRootIndex: */
				_newRememberedSet2 = ((VMRememberedSet *) (malloc(sizeof(VMRememberedSet))) );
				(_newRememberedSet2->rootIndex = PermToOldRememberedSetRootIndex);
				GIV(fromPermToOldSpaceRememberedSet) = _newRememberedSet2;
				/* end allocateRememberedSetWithRootIndex: */
			}
			if (!GIV(fromPermToNewSpaceRememberedSet)) {
				/* begin allocateRememberedSetWithRootIndex: */
				_newRememberedSet3 = ((VMRememberedSet *) (malloc(sizeof(VMRememberedSet))) );
				(_newRememberedSet3->rootIndex = PermToNewRememberedSetRootIndex);
				GIV(fromPermToNewSpaceRememberedSet) = _newRememberedSet3;
				/* end allocateRememberedSetWithRootIndex: */
			}
		}
		/* end ensureAuxiliarStructures */
		/* begin readHeaderFromImage: */
		/* begin simulationOnly: */
		/* end simulationOnly: */
		_file = sqImageFileOpen(headerFileNameinImageintobufferSize(_imageName, _buffer, 0xFF), "r");
		if (!_file) {
			logError("Could not open header file: %s", _buffer);
			ioExitWithErrorCode(1);
		}
		_headerPtr = &_header;
		/* begin readSTONFrom:into: */
		/* begin readHeadSTONFrom:into: */
		/* begin simulationOnly: */
		/* end simulationOnly: */
		readLineFromintoofSize(_file, _lineBuffer, 1024);
		sscanf(contentsOf(_lineBuffer), "%s {\n", _structName);
		/* begin simulationOnly: */
		/* end simulationOnly: */
		/* end readHeadSTONFrom:into: */
		/* begin readFieldsSTONFrom:into: */
		/* begin simulationOnly: */
		/* end simulationOnly: */
		{
			(_headerPtr->dataSize = 0);
			(_headerPtr->hdrOldSpaceSize = 0);
			(_headerPtr->oldBaseAddr = 0);
			(_headerPtr->initialSpecialObjectsOop = 0);
			(_headerPtr->headerFlags = 0);
			(_headerPtr->extraVMMemory = 0);
			(_headerPtr->hdrNumStackPages = 0);
			(_headerPtr->hdrCogCodeSize = 0);
			(_headerPtr->hdrEdenBytes = 0);
			(_headerPtr->hdrMaxExtSemTabSize = 0);
			(_headerPtr->firstSegSize = 0);
			(_headerPtr->freeOldSpaceInImage = 0);
			(_headerPtr->swapBytes = 0);
			(_headerPtr->hdrLastHash = 0);
			(_headerPtr->imageFormat = 0);
			(_headerPtr->imageHeaderSize = 0);
			(_headerPtr->imageVersion = 0);
		}
		do {
			readLineFromintoofSize(_file, _lineBuffer2, 1024);
			sscanf(contentsOf(_lineBuffer2), fieldFormat(), _fieldName, ((sqInt*) &_fieldValue ));
			{
				if ((strcmp("dataSize", contentsOf(_fieldName))) == 0) {
					(_headerPtr->dataSize = contentsOf(_fieldValue));
				}
				if ((strcmp("hdrOldSpaceSize", contentsOf(_fieldName))) == 0) {
					(_headerPtr->hdrOldSpaceSize = contentsOf(_fieldValue));
				}
				if ((strcmp("oldBaseAddr", contentsOf(_fieldName))) == 0) {
					(_headerPtr->oldBaseAddr = contentsOf(_fieldValue));
				}
				if ((strcmp("initialSpecialObjectsOop", contentsOf(_fieldName))) == 0) {
					(_headerPtr->initialSpecialObjectsOop = contentsOf(_fieldValue));
				}
				if ((strcmp("headerFlags", contentsOf(_fieldName))) == 0) {
					(_headerPtr->headerFlags = contentsOf(_fieldValue));
				}
				if ((strcmp("extraVMMemory", contentsOf(_fieldName))) == 0) {
					(_headerPtr->extraVMMemory = contentsOf(_fieldValue));
				}
				if ((strcmp("hdrNumStackPages", contentsOf(_fieldName))) == 0) {
					(_headerPtr->hdrNumStackPages = contentsOf(_fieldValue));
				}
				if ((strcmp("hdrCogCodeSize", contentsOf(_fieldName))) == 0) {
					(_headerPtr->hdrCogCodeSize = contentsOf(_fieldValue));
				}
				if ((strcmp("hdrEdenBytes", contentsOf(_fieldName))) == 0) {
					(_headerPtr->hdrEdenBytes = contentsOf(_fieldValue));
				}
				if ((strcmp("hdrMaxExtSemTabSize", contentsOf(_fieldName))) == 0) {
					(_headerPtr->hdrMaxExtSemTabSize = contentsOf(_fieldValue));
				}
				if ((strcmp("firstSegSize", contentsOf(_fieldName))) == 0) {
					(_headerPtr->firstSegSize = contentsOf(_fieldValue));
				}
				if ((strcmp("freeOldSpaceInImage", contentsOf(_fieldName))) == 0) {
					(_headerPtr->freeOldSpaceInImage = contentsOf(_fieldValue));
				}
				if ((strcmp("swapBytes", contentsOf(_fieldName))) == 0) {
					(_headerPtr->swapBytes = contentsOf(_fieldValue));
				}
				if ((strcmp("hdrLastHash", contentsOf(_fieldName))) == 0) {
					(_headerPtr->hdrLastHash = contentsOf(_fieldValue));
				}
				if ((strcmp("imageFormat", contentsOf(_fieldName))) == 0) {
					(_headerPtr->imageFormat = contentsOf(_fieldValue));
				}
				if ((strcmp("imageHeaderSize", contentsOf(_fieldName))) == 0) {
					(_headerPtr->imageHeaderSize = contentsOf(_fieldValue));
				}
				if ((strcmp("imageVersion", contentsOf(_fieldName))) == 0) {
					(_headerPtr->imageVersion = contentsOf(_fieldValue));
				}
			}
			/* begin endOfSTON: */
			_aCharacter = fgetc(_file);
			ungetc(_aCharacter, _file);
			/* end endOfSTON: */
		} while (!((_aCharacter == -1) || (_aCharacter == '}')));
		/* end readFieldsSTONFrom:into: */
		/* end readSTONFrom:into: */
		if (((_header.hdrOldSpaceSize)) == 0) {
			(_header.hdrOldSpaceSize = (_header.dataSize));
		}
		extractImageVersionFrominto((_header.imageFormat), _headerPtr);
		sqImageFileClose(_file);
		_aHeader = _header;
		/* end readHeaderFromImage: */
		loadHeaderToMemory(_aHeader);
		allocateMemoryForImagewithHeader(_imageName, _aHeader);
		/* end CIR_readImageNamed: */
	} else {
		/* begin SIR_readImageNamed: */
		/* begin ensureAuxiliarStructures */
		{
			if (!GIV(fromOldSpaceRememberedSet)) {
				/* begin allocateRememberedSetWithRootIndex: */
				_newRememberedSet4 = ((VMRememberedSet *) (malloc(sizeof(VMRememberedSet))) );
				(_newRememberedSet4->rootIndex = OldRememberedSetRootIndex);
				GIV(fromOldSpaceRememberedSet) = _newRememberedSet4;
				/* end allocateRememberedSetWithRootIndex: */
			}
			if (!GIV(fromPermToOldSpaceRememberedSet)) {
				/* begin allocateRememberedSetWithRootIndex: */
				_newRememberedSet22 = ((VMRememberedSet *) (malloc(sizeof(VMRememberedSet))) );
				(_newRememberedSet22->rootIndex = PermToOldRememberedSetRootIndex);
				GIV(fromPermToOldSpaceRememberedSet) = _newRememberedSet22;
				/* end allocateRememberedSetWithRootIndex: */
			}
			if (!GIV(fromPermToNewSpaceRememberedSet)) {
				/* begin allocateRememberedSetWithRootIndex: */
				_newRememberedSet32 = ((VMRememberedSet *) (malloc(sizeof(VMRememberedSet))) );
				(_newRememberedSet32->rootIndex = PermToNewRememberedSetRootIndex);
				GIV(fromPermToNewSpaceRememberedSet) = _newRememberedSet32;
				/* end allocateRememberedSetWithRootIndex: */
			}
		}
		/* end ensureAuxiliarStructures */
		_file2 = sqImageFileOpen(_imageName, "rb");
		if (!_file2) {
			logError("Image file cannot be read: %s", _imageName);
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			goto l15;
			/* end primitiveFail */
		}
		/* begin readImageFromFile:StartingAt: */
		/* begin readHeaderFrom:startingAt: */
		/* begin simulationOnly: */
		/* end simulationOnly: */
		/* begin getWord32FromFile:swap: */
		_w = 0;
		sqImageFileRead(&_w, sizeof(int), 1, ((sqImageFile) _file2 ));
		_version = _w;
		/* end getWord32FromFile:swap: */
		extractImageVersionFrominto(_version, &_header2);
		(_header2.imageHeaderSize = getWord32FromFileswap(((sqImageFile) _file2 ), (_header2.swapBytes)));
		(_header2.dataSize = getLongFromFileswap(((sqImageFile) _file2 ), (_header2.swapBytes)));
		(_header2.hdrOldSpaceSize = (_header2.dataSize));
		(_header2.oldBaseAddr = getLongFromFileswap(((sqImageFile) _file2 ), (_header2.swapBytes)));
		(_header2.initialSpecialObjectsOop = getLongFromFileswap(((sqImageFile) _file2 ), (_header2.swapBytes)));
		(_header2.hdrLastHash = getLongFromFileswap(((sqImageFile) _file2 ), (_header2.swapBytes)));
		/* begin getLongFromFile:swap: */
		_swapFlag = (_header2.swapBytes);
		_w2 = 0;
		sqImageFileRead(&_w2, sizeof(_w2), 1, ((sqImageFile) _file2 ));
		if (_swapFlag) {
			/* begin byteSwapped: */
			SQ_SWAP_8_BYTES(_w2);
			/* end byteSwapped: */
		}
		/* end getLongFromFile:swap: */
		(_header2.headerFlags = getLongFromFileswap(((sqImageFile) _file2 ), (_header2.swapBytes)));
		(_header2.extraVMMemory = getWord32FromFileswap(((sqImageFile) _file2 ), (_header2.swapBytes)));
		(_header2.hdrNumStackPages = getShortFromFileswap(((sqImageFile) _file2 ), (_header2.swapBytes)));
		(_header2.hdrCogCodeSize = (getShortFromFileswap(((sqImageFile) _file2 ), (_header2.swapBytes))) * 1024);
		(_header2.hdrEdenBytes = getWord32FromFileswap(((sqImageFile) _file2 ), (_header2.swapBytes)));
		(_header2.hdrMaxExtSemTabSize = getShortFromFileswap(((sqImageFile) _file2 ), (_header2.swapBytes)));
		(_header2.imageVersion = getShortFromFileswap(((sqImageFile) _file2 ), (_header2.swapBytes)));
		(_header2.firstSegSize = getLongFromFileswap(((sqImageFile) _file2 ), (_header2.swapBytes)));
		(_header2.freeOldSpaceInImage = getLongFromFileswap(((sqImageFile) _file2 ), (_header2.swapBytes)));
		sqImageFileSeek(((sqImageFile) _file2 ), 0 + ((_header2.imageHeaderSize)));
		_header3 = _header2;
		/* end readHeaderFrom:startingAt: */
		loadHeaderToMemory(_header3);
		allocateMemoryForImagewithHeader(((sqImageFile) _file2 ), _header3);
		/* end readImageFromFile:StartingAt: */
		sqImageFileClose(_file2);
		l15:
		;
		/* end SIR_readImageNamed: */
	}
	return 0;
}
/* VMMemoryMap>>#allocateHeap */
static VMMemoryMap * NoDbgRegParms
allocateHeap(VMMemoryMap * self_in_allocateHeap)
{
	sqInt _anInteger;
	sqInt _newSpaceSizeToAllocate;
	sqInt _sizeToAllocate;

	/* begin allocateCodeZone */
	if (((self_in_allocateHeap->initialCodeZoneSize)) == 0) {
		goto l2;
	}
	(self_in_allocateHeap->codeZoneStart = allocateJITMemory((self_in_allocateHeap->initialCodeZoneSize), 13421772800LL));
	if (!((self_in_allocateHeap->codeZoneStart))) {
		insufficientMemoryAvailableError();
	}
	if (!(((self_in_allocateHeap->codeZoneStart)) == 13421772800LL)) {
		logError("Could not allocate codeZone in the expected place (%p), got %p", 13421772800LL, (self_in_allocateHeap->codeZoneStart));
		error("Error allocating");
	}
	(self_in_allocateHeap->codeZoneEnd = ((self_in_allocateHeap->codeZoneStart)) + ((self_in_allocateHeap->initialCodeZoneSize)));
	l2:
	;
	/* end allocateCodeZone */
	/* begin allocateNewObjectsSpace */
	_newSpaceSizeToAllocate = roundToAllocationSize(self_in_allocateHeap, ((self_in_allocateHeap->initialNewSpaceSize)) + ((self_in_allocateHeap->allocationReserve)));
	(self_in_allocateHeap->newSpaceStart = allocateMemoryBaseAddress(_newSpaceSizeToAllocate, 14495514624LL));
	if (!((self_in_allocateHeap->newSpaceStart))) {
		insufficientMemoryAvailableError();
	}
	if (!(((self_in_allocateHeap->newSpaceStart)) == 14495514624LL)) {
		logError("Could not allocate newSpace in the expected place (%p), got %p", (self_in_allocateHeap->newSpaceStart), 14495514624LL);
		error("Error allocating");
	}
	(self_in_allocateHeap->newSpaceEnd = ((self_in_allocateHeap->newSpaceStart)) + _newSpaceSizeToAllocate);
	/* end allocateNewObjectsSpace */
	/* begin allocateOldObjectsSpace */
	_sizeToAllocate = roundToAllocationSize(self_in_allocateHeap, ((self_in_allocateHeap->initialOldSpaceSize)) + ((self_in_allocateHeap->initialHeadroom)));
	(self_in_allocateHeap->oldSpaceStart = allocateMemoryBaseAddress(_sizeToAllocate, 0x10000000000LL));
	if (!((self_in_allocateHeap->oldSpaceStart))) {
		insufficientMemoryAvailableError();
	}
	if (!(((self_in_allocateHeap->oldSpaceStart)) == 0x10000000000LL)) {
		logError("Could not allocate oldSpace in the expected place (%p), got %p", (self_in_allocateHeap->oldSpaceStart), 0x10000000000LL);
		error("Error allocating");
	}
	/* begin setOldSpaceEnd: */
	_anInteger = ((sqInt) (((self_in_allocateHeap->oldSpaceStart)) + _sizeToAllocate) );
	(self_in_allocateHeap->oldSpaceEnd) = _anInteger;
	assert((((self_in_allocateHeap->permSpaceStart)) == 0) || (_anInteger < ((self_in_allocateHeap->permSpaceStart))));
	/* end setOldSpaceEnd: */
	/* end allocateOldObjectsSpace */
	allocatePermObjectsSpace(self_in_allocateHeap);
	return self_in_allocateHeap;
}
/* VMMemoryMap>>#allocatePermObjectsSpace */
static VMMemoryMap * NoDbgRegParms
allocatePermObjectsSpace(VMMemoryMap * self_in_allocatePermObjectsSpace)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aValue;
	sqInt _minSize;

	_minSize = ((((self_in_allocatePermObjectsSpace->minPermSpaceSize)) < ((self_in_allocatePermObjectsSpace->initialPermSpaceSize))) ? (self_in_allocatePermObjectsSpace->initialPermSpaceSize) : (self_in_allocatePermObjectsSpace->minPermSpaceSize));
	if (_minSize == 0) {
		return self_in_allocatePermObjectsSpace;
	}
	_minSize = roundToAllocationSize(self_in_allocatePermObjectsSpace, _minSize);
	(self_in_allocatePermObjectsSpace->permSpaceStart = allocateMemoryBaseAddress(_minSize, 0x20000000000LL));
	if (!((self_in_allocatePermObjectsSpace->permSpaceStart))) {
		insufficientMemoryAvailableError();
	}
	if (!(((self_in_allocatePermObjectsSpace->permSpaceStart)) == 0x20000000000LL)) {
		logError("Could not allocate permSpace in the expected place (%p), got %p", (self_in_allocatePermObjectsSpace->permSpaceStart), 0x20000000000LL);
		error("Error allocating");
	}
	(self_in_allocatePermObjectsSpace->permSpaceEnd = ((self_in_allocatePermObjectsSpace->permSpaceStart)) + _minSize);
	/* begin setPermSpaceFreeStart: */
	_aValue = ((sqInt) ((self_in_allocatePermObjectsSpace->permSpaceStart)) );
	GIV(permSpaceFreeStart) = _aValue;
	/* end setPermSpaceFreeStart: */
	return self_in_allocatePermObjectsSpace;
}
/* VMMemoryMap>>#allocateStackPages: */
static void NoDbgRegParms
allocateStackPages(VMMemoryMap * self_in_allocateStackPages, sqInt _initialStackSize)
{
	sqInt _sizeToRequest;

	_sizeToRequest = roundToAllocationSize(self_in_allocateStackPages, _initialStackSize);
	(self_in_allocateStackPages->stackPagesStart = allocateMemoryBaseAddress(_sizeToRequest, 12884901888LL));
	if (!((self_in_allocateStackPages->stackPagesStart))) {
		insufficientMemoryAvailableError();
	}
	if (!(((self_in_allocateStackPages->stackPagesStart)) == 12884901888LL)) {
		logError("Could not allocate stack in the expected place (%p), got %p", 12884901888LL, (self_in_allocateStackPages->stackPagesStart));
		error("Error allocating");
	}
	(self_in_allocateStackPages->stackPagesEnd = ((self_in_allocateStackPages->stackPagesStart)) + _sizeToRequest);
	memset((self_in_allocateStackPages->stackPagesStart), 0, _sizeToRequest);
	{
		return;
	}
}
/*	In windows we have an allocation granularity. Maybe we have to get it from 
	the system. 
	
	https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/ns-sysinfoapi-system_info  */
/* VMMemoryMap>>#allocationGranularity */
static sqInt NoDbgRegParms
allocationGranularity(VMMemoryMap * self_in_allocationGranularity)
{
	
#  if WIN32
	{
		return 64 * 1024;
	}
#  else /* WIN32 */
	{
		return 0;
	}
#  endif /* WIN32 */
	return self_in_allocationGranularity;
}
/* VMMemoryMap>>#calculateMaskToUse */
static VMMemoryMap * NoDbgRegParms
calculateMaskToUse(VMMemoryMap * self_in_calculateMaskToUse)
{
	uint64_t _allOnes;
	uint64_t _newSpaceFirst;
	uint64_t _newSpaceLast;
	uint64_t _newSpaceMaskAttempt;
	uint64_t _oldSpaceFirst;
	uint64_t _oldSpaceLast;
	uint64_t _oldSpaceMaskAttempt;

	{
		_allOnes = 0xFFFFFFFFFFFFFFFFULL;
	}
	_newSpaceFirst = 14495514624LL;
	_newSpaceLast = 0xFFFFFFFFFFLL;
	_newSpaceMaskAttempt = (_newSpaceLast - _newSpaceFirst) ^ _allOnes;
	_oldSpaceFirst = 0x10000000000LL;
	_oldSpaceLast = 0x1FFFFFFFFFFLL;
	_oldSpaceMaskAttempt = (_oldSpaceLast - _oldSpaceFirst) ^ _allOnes;
	(self_in_calculateMaskToUse->spaceMaskToUse = _newSpaceMaskAttempt & _oldSpaceMaskAttempt);
	if (((self_in_calculateMaskToUse->spaceMaskToUse)) == 0) {
		error("Could not calculate mask to use to identify new/old/perm objects");
	}
	(self_in_calculateMaskToUse->newSpaceMask = 14495514624LL & ((self_in_calculateMaskToUse->spaceMaskToUse)));
	(self_in_calculateMaskToUse->oldSpaceMask = 0x10000000000LL & ((self_in_calculateMaskToUse->spaceMaskToUse)));
	(self_in_calculateMaskToUse->permSpaceMask = 0x20000000000LL & ((self_in_calculateMaskToUse->spaceMaskToUse)));
	return self_in_calculateMaskToUse;
}
/* VMMemoryMap>>#ensureAtLeastPermSpaceOf: */
static sqInt NoDbgRegParms
ensureAtLeastPermSpaceOf(VMMemoryMap * self_in_ensureAtLeastPermSpaceOf, sqInt _requestedSize)
{
	sqInt _classIndex;
	sqInt _diff;
	sqInt _extendedAddress;
	sqInt _requestedSize2;

	if (_requestedSize == 0) {
		return 1;
	}
	if (((self_in_ensureAtLeastPermSpaceOf->permSpaceStart)) == 0) {
		(self_in_ensureAtLeastPermSpaceOf->initialPermSpaceSize = _requestedSize);
		allocatePermObjectsSpace(self_in_ensureAtLeastPermSpaceOf);
		/* begin allocateSlotsInPermSpace:format:classIndex: */
		_classIndex = arrayClassIndexPun();
		allocateSlotsInPermSpacebytesformatclassIndex(0, 8 + BaseHeaderSize, 0, _classIndex);
		/* end allocateSlotsInPermSpace:format:classIndex: */
		return 1;
	}
	_diff = _requestedSize - (permSpaceSize(self_in_ensureAtLeastPermSpaceOf));
	if (_diff <= 0) {
		return 1;
	}
	/* begin extendPermObjectsSpaceBy: */
	_requestedSize2 = roundToAllocationSize(self_in_ensureAtLeastPermSpaceOf, _diff);
	_extendedAddress = allocateMemoryBaseAddress(_requestedSize2, (self_in_ensureAtLeastPermSpaceOf->permSpaceEnd));
	if (_extendedAddress != ((self_in_ensureAtLeastPermSpaceOf->permSpaceEnd))) {
		logError("Could not extend perm space.");
		return 0;
	}
	(self_in_ensureAtLeastPermSpaceOf->permSpaceEnd = ((self_in_ensureAtLeastPermSpaceOf->permSpaceEnd)) + _requestedSize2);
	return 1;
	/* end extendPermObjectsSpaceBy: */
}
/* VMMemoryMap>>#extendPermObjectsSpaceMinimum: */
static sqInt NoDbgRegParms
extendPermObjectsSpaceMinimum(VMMemoryMap * self_in_extendPermObjectsSpaceMinimum, sqInt _minimalSize)
{
	sqInt _extendedAddress;
	sqInt _requestedSize;
	int _size;

	_size = 0;
	while (_size < _minimalSize) {
		_size += (10 * 1024) * 1024;
	}
	if (((self_in_extendPermObjectsSpaceMinimum->permSpaceStart)) == 0) {
		return ensureAtLeastPermSpaceOf(self_in_extendPermObjectsSpaceMinimum, _size);
	}
	/* begin extendPermObjectsSpaceBy: */
	_requestedSize = roundToAllocationSize(self_in_extendPermObjectsSpaceMinimum, _size);
	_extendedAddress = allocateMemoryBaseAddress(_requestedSize, (self_in_extendPermObjectsSpaceMinimum->permSpaceEnd));
	if (_extendedAddress != ((self_in_extendPermObjectsSpaceMinimum->permSpaceEnd))) {
		logError("Could not extend perm space.");
		return 0;
	}
	(self_in_extendPermObjectsSpaceMinimum->permSpaceEnd = ((self_in_extendPermObjectsSpaceMinimum->permSpaceEnd)) + _requestedSize);
	return 1;
	/* end extendPermObjectsSpaceBy: */
}
/* VMMemoryMap>>#fixedPermSpaceStart */
sqInt
fixedPermSpaceStart(VMMemoryMap * self_in_fixedPermSpaceStart)
{
	return 0x20000000000LL;
}
/* VMMemoryMap>>#getNewSpaceStart */
uint64_t
getNewSpaceStart(VMMemoryMap * self_in_getNewSpaceStart)
{
	return (self_in_getNewSpaceStart->newSpaceStart);
}
/* VMMemoryMap>>#getOldSpaceStart */
uint64_t
getOldSpaceStart(VMMemoryMap * self_in_getOldSpaceStart)
{
	return (self_in_getOldSpaceStart->oldSpaceStart);
}
/* VMMemoryMap>>#isInCodeZone: */
sqInt
isInCodeZone(VMMemoryMap * self_in_isInCodeZone, sqInt _anOop)
{
	return (_anOop >= ((self_in_isInCodeZone->codeZoneStart))) && (_anOop < ((self_in_isInCodeZone->codeZoneEnd)));
}
/* VMMemoryMap>>#isOldObject: */
sqInt
isOldObject(VMMemoryMap * self_in_isOldObject, sqInt _anOop)
{
	return (_anOop & ((self_in_isOldObject->spaceMaskToUse))) == ((self_in_isOldObject->oldSpaceMask));
}
/* VMMemoryMap>>#isPermanentObject: */
sqInt
isPermanentObject(VMMemoryMap * self_in_isPermanentObject, sqInt _anOop)
{
	return _anOop >= 0x20000000000LL;
}
/* VMMemoryMap>>#isYoungObject: */
sqInt
isYoungObject(VMMemoryMap * self_in_isYoungObject, sqInt _anOop)
{
	return ((_anOop & ((self_in_isYoungObject->spaceMaskToUse))) == ((self_in_isYoungObject->newSpaceMask))) && (_anOop >= ((self_in_isYoungObject->newSpaceStart)));
}
/* VMMemoryMap>>#permSpaceSize */
static int64_t NoDbgRegParms
permSpaceSize(VMMemoryMap * self_in_permSpaceSize)
{
	return ((self_in_permSpaceSize->permSpaceEnd)) - ((self_in_permSpaceSize->permSpaceStart));
}
/*	First we round up to Page Size, and then we calculate the min with the 
	platform granularity */
/* VMMemoryMap>>#roundToAllocationSize: */
static sqInt NoDbgRegParms
roundToAllocationSize(VMMemoryMap * self_in_roundToAllocationSize, sqInt _anInteger)
{
	sqInt _pageMask;
	sqInt _pageSize;
	sqInt _rounded;

	_pageSize = getpagesize();
	_pageMask = ~((usqIntptr_t) (_pageSize - 1) );
	_rounded = _anInteger & _pageMask;
	if (_rounded < _anInteger) {
		_rounded += _pageSize;
	}
	return ((_rounded < (allocationGranularity(self_in_roundToAllocationSize))) ? allocationGranularity(self_in_roundToAllocationSize) : _rounded);
}
/*	The first object space in the memory map is the newSpace. */
/* VMMemoryMap>>#startOfObjectMemory */
uint64_t
startOfObjectMemory(VMMemoryMap * self_in_startOfObjectMemory)
{
	return (self_in_startOfObjectMemory->newSpaceStart);
}
/* VMRememberedSet>>#countNotNilObjects */
static sqInt NoDbgRegParms
countNotNilObjects(VMRememberedSet * self_in_countNotNilObjects)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _count;
	sqInt _i;

	_count = 0;
	for (_i = 0; _i <= ((self_in_countNotNilObjects->rememberedSetLimit)); _i += 1) {
		if ((((self_in_countNotNilObjects->rememberedSetArray)[_i]) == GIV(nilObj)) || (((self_in_countNotNilObjects->rememberedSetArray)[_i]) == 0)) {
			return _i;
		}
		_count = _i;
	}
	return _count;
}
/* VMRememberedSet>>#forgetObject: */
static VMRememberedSet * NoDbgRegParms
forgetObject(VMRememberedSet * self_in_forgetObject, sqInt _objOop)
{
	sqInt _aNewValue;
	sqInt _aValue;
	sqLong _index;

	assert(((self_in_forgetObject->rememberedSetSize)) > 0);
	assert(isRemembered(_objOop));
	/* begin setIsRememberedOf:to: */
	/* begin unsignedLong64At:put: */
	_aValue = (uint64AtPointer(_objOop)) & (~((usqIntptr_t) (1U << (rememberedBitShift())) ));
	uint64AtPointerput(_objOop, _aValue);
	/* end unsignedLong64At:put: */
	/* end setIsRememberedOf:to: */
	if (!(_objOop == ((self_in_forgetObject->rememberedSetArray)[((self_in_forgetObject->rememberedSetSize)) - 1]))) {
		_index = 0;
		while (_index < ((self_in_forgetObject->rememberedSetSize))) {
			if (_objOop == ((self_in_forgetObject->rememberedSetArray)[_index])) {
				(self_in_forgetObject->rememberedSetArray)[_index] = (self_in_forgetObject->rememberedSetArray)[((self_in_forgetObject->rememberedSetSize)) - 1];
				_index = (self_in_forgetObject->rememberedSetSize);
			} else {
				_index += 1;
			}
		}
	}
	/* begin setRememberedSetSize: */
	_aNewValue = ((self_in_forgetObject->rememberedSetSize)) - 1;
	(self_in_forgetObject->rememberedSetSize) = _aNewValue;
	if (_aNewValue < ((self_in_forgetObject->rememberedSetLimit))) {
		(self_in_forgetObject->rememberedSetArray)[_aNewValue] = 0;
	}
	/* end setRememberedSetSize: */
	assert(((self_in_forgetObject->rememberedSetSize)) >= 0);
	return self_in_forgetObject;
}
/* VMRememberedSet>>#growRememberedSet */
static VMRememberedSet * NoDbgRegParms
growRememberedSet(VMRememberedSet * self_in_growRememberedSet)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt *_base;
	sqInt _i;
	sqInt _newObj;
	sqInt _nSlots;
	sqInt _nSlots2;
	sqInt _nSlots3;
	usqInt _numSlots;
	usqInt _numSlots2;
	sqInt _obj;
	sqInt _obj2;
	sqInt _obj3;
	sqInt _obj4;
	sqInt _objStackRootIndex;
	usqInt _p;
	usqInt _p2;
	usqInt _p3;
	sqInt _rootIndex;

	/* begin objStackAt: */
	_objStackRootIndex = (self_in_growRememberedSet->rootIndex);
	/* begin fetchPointer:ofObject: */
	_obj = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _objStackRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end objStackAt: */
	/* begin numSlotsOf: */
	assert((classIndexOf(_obj)) > (isForwardedObjectClassIndexPun()));
	_numSlots2 = byteAt(_obj + 7);
	_numSlots = ((_numSlots2 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(_obj - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : _numSlots2);
	/* end numSlotsOf: */
	assert(_numSlots >= 1024);
	/* begin allocatePinnedSlots: */
	_nSlots3 = _numSlots * 2;
	_obj4 = allocateSlotsForPinningInOldSpacebytesformatclassIndex(_nSlots3, ((_nSlots3 == 0)
		 ? 8 + BaseHeaderSize
		 : ((sqInt) (((usqInt) _nSlots3 ) << (shiftForWord())) ) + (((_nSlots3 >= (numSlotsMask()))
			 ? BaseHeaderSize + BaseHeaderSize
			 : BaseHeaderSize))), sixtyFourBitIndexableFormat(), sixtyFourBitLongsClassIndexPun());
	if (_obj4) {
		/* begin fillObj:numSlots:with: */
		assert(oopisLessThan(((_obj4 + BaseHeaderSize) + (_nSlots3 * BytesPerOop)) - 1, addressAfter(_obj4)));
		for (_p3 = ((usqInt) (_obj4 + BaseHeaderSize) ); _p3 <= ((usqInt) (((_obj4 + BaseHeaderSize) + (_nSlots3 * BytesPerOop)) - 1) ); _p3 += 8) {
			longAtput(_p3, 0);
		}
		/* end fillObj:numSlots:with: */
	}
	_newObj = _obj4;
	/* end allocatePinnedSlots: */
	if (!_newObj) {
		/* begin allocatePinnedSlots: */
		_nSlots2 = _numSlots + 1024;
		_obj3 = allocateSlotsForPinningInOldSpacebytesformatclassIndex(_nSlots2, ((_nSlots2 == 0)
			 ? 8 + BaseHeaderSize
			 : ((sqInt) (((usqInt) _nSlots2 ) << (shiftForWord())) ) + (((_nSlots2 >= (numSlotsMask()))
				 ? BaseHeaderSize + BaseHeaderSize
				 : BaseHeaderSize))), sixtyFourBitIndexableFormat(), sixtyFourBitLongsClassIndexPun());
		if (_obj3) {
			/* begin fillObj:numSlots:with: */
			assert(oopisLessThan(((_obj3 + BaseHeaderSize) + (_nSlots2 * BytesPerOop)) - 1, addressAfter(_obj3)));
			for (_p2 = ((usqInt) (_obj3 + BaseHeaderSize) ); _p2 <= ((usqInt) (((_obj3 + BaseHeaderSize) + (_nSlots2 * BytesPerOop)) - 1) ); _p2 += 8) {
				longAtput(_p2, 0);
			}
			/* end fillObj:numSlots:with: */
		}
		_newObj = _obj3;
		/* end allocatePinnedSlots: */
		if (!_newObj) {
			if (!(growOldSpaceByAtLeastcallingOperation((_numSlots + 1024) * BytesPerWord, "growing remembered set"))) {
				error("could not grow remembered set");
			}
			/* begin allocatePinnedSlots: */
			_nSlots = _numSlots + 1024;
			_obj2 = allocateSlotsForPinningInOldSpacebytesformatclassIndex(_nSlots, ((_nSlots == 0)
				 ? 8 + BaseHeaderSize
				 : ((sqInt) (((usqInt) _nSlots ) << (shiftForWord())) ) + (((_nSlots >= (numSlotsMask()))
					 ? BaseHeaderSize + BaseHeaderSize
					 : BaseHeaderSize))), sixtyFourBitIndexableFormat(), sixtyFourBitLongsClassIndexPun());
			if (_obj2) {
				/* begin fillObj:numSlots:with: */
				assert(oopisLessThan(((_obj2 + BaseHeaderSize) + (_nSlots * BytesPerOop)) - 1, addressAfter(_obj2)));
				for (_p = ((usqInt) (_obj2 + BaseHeaderSize) ); _p <= ((usqInt) (((_obj2 + BaseHeaderSize) + (_nSlots * BytesPerOop)) - 1) ); _p += 8) {
					longAtput(_p, 0);
				}
				/* end fillObj:numSlots:with: */
			}
			_newObj = _obj2;
			/* end allocatePinnedSlots: */
		}
	}
	/* begin rememberedSet:oop: */
	_rootIndex = (self_in_growRememberedSet->rootIndex);
	assert(isOldObject(GIV(memoryMap), _newObj));
	{
		assert(!(isOopForwarded(GIV(hiddenRootsObj))));
		longAtput((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _rootIndex ) << (shiftForWord())) ), _newObj);
	}
	/* end rememberedSet:oop: */
	_base = ((sqInt *) (firstIndexableField(_newObj)) );
	for (_i = 0; _i < ((self_in_growRememberedSet->rememberedSetSize)); _i += 1) {
		_base[_i] = (self_in_growRememberedSet->rememberedSetArray)[_i];
	}
	if (((((usqInt) (longAt(_obj)) ) >> (markedBitFullShift())) & 1) != 0) {
		{
			/* begin setIsMarkedOf:to: */
			assert(!(isFreeObject(_newObj)));
			unsignedLongAtput(_newObj, (unsignedLongAt(_newObj)) | (1ULL << (markedBitFullShift())));
			/* end setIsMarkedOf:to: */
			/* begin setIsMarkedOf:to: */
			assert(!(isFreeObject(_obj)));
			unsignedLongAtput(_obj, (unsignedLongAt(_obj)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
			/* end setIsMarkedOf:to: */
		}
	}
	freeObject(_obj);
	(self_in_growRememberedSet->rememberedSetArray = _base);
	(self_in_growRememberedSet->rememberedSetLimit = numSlotsOf(_newObj));
	/* begin setRememberedSetRedZone */
	(self_in_growRememberedSet->rememberedSetRedZone = (((((self_in_growRememberedSet->rememberedSetLimit)) - 4) < ((self_in_growRememberedSet->fudge))) ? (self_in_growRememberedSet->fudge) : ((self_in_growRememberedSet->rememberedSetLimit)) - 4));
	/* end setRememberedSetRedZone */
	return self_in_growRememberedSet;
}
/* VMRememberedSet>>#initializeRememberedSetShouldStartEmpty: */
static VMRememberedSet * NoDbgRegParms
initializeRememberedSetShouldStartEmpty(VMRememberedSet * self_in_initializeRememberedSetShouldStartEmpty, sqInt _shouldStartEmpty)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _format;
	sqInt _obj;
	sqInt _obj2;
	sqInt _objStackRootIndex;
	usqInt _p;
	sqInt _rootIndex;

	/* begin objStackAt: */
	_objStackRootIndex = (self_in_initializeRememberedSetShouldStartEmpty->rootIndex);
	/* begin fetchPointer:ofObject: */
	_obj = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _objStackRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end objStackAt: */
	if (_obj == GIV(nilObj)) {
		/* begin allocatePinnedSlots: */
		_obj2 = allocateSlotsForPinningInOldSpacebytesformatclassIndex(1024, (1024U << (shiftForWord())) + (BaseHeaderSize + BaseHeaderSize), sixtyFourBitIndexableFormat(), sixtyFourBitLongsClassIndexPun());
		if (_obj2) {
			/* begin fillObj:numSlots:with: */
			assert(oopisLessThan(((_obj2 + BaseHeaderSize) + (1024 * BytesPerOop)) - 1, addressAfter(_obj2)));
			for (_p = ((usqInt) (_obj2 + BaseHeaderSize) ); _p <= ((usqInt) (((_obj2 + BaseHeaderSize) + (1024 * BytesPerOop)) - 1) ); _p += 8) {
				longAtput(_p, 0);
			}
			/* end fillObj:numSlots:with: */
		}
		_obj = _obj2;
		/* end allocatePinnedSlots: */
		/* begin rememberedSet:oop: */
		_rootIndex = (self_in_initializeRememberedSetShouldStartEmpty->rootIndex);
		assert(isOldObject(GIV(memoryMap), _obj));
		{
			assert(!(isOopForwarded(GIV(hiddenRootsObj))));
			longAtput((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _rootIndex ) << (shiftForWord())) ), _obj);
		}
		/* end rememberedSet:oop: */
	} else {
		/* begin setFormatOf:to: */
		_format = sixtyFourBitIndexableFormat();
		assert((_format >= 0) && (_format <= (formatMask())));
		longAtput(_obj, ((longAt(_obj)) & (~((usqIntptr_t) ((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) ))) + ((sqInt) (((usqInt) _format ) << (formatShift())) ));
		/* end setFormatOf:to: */
	}
	assert((formatOf(_obj)) == (wordIndexableFormat()));
	assert(isPinned(_obj));
	(self_in_initializeRememberedSetShouldStartEmpty->rememberedSetArray = ((sqInt *) (firstIndexableField(_obj)) ));
	(self_in_initializeRememberedSetShouldStartEmpty->rememberedSetLimit = numSlotsOf(_obj));
	if (_shouldStartEmpty) {
		(self_in_initializeRememberedSetShouldStartEmpty->rememberedSetSize) = 0;
	} else {
		(self_in_initializeRememberedSetShouldStartEmpty->rememberedSetSize) = countNotNilObjects(self_in_initializeRememberedSetShouldStartEmpty);
	}
	/* begin setRememberedSetRedZone */
	(self_in_initializeRememberedSetShouldStartEmpty->rememberedSetRedZone = (((((self_in_initializeRememberedSetShouldStartEmpty->rememberedSetLimit)) - 4) < ((self_in_initializeRememberedSetShouldStartEmpty->fudge))) ? (self_in_initializeRememberedSetShouldStartEmpty->fudge) : ((self_in_initializeRememberedSetShouldStartEmpty->rememberedSetLimit)) - 4));
	/* end setRememberedSetRedZone */
	return self_in_initializeRememberedSetShouldStartEmpty;
}
/* VMRememberedSet>>#isInRememberedSet: */
static sqInt NoDbgRegParms
isInRememberedSet(VMRememberedSet * self_in_isInRememberedSet, sqInt _objOop)
{
	sqInt _i;

	for (_i = 0; _i < ((self_in_isInRememberedSet->rememberedSetSize)); _i += 1) {
		if (((self_in_isInRememberedSet->rememberedSetArray)[_i]) == _objOop) {
			return 1;
		}
	}
	return 0;
}
/* VMRememberedSet>>#objectOop */
static sqInt NoDbgRegParms
objectOop(VMRememberedSet * self_in_objectOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _objStackRootIndex;

	/* begin objStackAt: */
	_objStackRootIndex = (self_in_objectOop->rootIndex);
	/* begin fetchPointer:ofObject: */
	return unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _objStackRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end objStackAt: */
}
/* VMRememberedSet>>#rememberedSetArrayPointerFromObject: */
static sqInt * NoDbgRegParms
rememberedSetArrayPointerFromObject(VMRememberedSet * self_in_rememberedSetArrayPointerFromObject, sqInt _anOop)
{
	return ((sqInt *) (firstIndexableField(_anOop)) );
}
/* VMRememberedSet>>#rememberWithoutMarkingAsRemembered: */
sqInt
rememberWithoutMarkingAsRemembered(VMRememberedSet * self_in_rememberWithoutMarkingAsRemembered, sqInt _objOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt _aNewValue;

	assert(isNonImmediate(_objOop));
	assert(!(isYoungObject(getMemoryMap(), _objOop)));
	if (((self_in_rememberWithoutMarkingAsRemembered->rememberedSetSize)) >= ((self_in_rememberWithoutMarkingAsRemembered->rememberedSetLimit))) {
		growRememberedSet(self_in_rememberWithoutMarkingAsRemembered);
		if (!((self_in_rememberWithoutMarkingAsRemembered->doFullScan))) {
			/* begin scheduleScavenge */
			GIV(needGCFlag) = 1;
			forceInterruptCheck();
			/* end scheduleScavenge */
		}
	}
	(self_in_rememberWithoutMarkingAsRemembered->rememberedSetArray)[(self_in_rememberWithoutMarkingAsRemembered->rememberedSetSize)] = _objOop;
	/* begin setRememberedSetSize: */
	_aNewValue = ((self_in_rememberWithoutMarkingAsRemembered->rememberedSetSize)) + 1;
	(self_in_rememberWithoutMarkingAsRemembered->rememberedSetSize) = _aNewValue;
	if (_aNewValue < ((self_in_rememberWithoutMarkingAsRemembered->rememberedSetLimit))) {
		(self_in_rememberWithoutMarkingAsRemembered->rememberedSetArray)[_aNewValue] = 0;
	}
	/* end setRememberedSetSize: */
	return _objOop;
}
/*	Add the argument to the remembered set and set its isRemembered bit to 
	true. Answer the argument for the benefit of the Cogit. */
/* VMRememberedSet>>#remember: */
sqInt
remember(VMRememberedSet * self_in_remember, sqInt _objOop)
{
	sqInt _aValue;

	assert(!(isInRememberedSet(self_in_remember, _objOop)));
	/* begin setIsRememberedOf:to: */
	/* begin unsignedLong64At:put: */
	_aValue = (uint64AtPointer(_objOop)) | (1U << (rememberedBitShift()));
	uint64AtPointerput(_objOop, _aValue);
	/* end unsignedLong64At:put: */
	/* end setIsRememberedOf:to: */
	return rememberWithoutMarkingAsRemembered(self_in_remember, _objOop);
}
/* VMRememberedSet>>#shrinkRememberedSet */
static VMRememberedSet * NoDbgRegParms
shrinkRememberedSet(VMRememberedSet * self_in_shrinkRememberedSet)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt *_base;
	sqInt _i;
	sqInt _newObj;
	sqInt _numSlots;
	sqInt _obj;
	sqInt _obj2;
	sqInt _obj3;
	sqInt _obj4;
	sqInt _objStackRootIndex;
	usqInt _p;
	usqInt _p2;
	usqInt _p3;
	sqInt _rootIndex;

	if (!(((self_in_shrinkRememberedSet->rememberedSetLimit)) >= 2048)) {
		return self_in_shrinkRememberedSet;
	}
	if (!(((self_in_shrinkRememberedSet->rememberedSetSize)) < (((self_in_shrinkRememberedSet->rememberedSetLimit)) / 2))) {
		return self_in_shrinkRememberedSet;
	}
	/* begin objectOop */
	/* begin objStackAt: */
	_objStackRootIndex = (self_in_shrinkRememberedSet->rootIndex);
	/* begin fetchPointer:ofObject: */
	_obj = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _objStackRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end objStackAt: */
	/* end objectOop */
	_numSlots = ((((numSlotsOf(_obj)) / 2) < 2048) ? 2048 : (numSlotsOf(_obj)) / 2);
	/* begin allocatePinnedSlots: */
	_obj4 = allocateSlotsForPinningInOldSpacebytesformatclassIndex(_numSlots, ((_numSlots == 0)
		 ? 8 + BaseHeaderSize
		 : ((sqInt) (((usqInt) _numSlots ) << (shiftForWord())) ) + (((_numSlots >= (numSlotsMask()))
			 ? BaseHeaderSize + BaseHeaderSize
			 : BaseHeaderSize))), sixtyFourBitIndexableFormat(), sixtyFourBitLongsClassIndexPun());
	if (_obj4) {
		/* begin fillObj:numSlots:with: */
		assert(oopisLessThan(((_obj4 + BaseHeaderSize) + (_numSlots * BytesPerOop)) - 1, addressAfter(_obj4)));
		for (_p3 = ((usqInt) (_obj4 + BaseHeaderSize) ); _p3 <= ((usqInt) (((_obj4 + BaseHeaderSize) + (_numSlots * BytesPerOop)) - 1) ); _p3 += 8) {
			longAtput(_p3, 0);
		}
		/* end fillObj:numSlots:with: */
	}
	_newObj = _obj4;
	/* end allocatePinnedSlots: */
	if (!_newObj) {
		/* begin allocatePinnedSlots: */
		_obj3 = allocateSlotsForPinningInOldSpacebytesformatclassIndex(_numSlots, ((_numSlots == 0)
			 ? 8 + BaseHeaderSize
			 : ((sqInt) (((usqInt) _numSlots ) << (shiftForWord())) ) + (((_numSlots >= (numSlotsMask()))
				 ? BaseHeaderSize + BaseHeaderSize
				 : BaseHeaderSize))), sixtyFourBitIndexableFormat(), sixtyFourBitLongsClassIndexPun());
		if (_obj3) {
			/* begin fillObj:numSlots:with: */
			assert(oopisLessThan(((_obj3 + BaseHeaderSize) + (_numSlots * BytesPerOop)) - 1, addressAfter(_obj3)));
			for (_p2 = ((usqInt) (_obj3 + BaseHeaderSize) ); _p2 <= ((usqInt) (((_obj3 + BaseHeaderSize) + (_numSlots * BytesPerOop)) - 1) ); _p2 += 8) {
				longAtput(_p2, 0);
			}
			/* end fillObj:numSlots:with: */
		}
		_newObj = _obj3;
		/* end allocatePinnedSlots: */
		if (!_newObj) {
			if (!(growOldSpaceByAtLeastcallingOperation(_numSlots * BytesPerWord, "shrinking RememberedSet"))) {
				error("could not shrink remembered set");
			}
			/* begin allocatePinnedSlots: */
			_obj2 = allocateSlotsForPinningInOldSpacebytesformatclassIndex(_numSlots, ((_numSlots == 0)
				 ? 8 + BaseHeaderSize
				 : ((sqInt) (((usqInt) _numSlots ) << (shiftForWord())) ) + (((_numSlots >= (numSlotsMask()))
					 ? BaseHeaderSize + BaseHeaderSize
					 : BaseHeaderSize))), sixtyFourBitIndexableFormat(), sixtyFourBitLongsClassIndexPun());
			if (_obj2) {
				/* begin fillObj:numSlots:with: */
				assert(oopisLessThan(((_obj2 + BaseHeaderSize) + (_numSlots * BytesPerOop)) - 1, addressAfter(_obj2)));
				for (_p = ((usqInt) (_obj2 + BaseHeaderSize) ); _p <= ((usqInt) (((_obj2 + BaseHeaderSize) + (_numSlots * BytesPerOop)) - 1) ); _p += 8) {
					longAtput(_p, 0);
				}
				/* end fillObj:numSlots:with: */
			}
			_newObj = _obj2;
			/* end allocatePinnedSlots: */
		}
	}
	/* begin rememberedSet:oop: */
	_rootIndex = (self_in_shrinkRememberedSet->rootIndex);
	assert(isOldObject(GIV(memoryMap), _newObj));
	{
		assert(!(isOopForwarded(GIV(hiddenRootsObj))));
		longAtput((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) _rootIndex ) << (shiftForWord())) ), _newObj);
	}
	/* end rememberedSet:oop: */
	_base = ((sqInt *) (firstIndexableField(_newObj)) );
	for (_i = 0; _i < ((self_in_shrinkRememberedSet->rememberedSetSize)); _i += 1) {
		_base[_i] = (self_in_shrinkRememberedSet->rememberedSetArray)[_i];
	}
	if (((((usqInt) (longAt(_obj)) ) >> (markedBitFullShift())) & 1) != 0) {
		{
			/* begin setIsMarkedOf:to: */
			assert(!(isFreeObject(_newObj)));
			unsignedLongAtput(_newObj, (unsignedLongAt(_newObj)) | (1ULL << (markedBitFullShift())));
			/* end setIsMarkedOf:to: */
			/* begin setIsMarkedOf:to: */
			assert(!(isFreeObject(_obj)));
			unsignedLongAtput(_obj, (unsignedLongAt(_obj)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
			/* end setIsMarkedOf:to: */
		}
	}
	freeObject(_obj);
	(self_in_shrinkRememberedSet->rememberedSetArray = _base);
	(self_in_shrinkRememberedSet->rememberedSetLimit = numSlotsOf(_newObj));
	/* begin setRememberedSetRedZone */
	(self_in_shrinkRememberedSet->rememberedSetRedZone = (((((self_in_shrinkRememberedSet->rememberedSetLimit)) - 4) < ((self_in_shrinkRememberedSet->fudge))) ? (self_in_shrinkRememberedSet->fudge) : ((self_in_shrinkRememberedSet->rememberedSetLimit)) - 4));
	/* end setRememberedSetRedZone */
	return self_in_shrinkRememberedSet;
}
/*	For assert-checking */
/* VMStackPage>>#addressIsInPage: */
static sqInt NoDbgRegParms
addressIsInPage(StackPage * self_in_addressIsInPage, char *_address)
{
	return (((self_in_addressIsInPage->lastAddress)) < _address) && (_address < ((self_in_addressIsInPage->baseAddress)));
}
/* VMStackPage>>#isFree */
static sqInt NoDbgRegParms
isFree(StackPage * self_in_isFree)
{
	return ((self_in_isFree->baseFP)) == 0;
}
/*	<InterpreterStackPage>MRUP-->used page<->used page<->used page<->used page<--LRUP 
	^ <-next-prev-> ^ 
	| | 
	v <-prev-next-> v 
	free page<->free page<->free page<->free page */
/* VMStackPages>>#freeStackPageNoAssert: */
static void NoDbgRegParms
freeStackPageNoAssert(StackPage *_aPage)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	StackPage *_prev;

	(_aPage->baseFP = 0);
	if (_aPage == GIV(mostRecentlyUsedPage)) {
		GIV(mostRecentlyUsedPage) = (GIV(mostRecentlyUsedPage)->prevPage);
		{
			return;
		}
	}
	if (((((_prev = (_aPage->prevPage)))->baseFP)) == 0) {
		{
			return;
		}
	}
	(_prev->nextPage = (_aPage->nextPage));
	(((_aPage->nextPage))->prevPage = _prev);
	(_aPage->nextPage = (GIV(mostRecentlyUsedPage)->nextPage));
	(((GIV(mostRecentlyUsedPage)->nextPage))->prevPage = _aPage);
	(_aPage->prevPage = GIV(mostRecentlyUsedPage));
	(GIV(mostRecentlyUsedPage)->nextPage = _aPage);
}
/*	<InterpreterStackPage>MRUP-->used page<->used page<->used page<->used page<--LRUP 
	^ <-next-prev-> ^ 
	| | 
	v <-prev-next-> v 
	free page<->free page<->free page<->free page */
/* VMStackPages>>#freeStackPage: */
static sqInt NoDbgRegParms
freeStackPage(StackPage *_aPage)
{
	freeStackPageNoAssert(_aPage);
	assert(pageListIsWellFormed());
	return 0;
}
/*	<InterpreterStackPage>MRUP-->used page<->used page<->used page<->used page<--LRUP 
	^ <-next-prev-> ^ 
	| | 
	v <-prev-next-> v 
	free page<->free page<->free page<->free page */
/* VMStackPages>>#markStackPageMostRecentlyUsed: */
static void NoDbgRegParms
markStackPageMostRecentlyUsed(StackPage *_page)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	if (_page == GIV(mostRecentlyUsedPage)) {
		{
			return;
		}
	}
	if (((_page->prevPage)) == GIV(mostRecentlyUsedPage)) {
		GIV(mostRecentlyUsedPage) = _page;
		assert(pageListIsWellFormed());
		{
			return;
		}
	}
	(((_page->prevPage))->nextPage = (_page->nextPage));
	(((_page->nextPage))->prevPage = (_page->prevPage));
	(((GIV(mostRecentlyUsedPage)->nextPage))->prevPage = _page);
	(_page->prevPage = GIV(mostRecentlyUsedPage));
	(_page->nextPage = (GIV(mostRecentlyUsedPage)->nextPage));
	(GIV(mostRecentlyUsedPage)->nextPage = _page);
	GIV(mostRecentlyUsedPage) = _page;
	assert(pageListIsWellFormed());
}
/*	<InterpreterStackPage>This method is used to move a page to a position in the list such that it 
	cannot be deallocated when a new page is allocated, without changing the 
	most recently 
	used page. There must be at least 3 pages in the system. So making the 
	page the MRU's prevPage is sufficient to ensure it won't be deallocated.MRUP-->used page<->used page<->used page<->used page<--LRUP 
	^ <-next-prev-> ^ 
	| | 
	v <-prev-next-> v 
	free page<->free page<->free page<->free page */
/* VMStackPages>>#markStackPageNextMostRecentlyUsed: */
static void NoDbgRegParms
markStackPageNextMostRecentlyUsed(StackPage *_page)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	assert(_page != GIV(mostRecentlyUsedPage));
	if (((_page->nextPage)) == GIV(mostRecentlyUsedPage)) {
		{
			return;
		}
	}
	(((_page->prevPage))->nextPage = (_page->nextPage));
	(((_page->nextPage))->prevPage = (_page->prevPage));
	(((GIV(mostRecentlyUsedPage)->prevPage))->nextPage = _page);
	(_page->prevPage = (GIV(mostRecentlyUsedPage)->prevPage));
	(_page->nextPage = GIV(mostRecentlyUsedPage));
	(GIV(mostRecentlyUsedPage)->prevPage = _page);
	assert(pageListIsWellFormed());
}
/*	MRUP-->used page<->used page<->used page<->used page<--LRUP 
	^ <-next-prev-> ^ 
	| | 
	v <-prev-next-> v 
	free page<->free page<->free page<->free page */
/* VMStackPages>>#newStackPage */
static StackPage *
newStackPage(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	StackPage *_lruOrFree;

	_lruOrFree = (GIV(mostRecentlyUsedPage)->nextPage);
	if (((_lruOrFree->baseFP)) == 0) {
		return _lruOrFree;
	}
	divorceFramesIn(_lruOrFree);
	return _lruOrFree;
}
/*	<Integer>Answer the page index for a pointer into stack memory, i.e. the index 
	for the page the address is in. N.B. This is a zero-relative index. */
/* VMStackPages>>#pageIndexFor: */
static sqInt NoDbgRegParms
pageIndexFor(void *_pointer)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	assert((((char *) _pointer ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _pointer ) <= ((char *) GIV(pages) )));
	return pageIndexForstackBasePlus1bytesPerPage(_pointer, GIV(stackBasePlus1), GIV(bytesPerPage));
}
/*	Answer if the stack page list is well-formed. 
	MRUP-->used page<->used page<->used page<->used page<--LRUP 
	^ <-next-prev-> ^ 
	| | 
	v <-prev-next-> v 
	free page<->free page<->free page<->free page */
/* VMStackPages>>#pageListIsWellFormed */
static sqInt
pageListIsWellFormed(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	int _count;
	sqInt _limit;
	int _ok;
	StackPage *_page;

	_ok = 1;
	_page = (GIV(mostRecentlyUsedPage)->nextPage);
	_count = 1;
	_limit = GIV(numStackPages) * 2;
	while ((((_page->baseFP)) == 0) && ((_page != GIV(mostRecentlyUsedPage)) && (_count <= _limit))) {
		if (!(asserta(((((_page->nextPage))->prevPage)) == _page))) {
			_ok = 0;
		}
		_page = (_page->nextPage);
		_count += 1;
	}
	while ((_page != GIV(mostRecentlyUsedPage)) && (_count <= _limit)) {
		if (!(asserta(((((_page->nextPage))->prevPage)) == _page))) {
			_ok = 0;
		}
		if (asserta(!(isFree(_page)))) {
			if (!(asserta((addressIsInPage(_page, (_page->baseFP))) && (addressIsInPage(_page, (_page->headSP)))))) {
				_ok = 0;
			}
		} else {
			_ok = 0;
		}
		_page = (_page->nextPage);
		_count += 1;
	}
	if (!(asserta(_count == (numStkPages())))) {
		_ok = 0;
	}
	return _ok;
}
/*	Answer the page for a page index. 
	N.B. This is a zero-relative index. */
/* VMStackPages>>#stackPageAt: */
static StackPage * NoDbgRegParms
stackPageAt(sqInt _index)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return stackPageAtpages(_index, GIV(pages));
}
/*	<Integer> */
/* VMStackPages>>#stackPageFor: */
static StackPage * NoDbgRegParms
stackPageFor(void *_pointer)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	/* begin stackPageAt: */
	return stackPageAtpages((assert((((char *) _pointer ) >= (GIV(stackBasePlus1) - 1)) && (((char *) _pointer ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(_pointer, GIV(stackBasePlus1), GIV(bytesPerPage))), GIV(pages));
	/* end stackPageAt: */
}
/* VMStackPages>>#statAverageLivePagesWhenMapping */
static double
statAverageLivePagesWhenMapping0(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((GIV(statNumMaps) == 0)
		 ? 0.0
		 : ((double) GIV(statPageCountWhenMappingSum) ) / GIV(statNumMaps));
}


static char _m[] = "";
void* vm_exports[][3] = {
#if FEATURE_THREADED_FFI
	{(void*)_m, "doPrimitiveWorkerCallout\000\377", (void*)doPrimitiveWorkerCallout},
#endif /* FEATURE_THREADED_FFI */
	{(void*)_m, "moduleUnloaded", (void*)moduleUnloaded},
	{(void*)_m, "primitiveAddLargeIntegers\000\377", (void*)primitiveAddLargeIntegers},
	{(void*)_m, "primitiveAllInstances\000\377", (void*)primitiveAllInstances},
	{(void*)_m, "primitiveAllObjects\000\377", (void*)primitiveAllObjects},
	{(void*)_m, "primitiveBitAndLargeIntegers\000\377", (void*)primitiveBitAndLargeIntegers},
	{(void*)_m, "primitiveBitOrLargeIntegers\000\377", (void*)primitiveBitOrLargeIntegers},
	{(void*)_m, "primitiveBitShiftLargeIntegers\000\377", (void*)primitiveBitShiftLargeIntegers},
	{(void*)_m, "primitiveBitXorLargeIntegers\000\377", (void*)primitiveBitXorLargeIntegers},
	{(void*)_m, "primitiveCompareBytes\000\377", (void*)primitiveCompareBytes},
	{(void*)_m, "primitiveDivideLargeIntegers\000\377", (void*)primitiveDivideLargeIntegers},
	{(void*)_m, "primitiveDivLargeIntegers\000\377", (void*)primitiveDivLargeIntegers},
	{(void*)_m, "primitiveEqualLargeIntegers\000\377", (void*)primitiveEqualLargeIntegers},
	{(void*)_m, "primitiveFFIAllocate\000\377", (void*)primitiveFFIAllocate},
	{(void*)_m, "primitiveFFIFree\000\377", (void*)primitiveFFIFree},
	{(void*)_m, "primitiveFFIIntegerAt\000\377", (void*)primitiveFFIIntegerAt},
	{(void*)_m, "primitiveFFIIntegerAtPut\000\377", (void*)primitiveFFIIntegerAtPut},
	{(void*)_m, "primitiveGetCurrentWorkingDirectory\000\377", (void*)primitiveGetCurrentWorkingDirectory},
	{(void*)_m, "primitiveGetenv\000\377", (void*)primitiveGetenv},
	{(void*)_m, "primitiveGreaterOrEqualLargeIntegers\000\377", (void*)primitiveGreaterOrEqualLargeIntegers},
	{(void*)_m, "primitiveGreaterThanLargeIntegers\000\377", (void*)primitiveGreaterThanLargeIntegers},
	{(void*)_m, "primitiveHeartbeatFrequency\000\377", (void*)primitiveHeartbeatFrequency},
	{(void*)_m, "primitiveHighResClock\000\377", (void*)primitiveHighResClock},
	{(void*)_m, "primitiveImageFormatVersion\000\377", (void*)primitiveImageFormatVersion},
	{(void*)_m, "primitiveInterruptChecksPerMSec\000\377", (void*)primitiveInterruptChecksPerMSec},
	{(void*)_m, "primitiveIsBigEnder\000\377", (void*)primitiveIsBigEnder},
	{(void*)_m, "primitiveLessOrEqualLargeIntegers\000\377", (void*)primitiveLessOrEqualLargeIntegers},
	{(void*)_m, "primitiveLessThanLargeIntegers\000\377", (void*)primitiveLessThanLargeIntegers},
	{(void*)_m, "primitiveLoadSymbolFromModule\000\377", (void*)primitiveLoadSymbolFromModule},
	{(void*)_m, "primitiveLongRunningPrimitive\000\377", (void*)primitiveLongRunningPrimitive},
	{(void*)_m, "primitiveLongRunningPrimitiveSemaphore\000\377", (void*)primitiveLongRunningPrimitiveSemaphore},
	{(void*)_m, "primitiveMethodPCData\000\377", (void*)primitiveMethodPCData},
	{(void*)_m, "primitiveMethodProfilingData\000\377", (void*)primitiveMethodProfilingData},
	{(void*)_m, "primitiveMillisecondClockMask\000\377", (void*)primitiveMillisecondClockMask},
	{(void*)_m, "primitiveMinimumUnusedHeadroom\000\377", (void*)primitiveMinimumUnusedHeadroom},
	{(void*)_m, "primitiveModLargeIntegers\000\377", (void*)primitiveModLargeIntegers},
	{(void*)_m, "primitiveMultiplyLargeIntegers\000\377", (void*)primitiveMultiplyLargeIntegers},
	{(void*)_m, "primitiveNotEqualLargeIntegers\000\377", (void*)primitiveNotEqualLargeIntegers},
	{(void*)_m, "primitiveProfilePrimitive\000\377", (void*)primitiveProfilePrimitive},
	{(void*)_m, "primitiveProfileSample\000\377", (void*)primitiveProfileSample},
	{(void*)_m, "primitiveProfileSemaphore\000\377", (void*)primitiveProfileSemaphore},
	{(void*)_m, "primitiveProfileStart\000\377", (void*)primitiveProfileStart},
	{(void*)_m, "primitiveQuoLargeIntegers\000\377", (void*)primitiveQuoLargeIntegers},
	{(void*)_m, "primitiveRemLargeIntegers\000\377", (void*)primitiveRemLargeIntegers},
	{(void*)_m, "primitiveSameThreadCallout\000\377", (void*)primitiveSameThreadCallout},
	{(void*)_m, "primitiveSetGCSemaphore\000\377", (void*)primitiveSetGCSemaphore},
	{(void*)_m, "primitiveStringCompareWith\000\377", (void*)primitiveStringCompareWith},
	{(void*)_m, "primitiveSubtractLargeIntegers\000\377", (void*)primitiveSubtractLargeIntegers},
	{(void*)_m, "primitiveUtcWithOffset\000\377", (void*)primitiveUtcWithOffset},
	{(void*)_m, "primitiveVoidReceiver\000\377", (void*)primitiveVoidReceiver},
	{(void*)_m, "primitiveWorkerCallout\000\377", (void*)primitiveWorkerCallout},
	{(void*)_m, "primitiveWorkerExtractReturnValue\000\377", (void*)primitiveWorkerExtractReturnValue},
	{(void*)_m, "printFramesInPage", (void*)printFramesInPage},
	{(void*)_m, "printFramesOnStackPageListInUse\000\377", (void*)printFramesOnStackPageListInUse},
	{(void*)_m, "segmentContainingObj", (void*)segmentContainingObj},
	{(void*)_m, "shortPrintFramesInPage", (void*)shortPrintFramesInPage},
	{(void*)_m, "shortPrintFramesOnStackPageListInUse\000\377", (void*)shortPrintFramesOnStackPageListInUse},
	{(void*)_m, "statNumGCs\000\377", (void*)statNumGCs},
	{NULL, NULL, NULL}
};

void initGlobalStructure(void) {
#if SQ_USE_GLOBAL_STRUCT_REG
foo = &fum;
#endif
}
