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


/* Automatically generated by
	CCodeGeneratorGlobalStructure Melchor-tonel.1 uuid: 81d34bf2-89f7-0d00-b120-3b4100d6ef30
   from
	CoInterpreter VMMaker-tonel.1 uuid: 51dc9af2-89f7-0d00-b124-986800d6ef30
 */
static char __buildInfo[] = "CoInterpreter VMMaker-tonel.1 uuid: 51dc9af2-89f7-0d00-b124-986800d6ef30 " __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 "sqMemoryFence.h"
#include "dispdbg.h"
#include "vmMemoryMap.h"
#include "vmRememberedSet.h"
#include "sqCogStackAlignment.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. */
#if SPURVM
	vm_printf("\nClass %s does not have the required class index\n", s);
#else
	vm_printf("\nClass %s does not have the required compact class index\n", s);
#endif
	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 ClassBlockClosure null
#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 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 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 {
	size_t	dataSize;
	squeakFileOffsetType	startAddress;
 } 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 segmentDataFileinImage(sqInt segmentIndex, sqInt imageFileName);
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 sqInt ceInterpretMethodFromPICreceiver(sqInt aMethodObj, sqInt rcvr);
extern sqInt ceMNUFromPICMNUMethodreceiver(sqInt aMethodObj, sqInt rcvr);
extern sqInt ceNewHashOf(sqInt anObject);
extern sqInt ceNonLocalReturn(sqInt returnValue);
extern void ceReapAndResetErrorCodeFor(CogMethod *cogMethod);
extern sqInt ceReturnToInterpreter(sqInt anOop);
extern sqInt ceSendAborttonumArgs(sqInt selector, sqInt rcvr, sqInt numArgs);
extern sqInt ceSendFromInLineCacheMiss(CogMethod *cogMethodOrPIC);
extern void ceSendMustBeBooleanTointerpretingAtDelta(sqInt aNonBooleanObject, sqInt jumpSize);
extern sqInt ceSendMustBeBoolean(sqInt anObject);
extern void ceSendaboveClassBindingtonumArgs(sqInt selector, sqInt methodClassBinding, sqInt rcvr, sqInt numArgs);
extern sqInt ceSendabovetonumArgs(sqInt selector, sqInt methodClass, sqInt rcvr, sqInt numArgs);
extern sqInt ceSendsupertonumArgs(sqInt selector, sqInt superNormalBar, sqInt rcvr, 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);
static sqInt NoDbgRegParms checkOkayFields(sqInt oop);
static sqInt checkStackIntegrity(void);
extern void clearTraceLog(void);
extern CogMethod * cogMethodOf(sqInt aMethodOop);
static void commenceCogCompiledCodeCompaction(void);
extern void compilationBreakpointFor(sqInt selectorOop);
static sqInt NoDbgRegParms contextInstructionPointerframe(sqInt theIP, 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);
static void NoDbgRegParms followForwardingPointersInStackZone(sqInt theBecomeEffectsFlags);
extern void forceInterruptCheckFromHeartbeat(void);
static sqInt NoDbgRegParms frameCallerContext(char *theFP);
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 handleForwardedSendFaultForReceiverstackDelta(sqInt forwardedReceiver, sqInt stackDelta);
static sqInt NoDbgRegParms handleMNUInMachineCodeToclassForMessage(sqInt selectorIndex, sqInt rcvr, sqInt classForMessage);
static sqInt NoDbgRegParms iframeIsBlockActivation(char *theFP);
static sqInt NoDbgRegParms iframeReceiver(char *theFP);
static sqInt NoDbgRegParms iframeSavedIP(char *theFP);
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 sqInt 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 lookupMNUreceiver(sqInt selector, sqInt rcvr);
extern sqInt lookupOrdinaryreceiver(sqInt selector, sqInt rcvr);
static StackPage * NoDbgRegParms makeBaseFrameFor(sqInt aContext);
static void mapPrimTraceLog(void);
static void NeverInline mapStackPages(void);
static void mapTraceLog(void);
extern void markActiveMethodsAndReferents(void);
static void markAndTracePrimTraceLog(void);
static void NoDbgRegParms markAndTraceStackPage(StackPage *thePage);
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 char * NoDbgRegParms moveFramesInthroughtoPage(StackPage *oldPage, char *theFP, StackPage *newPage);
static sqInt NoDbgRegParms mustMapMachineCodePCcontext(sqInt theIP, sqInt aOnceMarriedContext);
extern usqInt newMethodAddress(void);
static sqInt NoDbgRegParms newMethodInLookupCacheAtand(sqInt selector, sqInt classTag);
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);
static void NoDbgRegParms printFrameThingatextraString(char *name, char *address, char *extraStringOrNil);
static void NoDbgRegParms printFrameThingatextra(char *name, char *address, sqInt extraValue);
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 sqInt rawHeaderOf(sqInt methodPointer);
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);
static sqInt NoDbgRegParms shortPrintFrame(char *theFP);
extern usqInt stackLimitAddress(void);
static sqInt stackLimitOffset(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);
static sqInt NoDbgRegParms validStackPageBaseFrame(StackPage *aPage);
extern usqInt varBaseAddress(void);
static sqInt NoDbgRegParms voidVMStateForSnapshotFlushingExternalPrimitivesIf(sqInt flushExtPrims);
extern char * whereIs(sqInt anOop);
static void NoDbgRegParms NeverInline widowOrForceToBytecodePC(sqInt ctxt);
static sqInt NoDbgRegParms frameIsMarked(sqInt theFPInt);
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 void unmarkAllFrames(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 primitiveClearVMProfile(void);
EXPORT(sqInt) primitiveClockLogAddresses(void);
static void primitiveCoarseLocalMicrosecondClock(void);
static void primitiveCoarseUTCMicrosecondClock(void);
static void primitiveConstantFill(void);
static void primitiveControlVMProfiling(void);
static void primitiveCopyObject(void);
EXPORT(sqInt) primitiveCrashVM(void);
EXPORT(sqInt) primitiveDisablePowerManager(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 primitiveFormat(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 */
EXPORT(sqInt) primitiveGetLogDirectory(void);
EXPORT(sqInt) primitiveGetWindowLabel(void);
EXPORT(sqInt) primitiveGetWindowSize(void);
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);
EXPORT(sqInt) primitiveIsWindowObscured(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);
EXPORT(sqInt) primitivePathToUsing(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);
EXPORT(sqInt) primitiveScreenDepth(void);
EXPORT(sqInt) primitiveScreenScaleFactor(void);
static void primitiveSecondsClock(void);
#if IMMUTABILITY
static void primitiveSetImmutability(void);
#else
# define primitiveSetImmutability (void (*)(void))0
#endif /* IMMUTABILITY */
EXPORT(sqInt) primitiveSetLogDirectory(void);
static void primitiveSetOrHasIdentityHash(void);
EXPORT(sqInt) primitiveSetWindowLabel(void);
EXPORT(sqInt) primitiveSetWindowSize(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 primitiveVMProfileSamplesInto(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 sqInt NoDbgRegParms changeClassOfto(sqInt rcvr, sqInt argClass);
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);
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);
extern sqInt checkOopHasOkayClass(usqInt obj);
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 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);
static sqInt NoDbgRegParms followObjFieldofObject(sqInt fieldIndex, sqInt anObject);
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);
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);
static sqInt NoDbgRegParms okayOop(sqInt signedOop);
extern sqInt oldSpaceObjectAfter(sqInt objOop);
static size_t oldSpaceSizeToWrite(void);
static void NoDbgRegParms NeverInline outOfPlaceBecomeandcopyHashFlag(sqInt obj1, sqInt obj2, sqInt copyHashFlag);
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);
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);
EXPORT(sqInt) callbackLeave(sqInt cbID);
extern sqInt canContextSwitchIfActivatingheader(sqInt theMethod, sqInt methodHeader);
extern sqInt characterForAscii(sqInt ascii);
extern sqInt checkAllAccessibleObjectsOkay(void);
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);
extern sqInt checkOkayInterpreterObjects(sqInt writeBack);
static sqInt NoDbgRegParms checkOkayStackPage(StackPage *thePage);
static sqInt NoDbgRegParms checkOkayStackZone(sqInt writeBack);
static void NoDbgRegParms checkProfileTick(sqInt aPrimitiveMethod);
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 void dummyReferToProxy(void);
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);
extern sqInt forceInterruptCheck(void);
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,sqInt theClass))(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 usqInt NoDbgRegParms iframeMethod(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 lookupMNUInClass(sqInt class);
static sqInt NoDbgRegParms lookupOrdinaryNoMNUEtcInClass(sqInt class);
extern sqInt lookupSelectorinClass(sqInt selector, sqInt class);
static void NoDbgRegParms makeContextSnapshotSafe(sqInt ctxt);
extern usqInt makePointwithxValueyValue(sqInt xValue, sqInt yValue);
static void mapInterpreterOops(void);
static sqInt NoDbgRegParms markAndTraceStackPages(sqInt fullGCFlag);
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 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);
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);
EXPORT(sqInt) reestablishContextPriorToCallback(sqInt callbackContext);
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 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);
extern void shortPrintFrameAndNCallers(char *theFP, sqInt n);
static sqInt NoDbgRegParms shortPrintOop(sqInt oop);
static sqInt NoDbgRegParms shortReversePrintFrameAndCallers(char *aFramePointer);
extern void showDisplayBitsLeftTopRightBottom(sqInt aForm, sqInt l, sqInt t, sqInt r, sqInt b);
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);
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 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 */
static sqInt NoDbgRegParms fieldOrSenderFPofContext(sqInt index, sqInt contextObj);
static sqInt NoDbgRegParms fieldofFrame(sqInt index, char *theFP);
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);
static void NoDbgRegParms pruneStackstackp(sqInt anArray, sqInt stackp);
extern sqInt ptEnterInterpreterFromCallback(void *aPointer);
extern sqInt ptExitInterpreterToCallback(void *aPointer);
extern void * readAddress(sqInt anOop);
static void unmarkAfterPathTo(void);
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 usqInt * 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 statAverageLivePagesWhenMapping(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 char * instructionPointer;
_iss usqInt newMethod;
_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 sqInt falseObj;
_iss usqInt totalFreeOldSpace;
_iss usqInt pastSpaceStart;
_iss sqInt bytesPerPage;
_iss sqInt numSegments;
_iss SpurContiguousObjStack * permSpaceForwardersToCleanUp;
_iss sqInt needGCFlag;
_iss sqInt * freeLists;
_iss unsigned char primTraceLogIndex;
_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 sqInt remapBufferCount;
_iss sqInt lkupClass;
_iss sqLong nextProfileTick;
_iss SpurScavengeLogRecord scavengeLogRecord;
_iss sqInt numStackPages;
_iss sqInt tempOop;
_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 sqInt ephemeronList;
_iss char * objStackInvalidBecause;
_iss sqInt sweepIndex;
_iss sqInt longRunningPrimitiveCheckMethod;
_iss sqInt tenureCriterion;
_iss usqInt totalHeapSizeIncludingBridges;
_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 tempOop2;
_iss sqInt maxSlotsForNewSpaceAlloc;
_iss sqInt pendingFinalizationSignals;
_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 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 jmpDepth;
_iss sqInt maxStacksToPrint;
_iss sqInt methodDictLinearSearchLimit;
_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 statFullGCs;
_iss sqInt statMaxPageCountWhenMapping;
_iss sqInt statPageCountWhenMappingSum;
_iss double tenuringProportion;
_iss sqInt classByteArrayCompactIndex;
_iss sqInt deferSmash;
_iss sqInt deferredSmash;
_iss sqInt extraFramesToMoveOnOverflow;
_iss sqInt imageFloatsBigEndian;
_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 memoryManager;
_iss usqLong nextPollUsecs;
_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 remapBuffer[RemapBufferSize + 1 /* 26 */];
_iss sqInt *extraRoots[ExtraRootsSize + 1 /* 2049 */];
_iss usqInt suspendedCallbacks[MaxJumpBuf + 1 /* 33 */];
_iss usqInt suspendedMethods[MaxJumpBuf + 1 /* 33 */];
_iss usqInt byteCount;
_iss sqInt cifs;
_iss sqInt codeGeneratorToComputeAccessorDepth;
_iss sqInt compactionStartUsecs;
_iss sqInt composedImageWriter;
_iss sqInt extA;
_iss sqInt extB;
_iss sqInt firstSegmentSize;
_iss sqInt fullScreenFlag;
_iss sqInt functions;
_iss sqInt gcMarkEndUsecs;
_iss sqInt initialMemoryAddress;
_iss sqInt jmpBuf;
_iss sqInt lkupClassTag;
_iss usqInt messageCount;
_iss sqInt nextAddress;
_iss sqInt numExtB;
_iss sqInt preferredPinningSegment;
_iss sqInt savedWindowSize;
_iss sqInt spurImageWriter;
_iss sqInt statCoalesces;
_iss usqLong statFGCDeltaUsecs;
_iss sqInt testWorker;
_iss sqInt theUnknownShort;
_iss sqInt traceSources;
#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 breakLookupClassTag;
sqInt breakSelectorLength = MinSmallInteger;
sqInt desiredEdenBytes;
sqInt extraVMMemory;
sqInt desiredNumStackPages;
usqInt maxOldSpaceSize;
sqInt desiredCogCodeSize;
char * breakSelector;
void * displayBits;
sqInt suppressHeartbeatFlag;
int displayHeight;
int displayWidth;
int displayDepth;
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 */ primitiveCompareBytes,
	/* 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 */ primitiveFormat,
	/* 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 */ primitiveClearVMProfile,
	/* 251 */ primitiveControlVMProfiling,
	/* 252 */ primitiveVMProfileSamplesInto,
	/* 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, 0,-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, 0,-1,-1,-1,-1,-1,-1,-1,-1,
/*240*/	-1,-1, 0,-1, 0,-1,-1,-1, 0,-1,-1, 0, 0, 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
	};
sqInt checkedPluginName;
sqInt debugCallbackInvokes;
sqInt debugCallbackPath;
sqInt debugCallbackReturns;
char expensiveAsserts = 0;
sqInt ffiExceptionResponse;
struct VirtualMachine* interpreterProxy;
const char *interpreterVersion = "Croquet Closure Cog[Spur] VM [CoInterpreterPrimitives VMMaker-tonel.1]";
static void (*interruptCheckChain)(void) = 0;
sqInt minBackwardJumpCountForCompile = MinBackwardJumpCountForCompile /* 40 */;
volatile int sendTrace;
int (*showSurfaceFn)(sqIntptr_t, int, int, int, int);


/*** 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 compilationBreakpointisMNUCase(sel, len, isMNU) do { \
	if ((len) == (isMNU ? -breakSelectorLength : breakSelectorLength) \
	 && !strncmp((char *)((sel) + BaseHeaderSize), breakSelector, (isMNU ? -breakSelectorLength : breakSelectorLength))) { \
		suppressHeartbeatFlag = 1; \
		compilationBreakpointFor(sel); \
	} \
} while (0)
#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 freeStart() 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 statMaxPageCountWhenMapping() 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;
	VMMemoryMap *aMemoryMap;
	int count;
	register sqInt currentBytecode CB_REG;
	sqInt extA;
	sqInt extB;
	sqInt i;
	sqInt index;
	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 numPages;
	StackPage *page;
	char *pageStructBase;
	sqInt slotsPerPage;
	sqInt stackAddress;
	sqInt stackPageBytes;
	sqInt stackPagesBytes;
	sqInt stackSlots;
	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 */
		sqMakeMemoryNotExecutableFromTo(((usqInt) (startOfObjectMemory(getMemoryMap())) ), ((usqInt) (((getMemoryMap())->oldSpaceEnd)) ));
		{
			/* 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)) - ((((256 * BytesPerWord) < (((stackPageByteSize()) - ((IFrameSlots + 64) * BytesPerWord)) - (osCogStackPageHeadroom()))) ? 256 * BytesPerWord : ((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: */
			/* begin stackPagesInitializedAt:totalSize:pageSize: */
			sqMakeMemoryNotExecutableFromTo(((usqInt) theStackMemory ), ((usqInt) theStackMemory ) + stackPagesBytes);
			assert((minimumUnusedHeadroom()) == stackPageBytes);
			/* end stackPagesInitializedAt:totalSize: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;
			}
		}
		{
			GIV(framePointer) = local_framePointer;
			GIV(instructionPointer) = local_instructionPointer;
			GIV(stackPointer) = local_stackPointer;
			return null;
		}
		/* end initStackPagesAndInterpret */
	}
	/* begin initExtensions */
	{
		GIV(extA) = (GIV(numExtB) = (GIV(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;
						char *sp;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

						{
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							/* begin pushReceiverVariable: */
							/* begin push: */
							object = unsignedLongAt(((longAt(local_framePointer + FoxIFReceiver)) + BaseHeaderSize) + 120);
							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);
					{
						char *sp;

						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin push: */
						unsignedLongAtput((sp = local_stackPointer - BytesPerWord), longAt(local_framePointer + FoxIFReceiver));
						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 objOop1;
						char *sp;
						sqInt theThingToPush;

						switch (GIV(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 l26;
								}
								theThingToPush = marryFrameSP(local_framePointer, local_stackPointer);
								l26:
								;
								/* end ensureFrameIsMarried:SP: */
							}
							break;
							case 1:
							{
								/* begin memoryActiveProcess */
								/* begin fetchPointer:ofObject: */
								/* begin fetchPointer:ofObject: */
								/* begin splObj: */
								/* begin fetchPointer:ofObject: */
								objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								/* end splObj: */
								objOop = unsignedLongAt((objOop1 + 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: */
						GIV(extB) = 0;
						GIV(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 ourContext;
						char *sp;
						sqInt t0;
						int t2;
						int t3;
						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 l455;
						}
						ourContext = marryFrameSP(theFP, theSP);
						l455:
						;
						/* 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 = longAt(local_framePointer + FoxIFReceiver);
						/* end receiver */
						/* goto commonReturn */
					}
				}
				commonReturn:
/* commonReturn */
				{
					VM_LABEL(commonReturn);
					{
						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;
						sqInt t17;
						char *theFP;
						char *theFP1;
						char *theFP2;
						char *theFP3;
						char *theFP4;
						char *theFP5;
						StackPage *thePage;
						StackPage *thePage2;
						StackPage *thePage3;
						StackPage *thePage4;
						char *theSP;
						char *theSP1;
						char *theSP2;
						char *theSP3;
						sqInt unwindContextOrNilOrZero;
						sqInt valuePointer;
						sqInt valuePointer1;

						frameToReturnTo = ((char *) 0 );
						theFP = ((char *) 0 );
						if (!((byteAt((local_framePointer + FoxIFrameFlags) + 3)) != 0)) {
							goto commonCallerReturn;
							goto l456;
						}
						/* begin writeBackHeadFramePointers */
						assert((local_framePointer - local_stackPointer) < (LargeContextSlots * BytesPerOop));
						assert(GIV(stackPage) == (mostRecentlyUsedPage()));
						assert(!(isFree(GIV(stackPage))));
						/* begin setHeadFP:andSP:inPage: */
						theSP3 = local_stackPointer;
						assert(theSP3 < local_framePointer);
						assert((theSP3 < ((GIV(stackPage)->baseAddress))) && (theSP3 > (((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 = theSP3);
						}
						/* 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: */
								theFP1 = local_framePointer;
								theSP = local_stackPointer;
								if (((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP1 + FoxMethod)) )))
									 ? ((unsignedLongAt(theFP1 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
									 : (byteAt((theFP1 + FoxIFrameFlags) + 2)) != 0)) {
									assert(isContext(frameContext(theFP1)));
									ourContext = unsignedLongAt(theFP1 + FoxThisContext);
									goto l470;
								}
								ourContext = marryFrameSP(theFP1, theSP);
								l470:
								;
								/* 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 l476;
								l476:
								;
								/* end sendCannotReturn: */
								goto l456;
							}
							/* 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: */
							theFP2 = local_framePointer;
							theSP1 = local_stackPointer;
							if (((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP2 + FoxMethod)) )))
								 ? ((unsignedLongAt(theFP2 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
								 : (byteAt((theFP2 + FoxIFrameFlags) + 2)) != 0)) {
								assert(isContext(frameContext(theFP2)));
								ourContext2 = unsignedLongAt(theFP2 + FoxThisContext);
								goto l491;
							}
							ourContext2 = marryFrameSP(theFP2, theSP1);
							l491:
							;
							/* 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 l485;
							l485:
							;
							/* end sendCannotReturn: */
							goto l456;
						}
						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 l473;
							}
							ourContext3 = marryFrameSP(local_framePointer, local_stackPointer);
							l473:
							;
							/* 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 l467;
							l467:
							;
							/* end internalAboutToReturn:through: */
							goto l456;
						}
						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(instructionPointer) = local_instructionPointer;
								GIV(stackPointer) = local_stackPointer;
								t0 = establishFrameForContextToReturnTo(contextToReturnTo);
								local_instructionPointer = GIV(instructionPointer);
								local_stackPointer = GIV(stackPointer);
							}
							frameToReturnTo = t0;
							if (frameToReturnTo == 0) {
								/* 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)));
									ourContext4 = unsignedLongAt(theFP3 + FoxThisContext);
									goto l477;
								}
								ourContext4 = marryFrameSP(theFP3, theSP2);
								l477:
								;
								/* 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 l472;
								l472:
								;
								/* end sendCannotReturn: */
								goto l456;
							}
						}
						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: */
							theFP5 = (GIV(stackPage)->baseFP);
							assert(isBaseFrame(theFP5));
							/* begin stackPageFor: */
							/* begin stackPageAt: */
							thePage4 = stackPageAtpages((assert((((char *) theFP5 ) >= (GIV(stackBasePlus1) - 1)) && (((char *) theFP5 ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(theFP5, 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: */
									theFP4 = (thePage->baseFP);
									assert(isBaseFrame(theFP4));
									/* begin stackPageFor: */
									/* begin stackPageAt: */
									thePage3 = stackPageAtpages((assert((((char *) theFP4 ) >= (GIV(stackBasePlus1) - 1)) && (((char *) theFP4 ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(theFP4, 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: */
										valuePointer1 = GIV(nilObj);
										assert(!(isOopForwarded(currentCtx)));
										longAtput((currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), valuePointer1);
										/* 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: */
								/* end returnToMachineCodeFrame */
								goto l458;
							}
							local_instructionPointer = pointerForOop(unsignedLongAt(local_framePointer + FoxIFSavedIP));
						}
						l458:
						;
						/* 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);
					}
				}
				l456:
				;
				/* 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 aMethodObj1;
						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))) {
									theSP = (thePage->headSP);
								} else {
									/* begin findFrameAbove:inPage: */
									fp = (thePage->headFP);
									if (fp == theFP) {
										frameAbove = 0;
										goto l496;
									}
									while (((callerFP = pointerForOop(unsignedLongAt(fp + FoxSavedFP)))) != 0) {
										if (callerFP == theFP) {
											frameAbove = fp;
											goto l496;
										}
										fp = callerFP;
									};
									error("did not find theFP in stack page");
									frameAbove = 0;
									l496:
									;
									/* end findFrameAbove:inPage: */
									/* begin newStackPage */
									lruOrFree = (GIV(mostRecentlyUsedPage)->nextPage);
									if (((lruOrFree->baseFP)) == 0) {
										newPage = lruOrFree;
										goto l503;
									}
									divorceFramesIn(lruOrFree);
									newPage = lruOrFree;
									l503:
									;
									/* end newStackPage */
									assert(newPage == GIV(stackPage));
									moveFramesInthroughtoPage(thePage, frameAbove, newPage);
									markStackPageMostRecentlyUsed(newPage);
									theFP = (thePage->headFP);
									theSP = (thePage->headSP);
								}
							} else {
								sqInt t0;
								StackPage * t3;

								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 l497;
								}
								local_instructionPointer = 0;
								{
									GIV(instructionPointer) = local_instructionPointer;
									GIV(stackPointer) = local_stackPointer;
									t3 = makeBaseFrameFor(contextToReturnTo);
									local_instructionPointer = GIV(instructionPointer);
									local_stackPointer = GIV(stackPointer);
								}
								thePage = t3;
								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: */
									/* end returnToMachineCodeFrame */
									goto l498;
								}
								local_instructionPointer = pointerForOop(unsignedLongAt(local_framePointer + FoxIFSavedIP));
							}
							l498:
							;
							/* end maybeReturnToMachineCodeFrame */
							assert(checkIsStillMarriedContextcurrentFP(contextToReturnTo, local_framePointer));
							/* begin setMethod: */
							aMethodObj1 = unsignedLongAt(local_framePointer + FoxMethod);
							assert(((usqInt) aMethodObj1 ) >= (startOfObjectMemory(getMemoryMap())));
							{
								GIV(method) = aMethodObj1;
								assert(isOopCompiledMethod(GIV(method)));
							}
							/* end setMethod: */
							unsignedLongAtput(local_stackPointer, localReturnValue);
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							goto l497;
							l497:
							;
							/* end baseFrameReturn */
							goto l492;
						}
						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: */
								/* end returnToMachineCodeFrame */
								goto l494;
							}
							local_instructionPointer = pointerForOop(unsignedLongAt(local_framePointer + FoxIFSavedIP));
						}
						l494:
						;
						/* 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);
					}
				}
				l492:
				;
				/* end case */
			}
			BREAK;
			CASE(95)
			{
				/* extNopBytecode */
				{
					VM_LABEL(extNopBytecode);
					{
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						GIV(numExtB) = (GIV(extA) = (GIV(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 l34;
							}
						} 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 l44;
									}
									rcvr2 = null;
									goto l44;
									/* 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 l44;
								}
							} else {
								if (((longAt(rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
									fetchFloatAtinto(rcvr + BaseHeaderSize, result3);
									rcvr2 = result3;
									goto l44;
								}
							}
							/* begin primitiveFail */
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
							/* end primitiveFail */
							rcvr2 = 0.0;
							l44:
							;
							/* 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 l37;
									}
									arg2 = null;
									goto l37;
									/* 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 l37;
								}
							} else {
								if (((longAt(arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
									fetchFloatAtinto(arg + BaseHeaderSize, result2);
									arg2 = result2;
									goto l37;
								}
							}
							/* begin primitiveFail */
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
							/* end primitiveFail */
							arg2 = 0.0;
							l37:
							;
							/* 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 l34;
							}
						}
						/* 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;
					}
				}
				l34:
				;
				/* 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 l45;
							}
						} 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 l55;
									}
									rcvr2 = null;
									goto l55;
									/* 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 l55;
								}
							} else {
								if (((longAt(rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
									fetchFloatAtinto(rcvr + BaseHeaderSize, result3);
									rcvr2 = result3;
									goto l55;
								}
							}
							/* begin primitiveFail */
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
							/* end primitiveFail */
							rcvr2 = 0.0;
							l55:
							;
							/* 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 l48;
									}
									arg2 = null;
									goto l48;
									/* 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 l48;
								}
							} else {
								if (((longAt(arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
									fetchFloatAtinto(arg + BaseHeaderSize, result2);
									arg2 = result2;
									goto l48;
								}
							}
							/* begin primitiveFail */
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
							/* end primitiveFail */
							arg2 = 0.0;
							l48:
							;
							/* 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 l45;
							}
						}
						/* 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;
					}
				}
				l45:
				;
				/* 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 l56;
						}
						/* 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 l62;
								}
								rcvr2 = null;
								goto l62;
								/* 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 l62;
							}
						} else {
							if (((longAt(rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(rcvr + BaseHeaderSize, result);
								rcvr2 = result;
								goto l62;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						rcvr2 = 0.0;
						l62:
						;
						/* 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 l65;
								}
								arg2 = null;
								goto l65;
								/* 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 l65;
							}
						} else {
							if (((longAt(arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(arg + BaseHeaderSize, result2);
								arg2 = result2;
								goto l65;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						arg2 = 0.0;
						l65:
						;
						/* end loadFloatOrIntFrom: */
						aBool = rcvr2 < arg2;
						/* end primitiveFloatLess:thanArg: */
						if (!GIV(primFailCode)) {
							/* begin booleanCheatSistaV1: */
							if (aBool) {
								goto booleanCheatTrueSistaV1;
							} else {
								goto booleanCheatFalseSistaV1;
							}
							/* end booleanCheatSistaV1: */
							goto l56;
						}
						/* 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;
					}
				}
				l56:
				;
				/* 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 l509;
							}
							if (bytecode == 239) {
								byteAtPointer(++local_instructionPointer);
								/* begin fetchNextBytecode */
								/* begin fetchByte */
								currentBytecode = byteAtPointer(++local_instructionPointer);
								/* end fetchByte */
								/* end fetchNextBytecode */
								goto l509;
							}
							if (bytecode == 238) {
								offset = byteAtPointer(++local_instructionPointer);
								/* begin jump: */
								local_instructionPointer = (local_instructionPointer + offset) + 1;
								currentBytecode = byteAtPointer(local_instructionPointer);
								/* end jump: */
								goto l509;
							}
						}
						currentBytecode = bytecode;
						/* begin push: */
						unsignedLongAtput((sp = local_stackPointer - BytesPerWord), GIV(trueObj));
						local_stackPointer = sp;
						/* end push: */
					}
				}
				l509:
				;
				/* 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 l66;
						}
						/* 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 l72;
								}
								rcvr2 = null;
								goto l72;
								/* 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 l72;
							}
						} else {
							if (((longAt(rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(rcvr + BaseHeaderSize, result);
								rcvr2 = result;
								goto l72;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						rcvr2 = 0.0;
						l72:
						;
						/* 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 l75;
								}
								arg2 = null;
								goto l75;
								/* 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 l75;
							}
						} else {
							if (((longAt(arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(arg + BaseHeaderSize, result2);
								arg2 = result2;
								goto l75;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						arg2 = 0.0;
						l75:
						;
						/* end loadFloatOrIntFrom: */
						aBool = rcvr2 > arg2;
						/* end primitiveFloatGreater:thanArg: */
						if (!GIV(primFailCode)) {
							/* begin booleanCheatSistaV1: */
							if (aBool) {
								goto booleanCheatTrueSistaV1;
							} else {
								goto booleanCheatFalseSistaV1;
							}
							/* end booleanCheatSistaV1: */
							goto l66;
						}
						/* 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;
					}
				}
				l66:
				;
				/* end case */
				booleanCheatFalseSistaV1:
/* booleanCheatFalseSistaV1 */
				{
					VM_LABEL(booleanCheatFalseSistaV1);
					{
						sqInt bytecode;
						sqInt offset;
						char *sp;
						int t5;
						int t6;

						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 l513;
						}
						if (bytecode == 239) {
							offset = byteAtPointer(++local_instructionPointer);
							/* begin jump: */
							local_instructionPointer = (local_instructionPointer + offset) + 1;
							currentBytecode = byteAtPointer(local_instructionPointer);
							/* end jump: */
							goto l513;
						}
						currentBytecode = bytecode;
						/* begin push: */
						unsignedLongAtput((sp = local_stackPointer - BytesPerWord), GIV(falseObj));
						local_stackPointer = sp;
						/* end push: */
					}
				}
				l513:
				;
				/* 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 l76;
						}
						/* 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 l82;
								}
								rcvr2 = null;
								goto l82;
								/* 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 l82;
							}
						} else {
							if (((longAt(rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(rcvr + BaseHeaderSize, result);
								rcvr2 = result;
								goto l82;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						rcvr2 = 0.0;
						l82:
						;
						/* 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 l85;
								}
								arg2 = null;
								goto l85;
								/* 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 l85;
							}
						} else {
							if (((longAt(arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(arg + BaseHeaderSize, result2);
								arg2 = result2;
								goto l85;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						arg2 = 0.0;
						l85:
						;
						/* end loadFloatOrIntFrom: */
						aBool = rcvr2 <= arg2;
						/* end primitiveFloatLessOrEqual:toArg: */
						if (!GIV(primFailCode)) {
							/* begin booleanCheatSistaV1: */
							if (aBool) {
								goto booleanCheatTrueSistaV1;
							} else {
								goto booleanCheatFalseSistaV1;
							}
							/* end booleanCheatSistaV1: */
							goto l76;
						}
						/* 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;
					}
				}
				l76:
				;
				/* 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 l86;
						}
						/* 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 l92;
								}
								rcvr2 = null;
								goto l92;
								/* 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 l92;
							}
						} else {
							if (((longAt(rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(rcvr + BaseHeaderSize, result);
								rcvr2 = result;
								goto l92;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						rcvr2 = 0.0;
						l92:
						;
						/* 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 l95;
								}
								arg2 = null;
								goto l95;
								/* 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 l95;
							}
						} else {
							if (((longAt(arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(arg + BaseHeaderSize, result2);
								arg2 = result2;
								goto l95;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						arg2 = 0.0;
						l95:
						;
						/* end loadFloatOrIntFrom: */
						aBool = rcvr2 >= arg2;
						/* end primitiveFloatGreaterOrEqual:toArg: */
						if (!GIV(primFailCode)) {
							/* begin booleanCheatSistaV1: */
							if (aBool) {
								goto booleanCheatTrueSistaV1;
							} else {
								goto booleanCheatFalseSistaV1;
							}
							/* end booleanCheatSistaV1: */
							goto l86;
						}
						/* 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;
					}
				}
				l86:
				;
				/* 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 l96;
						}
						/* 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 l102;
								}
								rcvr2 = null;
								goto l102;
								/* 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 l102;
							}
						} else {
							if (((longAt(rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(rcvr + BaseHeaderSize, result);
								rcvr2 = result;
								goto l102;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						rcvr2 = 0.0;
						l102:
						;
						/* 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 l105;
								}
								arg2 = null;
								goto l105;
								/* 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 l105;
							}
						} else {
							if (((longAt(arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(arg + BaseHeaderSize, result2);
								arg2 = result2;
								goto l105;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						arg2 = 0.0;
						l105:
						;
						/* end loadFloatOrIntFrom: */
						aBool = rcvr2 == arg2;
						/* end primitiveFloatEqual:toArg: */
						if (!GIV(primFailCode)) {
							/* begin booleanCheatSistaV1: */
							if (aBool) {
								goto booleanCheatTrueSistaV1;
							} else {
								goto booleanCheatFalseSistaV1;
							}
							/* end booleanCheatSistaV1: */
							goto l96;
						}
						/* 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;
					}
				}
				l96:
				;
				/* 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 l106;
						}
						/* 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 l112;
								}
								rcvr2 = null;
								goto l112;
								/* 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 l112;
							}
						} else {
							if (((longAt(rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(rcvr + BaseHeaderSize, result);
								rcvr2 = result;
								goto l112;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						rcvr2 = 0.0;
						l112:
						;
						/* 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 l115;
								}
								arg2 = null;
								goto l115;
								/* 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 l115;
							}
						} else {
							if (((longAt(arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
								fetchFloatAtinto(arg + BaseHeaderSize, result2);
								arg2 = result2;
								goto l115;
							}
						}
						/* begin primitiveFail */
						if (!GIV(primFailCode)) {
							GIV(primFailCode) = 1;
						}
						/* end primitiveFail */
						arg2 = 0.0;
						l115:
						;
						/* end loadFloatOrIntFrom: */
						aBool = rcvr2 == arg2;
						/* end primitiveFloatEqual:toArg: */
						if (!GIV(primFailCode)) {
							/* begin booleanCheatSistaV1: */
							if (!aBool) {
								goto booleanCheatTrueSistaV1;
							} else {
								goto booleanCheatFalseSistaV1;
							}
							/* end booleanCheatSistaV1: */
							goto l106;
						}
						/* 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;
					}
				}
				l106:
				;
				/* 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 l116;
							}
						} 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 l126;
									}
									rcvr2 = null;
									goto l126;
									/* 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 l126;
								}
							} else {
								if (((longAt(rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
									fetchFloatAtinto(rcvr + BaseHeaderSize, result3);
									rcvr2 = result3;
									goto l126;
								}
							}
							/* begin primitiveFail */
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
							/* end primitiveFail */
							rcvr2 = 0.0;
							l126:
							;
							/* 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 l119;
									}
									arg2 = null;
									goto l119;
									/* 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 l119;
								}
							} else {
								if (((longAt(arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
									fetchFloatAtinto(arg + BaseHeaderSize, result2);
									arg2 = result2;
									goto l119;
								}
							}
							/* begin primitiveFail */
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
							/* end primitiveFail */
							arg2 = 0.0;
							l119:
							;
							/* 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 l116;
							}
						}
						/* 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;
					}
				}
				l116:
				;
				/* 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 l127;
								}
							}
						} 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 l137;
									}
									rcvr2 = null;
									goto l137;
									/* 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 l137;
								}
							} else {
								if (((longAt(rcvr)) & (classIndexMask())) == ClassFloatCompactIndex) {
									fetchFloatAtinto(rcvr + BaseHeaderSize, result3);
									rcvr2 = result3;
									goto l137;
								}
							}
							/* begin primitiveFail */
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
							/* end primitiveFail */
							rcvr2 = 0.0;
							l137:
							;
							/* 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 l130;
									}
									arg2 = null;
									goto l130;
									/* 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 l130;
								}
							} else {
								if (((longAt(arg)) & (classIndexMask())) == ClassFloatCompactIndex) {
									fetchFloatAtinto(arg + BaseHeaderSize, result2);
									arg2 = result2;
									goto l130;
								}
							}
							/* begin primitiveFail */
							if (!GIV(primFailCode)) {
								GIV(primFailCode) = 1;
							}
							/* end primitiveFail */
							arg2 = 0.0;
							l130:
							;
							/* 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 l127;
							}
						}
						/* 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;
					}
				}
				l127:
				;
				/* 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 l138;
						}
						/* 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;
					}
				}
				l138:
				;
				/* end case */
			}
			BREAK;
			CASE(107)
			{
				/* bytecodePrimMakePoint */
				{
					VM_LABEL(bytecodePrimMakePoint);
					{
						sqInt arg;
						sqInt classFormat;
						sqInt classIndex;
						sqInt classObj;
						usqInt newObj;
						usqInt numBytes;
						sqInt numSlots;
						sqInt objFormat;
						sqInt objOop;
						usqInt pt;
						sqInt rcvr;
						char *sp;
						int t2;
						int t3;

						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 l143;
								}
							}
							long64Atput(newObj, ((((usqLong) numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) objFormat ) << (formatShift())) )) + classIndex);
							GIV(freeStart) += numBytes;
							pt = newObj;
							/* end allocateSmallNewSpaceSlots:format:classIndex: */
							/* end eeInstantiateSmallClassIndex:format:numSlots: */
							l143:
							;
							/* 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 l142;
						}
						/* 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;
					}
				}
				l142:
				;
				/* 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 l152;
						}
						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 l152;
								}
								shifted = ((sqInt) (((usqInt) integerReceiver ) << integerArgument) );
								if (!(integerReceiver == (((sqInt) shifted ) >> integerArgument))) {
									/* begin primitiveFail */
									if (!GIV(primFailCode)) {
										GIV(primFailCode) = 1;
									}
									/* end primitiveFail */
									goto l152;
								}
							} else {
								sqInt t1;

								if (!(integerArgument >= -61)) {
									/* begin primitiveFail */
									if (!GIV(primFailCode)) {
										GIV(primFailCode) = 1;
									}
									/* end primitiveFail */
									goto l152;
								}
								{
									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: */
						}
						l152:
						;
						/* end primitiveBitShift */
						if (!GIV(primFailCode)) {
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							goto l151;
						}
						/* 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;
					}
				}
				l151:
				;
				/* 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 l157;
						}
						/* 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;
					}
				}
				l157:
				;
				/* end case */
			}
			BREAK;
			CASE(110)
			{
				/* bytecodePrimBitAnd */
				{
					VM_LABEL(bytecodePrimBitAnd);
					{
						sqInt arg;
						sqInt objOop;
						sqInt rcvr;
						char *sp;
						sqInt t2;
						sqInt t3;

						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 l161;
						}
						/* 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 l161;
						}
						/* 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;
					}
				}
				l161:
				;
				/* end case */
			}
			BREAK;
			CASE(111)
			{
				/* bytecodePrimBitOr */
				{
					VM_LABEL(bytecodePrimBitOr);
					{
						sqInt arg;
						sqInt objOop;
						sqInt rcvr;
						char *sp;
						sqInt t2;
						sqInt t3;

						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 l166;
						}
						/* 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 l166;
						}
						/* 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;
					}
				}
				l166:
				;
				/* 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 classOop1;
						sqInt fmt;
						sqInt fmt1;
						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 l179;
						}
						/* begin isClassOfNonImm:equalTo:compactClassIndex: */
						assert(!(isImmediate(rcvr)));
						/* begin classIndexOf: */
						ccIndex = (longAt(rcvr)) & (classIndexMask());
						/* end classIndexOf: */
						{
							isString = ClassByteStringCompactIndex == ccIndex;
							goto l179;
						}
						/* end isClassOfNonImm:equalTo:compactClassIndex: */
						l179:
						;
						/* 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 l177;
							}
							if (fmt >= (firstByteFormat())) {
								sz = (numSlots << (shiftForWord())) - (fmt & 7);
								goto l177;
							}
							if (fmt >= (firstShortFormat())) {
								sz = (numSlots << ((shiftForWord()) - 1)) - (fmt & 3);
								goto l177;
							}
							if (fmt >= (firstLongFormat())) {
								sz = (numSlots << ((shiftForWord()) - 2)) - (fmt & 1);
								goto l177;
							}
							if (fmt == (sixtyFourBitIndexableFormat())) {
								sz = numSlots;
								goto l177;
							}
							sz = 0;
							l177:
							;
							/* end lengthOf:format: */
							unsignedLongAtput(local_stackPointer, ((((usqInt) sz ) << 3) | 1));
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							goto l175;
						}
						/* begin is:instanceOf:compactClassIndex: */
						classOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ));
						if (rcvr & (tagMask())) {
							isArray = 0;
							goto l176;
						}
						/* begin isClassOfNonImm:equalTo:compactClassIndex: */
						assert(!(isImmediate(rcvr)));
						/* begin classIndexOf: */
						ccIndex2 = (longAt(rcvr)) & (classIndexMask());
						/* end classIndexOf: */
						{
							isArray = ClassArrayCompactIndex == ccIndex2;
							goto l176;
						}
						/* end isClassOfNonImm:equalTo:compactClassIndex: */
						l176:
						;
						/* end is:instanceOf:compactClassIndex: */
						if (isArray) {
							usqInt t4;

							/* begin lengthOf:format: */
							fmt1 = (((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 (fmt1 <= 5) {
								sz = numSlots3;
								goto l178;
							}
							if (fmt1 >= (firstByteFormat())) {
								sz = (numSlots3 << (shiftForWord())) - (fmt1 & 7);
								goto l178;
							}
							if (fmt1 >= (firstShortFormat())) {
								sz = (numSlots3 << ((shiftForWord()) - 1)) - (fmt1 & 3);
								goto l178;
							}
							if (fmt1 >= (firstLongFormat())) {
								sz = (numSlots3 << ((shiftForWord()) - 2)) - (fmt1 & 1);
								goto l178;
							}
							if (fmt1 == (sixtyFourBitIndexableFormat())) {
								sz = numSlots3;
								goto l178;
							}
							sz = 0;
							l178:
							;
							/* end lengthOf:format: */
							unsignedLongAtput(local_stackPointer, ((((usqInt) sz ) << 3) | 1));
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
							goto l175;
						}
						/* 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;
					}
				}
				l175:
				;
				/* 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);
					{
						sqInt arg;
						sqInt rcvr;
						int t2;
						int t3;
						int t5;
						int t6;

						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);
					{
						sqInt aValue;
						sqInt rcvr;
						int t1;
						int t2;
						sqInt t5;
						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);
					{
						sqInt arg;
						sqInt rcvr;
						int t2;
						int t3;
						int t5;
						int t6;

						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 l200;
						}
						/* begin isClassOfNonImm:equalTo:compactClassIndex: */
						assert(!(isImmediate(rcvr)));
						/* begin classIndexOf: */
						ccIndex = (longAt(rcvr)) & (classIndexMask());
						/* end classIndexOf: */
						{
							isBlock = ClassFullBlockClosureCompactIndex == ccIndex;
							goto l200;
						}
						/* end isClassOfNonImm:equalTo:compactClassIndex: */
						l200:
						;
						/* 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 l196;
							}
							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;
					}
				}
				l196:
				;
				/* 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 l206;
						}
						/* begin isClassOfNonImm:equalTo:compactClassIndex: */
						assert(!(isImmediate(rcvr)));
						/* begin classIndexOf: */
						ccIndex = (longAt(rcvr)) & (classIndexMask());
						/* end classIndexOf: */
						{
							isBlock = ClassFullBlockClosureCompactIndex == ccIndex;
							goto l206;
						}
						/* end isClassOfNonImm:equalTo:compactClassIndex: */
						l206:
						;
						/* 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 l202;
							}
							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;
					}
				}
				l202:
				;
				/* 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 l214;
						}
						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;
					}
				}
				l214:
				;
				/* 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 l222;
						}
						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;
					}
				}
				l222:
				;
				/* 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 rcvr;
						sqInt t3;
						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());
						}
						GIV(lkupClassTag) = t3;
						assert(GIV(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 rcvr;
						sqInt t3;
						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());
						}
						GIV(lkupClassTag) = t3;
						assert(GIV(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 rcvr;
						sqInt t3;
						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());
						}
						GIV(lkupClassTag) = t3;
						assert(GIV(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 l235;
							}
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
						}
						/* begin pop: */
						local_stackPointer += 1 * BytesPerWord;
						/* end pop: */
						l235:
						;
						/* 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 l239;
							}
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
						}
						/* begin pop: */
						local_stackPointer += 1 * BytesPerWord;
						/* end pop: */
						l239:
						;
						/* end jumplfFalseBy: */
					}
				}
			}
			BREAK;
			CASE(200)
			CASE(201)
			CASE(202)
			CASE(203)
			CASE(204)
			CASE(205)
			CASE(206)
			CASE(207)
			{
				/* storeAndPopReceiverVariableBytecode */
				{
					VM_LABEL(storeAndPopReceiverVariableBytecode);
					{
						sqInt instVarIndex;
						sqInt rcvr;
						char *sp;
						char *sp2;
						char *sp3;
						int t15;
						int t16;
						int t23;
						int t24;
						sqInt top;

						/* begin receiver */
						rcvr = longAt(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 l245;
								l245:
								;
								/* end cannotAssign:to:withIndex: */
								goto l243;
							}
						}
#            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 l249;
						}
						if (top & (tagMask())) {
							goto l249;
						}
						if (!(rcvr >= 0x20000000000LL)) {
							goto l249;
						}
						if (top >= 0x20000000000LL) {
							goto l249;
						}
						t23 = top >= GIV(nilObj);
						if (t23) {
							t24 = top <= GIV(trueObj);
						} else {
							t24 = t23;
						}
						if (t24) {
							goto l249;
						}
						if (!(top >= (startOfObjectMemory(GIV(memoryMap))))) {
							goto l249;
						}
						remember(getFromPermToNewSpaceRememberedSet(), rcvr);
						l249:
						;
						/* end possiblePermObjectStoreInto:value: */
						unsignedLongAtput((rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) instVarIndex ) << (shiftForWord())) ), top);
						/* end storePointer:ofObject:withValue: */
						l243:
						;
						/* 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 l255;
						}
					}
				}
				l255:
				;
				/* 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);
					{
						GIV(extA) = (((usqInt) GIV(extA) ) << 8) + (byteAtPointer(++local_instructionPointer));
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
					}
				}
			}
			BREAK;
			CASE(225)
			{
				/* extBBytecode */
				{
					VM_LABEL(extBBytecode);
					{
						sqInt byte;
						int t6;
						int t7;
						sqInt t8;

						byte = byteAtPointer(++local_instructionPointer);
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						t6 = GIV(numExtB) == 0;
						if (t6) {
							t7 = byte > 0x7F;
						} else {
							t7 = t6;
						}
						if (t7) {
							t8 = byte - 256;
						} else {
							t8 = (((usqInt) GIV(extB) ) << 8) + byte;
						}
						GIV(extB) = t8;
						GIV(numExtB) += 1;
					}
				}
			}
			BREAK;
			CASE(226)
			{
				/* extPushReceiverVariableBytecode */
				{
					VM_LABEL(extPushReceiverVariableBytecode);
					{
						sqInt index;
						sqInt obj;
						sqInt object;
						sqInt object1;
						char *sp;
						char *sp2;
						int t10;
						int t11;

						index = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) GIV(extA) ) << 8) );
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						GIV(extA) = 0;
						/* begin pushMaybeContextReceiverVariable: */
						/* begin pushMaybeContext:receiverVariable: */
						obj = longAt(local_framePointer + FoxIFReceiver);
						t10 = index <= 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(index, 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: */
							object1 = unsignedLongAt((obj + BaseHeaderSize) + ((sqInt) (((usqInt) index ) << (shiftForWord())) ));
							unsignedLongAtput((sp2 = local_stackPointer - BytesPerWord), object1);
							local_stackPointer = sp2;
							/* end push: */
						}
						/* end pushMaybeContext:receiverVariable: */
						/* end pushMaybeContextReceiverVariable: */
					}
				}
			}
			BREAK;
			CASE(227)
			{
				/* extPushLiteralVariableBytecode */
				{
					VM_LABEL(extPushLiteralVariableBytecode);
					{
						sqInt index;
						sqInt litVar;
						sqInt object;
						char *sp;

						index = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) GIV(extA) ) << 8) );
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						GIV(extA) = 0;
						/* begin pushLiteralVariable: */
						{
							assert(GIV(method) == (iframeMethod(local_framePointer)));
							/* begin fetchPointer:ofObject: */
							litVar = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) (index + LiteralStart) ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
						}
						if (((long64At(litVar)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
							litVar = unfollowatIndex(litVar, index);
						}
						/* 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 index;
						char *sp;

						index = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) GIV(extA) ) << 8) );
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						GIV(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) (index + LiteralStart) ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */));
						local_stackPointer = sp;
						/* end push: */
						/* end pushLiteralConstant: */
					}
				}
			}
			BREAK;
			CASE(229)
			{
				/* longPushTemporaryVariableBytecode */
				{
					VM_LABEL(longPushTemporaryVariableBytecode);
					{
						sqInt frameNumArgs;
						sqInt index;
						sqInt object;
						char *sp;
						sqInt t9;

						/* begin fetchByte */
						index = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						/* begin push: */
						if (index < ((frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
							t9 = unsignedLongAt((local_framePointer + FoxCallerSavedIP) + ((frameNumArgs - index) * BytesPerWord));
						} else {
							t9 = unsignedLongAt(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((frameNumArgs - index) * 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 valuePointer1;

						/* 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 l270;
							}
						}
						long64Atput(newObj, ((((usqLong) size ) << (numSlotsFullShift())) + (2U << (formatShift()))) + ClassArrayCompactIndex);
						GIV(freeStart) += numBytes;
						array = newObj;
						/* end allocateSmallNewSpaceSlots:format:classIndex: */
						l270:
						;
						/* 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: */
								valuePointer1 = GIV(nilObj);
								assert(!(isOopForwarded(array)));
								longAtput((array + BaseHeaderSize) + ((sqInt) (((usqInt) i ) << (shiftForWord())) ), valuePointer1);
								/* 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) GIV(extB) ) << 8) );
						/* begin fetchNextBytecode */
						/* begin fetchByte */
						currentBytecode = byteAtPointer(++local_instructionPointer);
						/* end fetchByte */
						/* end fetchNextBytecode */
						GIV(extB) = 0;
						GIV(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) GIV(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: */
						GIV(numExtB) = (GIV(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) GIV(extA) ) << 5) )) + LiteralStart) ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							/* end literal:ofMethod: */
						}
						GIV(extA) = 0;
						GIV(argumentCount) = (byte & 7) + ((sqInt) (((usqInt) GIV(extB) ) << 3) );
						GIV(extB) = 0;
						GIV(numExtB) = 0;
						/* goto normalSend */
					}
				}
				normalSend:
/* normalSend */
				{
					VM_LABEL(normalSend);
					{
						sqInt rcvr;
						sqInt t1;
						sqInt tagBits;

						rcvr = unsignedLongAt(local_stackPointer + (GIV(argumentCount) * BytesPerWord));
						if (((tagBits = rcvr & (tagMask()))) != 0) {
							t1 = tagBits;
						} else {
							t1 = (longAt(rcvr)) & (classIndexMask());
						}
						GIV(lkupClassTag) = t1;
						assert(GIV(lkupClassTag) != (nilObject()));
						commonSendOrdinary:
/* commonSendOrdinary */
						{
							VM_LABEL(commonSendOrdinary);
							{
								sqInt classOrInteger;
								sqInt classTablePage;
								sqInt classTablePage2;
								sqInt classTag;
								CogMethod *cogMethod;
								CogMethod *cogMethod2;
								sqInt fieldIndex;
								sqInt fieldIndex1;
								sqInt fieldIndex11;
								sqInt fieldIndex2;
								sqInt inInterpreter;
								sqInt methodHeader;
								sqInt methodHeader2;
								sqInt nArgs;
								sqInt rcvr;
								sqInt referent;
								char *savedFramePointer;
								char *savedStackPointer;
								sqInt selector;
								sqInt selector1;
								sqInt succeeded;

								nArgs = 0;
								savedFramePointer = ((char *) 0 );
								savedStackPointer = ((char *) 0 );
								/* begin sendBreakpoint:receiver: */
								rcvr = unsignedLongAt(local_stackPointer + (GIV(argumentCount) * BytesPerWord));
								sendBreakpointreceiver(firstFixedFieldOfMaybeImmediate(GIV(messageSelector)), lengthOfMaybeImmediate(GIV(messageSelector)), rcvr);
								/* end sendBreakpoint:receiver: */
								/* begin doRecordSendTrace */
								if (recordSendTrace()) {
									/* begin recordTrace:thing:source: */
									/* begin classAtIndex: */
									assert((GIV(lkupClassTag) >= 0) && ((GIV(lkupClassTag) <= (tagMask())) || ((GIV(lkupClassTag) >= (arrayClassIndexPun())) && (GIV(lkupClassTag) <= (classIndexMask())))));
									/* begin fetchPointer:ofObject: */
									fieldIndex = ((usqInt) GIV(lkupClassTag) ) >> (classTableMajorIndexShift());
									classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									if (classTablePage == GIV(nilObj)) {
										classOrInteger = null;
										goto l518;
									}
									/* begin fetchPointer:ofObject: */
									fieldIndex1 = GIV(lkupClassTag) & ((1U << (classTableMajorIndexShift())) - 1);
									classOrInteger = unsignedLongAt((classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									l518:
									;
									/* 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(GIV(lkupClassTag)));
												/* begin cr */
												print("\n");
												/* end cr */
											}
										}
									}
								}
								/* end doRecordSendTrace */
								/* begin findNewMethodInClassTag:ifFound: */
								classTag = GIV(lkupClassTag);
								if (inlineLookupInMethodCacheSelclassTag(GIV(messageSelector), classTag)) {
									{
										/* begin ifAppropriateCompileToNativeCode:selector: */
										selector1 = 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, selector1);
											}
										} else {
											if (((assert(((methodHeader2 & 7) == 1)), (methodHeader2 >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
												cogselector(GIV(newMethod), selector1);
											} else {
												maybeFlagMethodAsInterpreted(GIV(newMethod));
											}
										}
										/* end ifAppropriateCompileToNativeCode:selector: */
									}
								} else {
									int t0;
									int t1;
									int t16;
									int t17;
									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 = classTag == (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 (classTag == (isForwardedObjectClassIndexPun())) {
											sqInt t0;

											{
												GIV(framePointer) = local_framePointer;
												GIV(stackPointer) = local_stackPointer;
												t0 = handleForwardedSendFaultForTag(classTag);
												local_framePointer = GIV(framePointer);
												local_stackPointer = GIV(stackPointer);
											}
											classTag = t0;
										}
										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 l517;
										}
									}
									/* begin classAtIndex: */
									assert((classTag >= 0) && ((classTag <= (tagMask())) || ((classTag >= (arrayClassIndexPun())) && (classTag <= (classIndexMask())))));
									/* begin fetchPointer:ofObject: */
									fieldIndex2 = ((usqInt) classTag ) >> (classTableMajorIndexShift());
									classTablePage2 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex2 ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									if (classTablePage2 == GIV(nilObj)) {
										GIV(lkupClass) = null;
										goto l523;
									}
									/* begin fetchPointer:ofObject: */
									fieldIndex11 = classTag & ((1U << (classTableMajorIndexShift())) - 1);
									GIV(lkupClass) = unsignedLongAt((classTablePage2 + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex11 ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									l523:
									;
									/* end classAtIndex: */
									t16 = (GIV(lkupClass) & (tagMask())) == 0;
									if (t16) {
										t17 = ((long64At(GIV(lkupClass))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
									} else {
										t17 = t16;
									}
									if (t17) {
										/* 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));
								}
								l517:
								;
								/* end findNewMethodInClassTag:ifFound: */
								/* 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 l526;
									}
									/* 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 = (freeStart()) < GIV(scavengeThreshold);
										if (t0) {
											t1 = (unsignedLongAt(freeStart())) != (freeStart());
										} 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 l520;
									l520:
									;
									/* 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 l526;
									}
								}
								{
									;
									{
										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);
									}
								}
								l526:
								;
								/* end executePrimitiveFromInterpreter:ifFail: */
								/* end executeNewMethod: */
								/* begin fetchNextBytecode */
								/* begin fetchByte */
								currentBytecode = byteAtPointer(++local_instructionPointer);
								/* end fetchByte */
								/* end fetchNextBytecode */
							}
						}
					}
				}
			}
			BREAK;
			CASE(235)
			{
				/* extSendSuperBytecode */
				{
					VM_LABEL(extSendSuperBytecode);
					{
						sqInt byte;
						sqInt class;
						sqInt classPointer;
						sqInt err;
						sqInt err2;
						sqInt hash;
						sqInt hash2;
						sqInt literal;
						usqInt methodPointer;
						sqInt objOop;
						sqInt objOop1;
						sqInt objOop11;
						sqInt objOop2;
						sqInt objOop4;
						sqInt objOop5;
						sqInt offset;
						sqInt oop;
						sqInt oop1;
						sqInt referent;
						sqInt referent2;
						sqInt referent3;
						sqInt superclass;
						sqInt superclass2;
						int t17;
						int t18;
						int t23;
						int t24;
						int t31;
						int t32;
						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) GIV(extA) ) << 5) )) + LiteralStart) ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							/* end literal:ofMethod: */
						}
						GIV(extA) = 0;
						{
							if (GIV(extB) >= 64) {
								int t14;
								int t15;

								GIV(argumentCount) = (byte & 7) + ((sqInt) (((usqInt) (GIV(extB) - 64) ) << 3) );
								GIV(extB) = 0;
								GIV(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));
									GIV(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: */
									objOop1 = unsignedLongAt(local_stackPointer + (GIV(argumentCount) * BytesPerWord));
									assert(isUnambiguouslyForwarder(objOop1));
									/* begin fetchPointer:ofMaybeForwardedObject: */
									referent2 = unsignedLongAt((objOop1 + 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(GIV(lkupClassTag) != (nilObject()));
								goto commonSendOrdinary;
								/* end directedSuperclassSend */
								goto l274;
							}
						}
						GIV(argumentCount) = (byte & 7) + ((sqInt) (((usqInt) GIV(extB) ) << 3) );
						GIV(extB) = 0;
						GIV(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: */
						objOop2 = unsignedLongAt((methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) (offset + LiteralStart) ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						t17 = (objOop2 & (tagMask())) == 0;
						if (t17) {
							t18 = ((long64At(objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
						} else {
							t18 = t17;
						}
						if (t18) {
							objOop2 = fixFollowedFieldofObjectwithInitialValue(offset + LiteralStart, methodPointer, objOop2);
						}
						literal = objOop2;
						/* 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: */
							objOop4 = unsignedLongAt((literal + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
							/* end fetchPointer:ofObject: */
							t5 = (objOop4 & (tagMask())) == 0;
							if (t5) {
								t6 = ((long64At(objOop4)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
							} else {
								t6 = t5;
							}
							if (t6) {
								objOop4 = fixFollowedFieldofObjectwithInitialValue(ValueIndex, literal, objOop4);
							}
							classPointer = objOop4;
							/* end followField:ofObject: */
						} else {
							/* begin nilObject */
							classPointer = GIV(nilObj);
							/* end nilObject */
						}
						/* end methodClassOf: */
						/* begin followField:ofObject: */
						/* begin fetchPointer:ofObject: */
						objOop5 = unsignedLongAt((classPointer + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						t31 = (objOop5 & (tagMask())) == 0;
						if (t31) {
							t32 = ((long64At(objOop5)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0;
						} else {
							t32 = t31;
						}
						if (t32) {
							objOop5 = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, classPointer, objOop5);
						}
						superclass2 = objOop5;
						/* end followField:ofObject: */
						/* end superclassOf: */
						{
							assert(addressCouldBeClassObj(superclass2));
							GIV(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: */
							objOop11 = unsignedLongAt(local_stackPointer + (GIV(argumentCount) * BytesPerWord));
							assert(isUnambiguouslyForwarder(objOop11));
							/* begin fetchPointer:ofMaybeForwardedObject: */
							referent3 = unsignedLongAt((objOop11 + 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: */
							};
							oop1 = referent3;
							/* end followForwarded: */
							unsignedLongAtput(local_stackPointer + (GIV(argumentCount) * BytesPerWord), oop1);
							/* end stackValue:put: */
						}
						/* end ensureReceiverUnforwarded */
						assert(GIV(lkupClassTag) != (nilObject()));
						goto commonSendOrdinary;
						/* end superclassSend */
					}
				}
				l274:
				;
				/* 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 classFormat1;
						sqInt classFormat2;
						sqInt classFormat3;
						sqInt classFormat4;
						sqInt classIndex;
						sqInt classIndex1;
						sqInt classIndex2;
						sqInt classIndex3;
						sqInt classIndex4;
						sqInt classObj;
						sqInt classObj1;
						sqInt classObj2;
						sqInt classObj3;
						sqInt classObj4;
						sqInt index;
						sqInt index2;
						sqInt index3;
						sqInt index4;
						usqInt newObj;
						usqInt newObj2;
						usqInt newObj3;
						usqInt newObj4;
						usqInt newObj5;
						usqInt numBytes;
						usqInt numBytes2;
						usqInt numBytes3;
						usqInt numBytes4;
						usqInt numBytes5;
						sqInt numSlots;
						sqInt numSlots1;
						sqInt numSlots2;
						sqInt numSlots3;
						sqInt numSlots4;
						sqInt objFormat;
						sqInt objFormat1;
						sqInt objFormat2;
						sqInt objFormat3;
						sqInt objFormat4;
						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 value1;
						double value11;
						float value12;
						float value13;
						double value2;
						float value21;
						float value22;
						float value3;
						float value31;
						float value4;
						float value5;

						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 l301;
										}
									}
									long64Atput(newObj, ((((usqLong) numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) objFormat ) << (formatShift())) )) + classIndex);
									GIV(freeStart) += numBytes;
									res = newObj;
									/* end allocateSmallNewSpaceSlots:format:classIndex: */
									/* end eeInstantiateSmallClassIndex:format:numSlots: */
									l301:
									;
									/* 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));
									index = (unsignedLongAt(local_stackPointer + (1 * BytesPerWord))) >> 3;
									/* begin eeInstantiateSmallClass:numSlots: */
									/* begin splObj: */
									/* begin fetchPointer:ofObject: */
									classObj2 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassFloat64Register ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									/* end splObj: */
									numSlots2 = 16 / 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()));
									newObj3 = GIV(freeStart);
									numBytes3 = BaseHeaderSize + (((numSlots2 < 1)
										 ? 8
										 : numSlots2 * 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 l347;
										}
									}
									long64Atput(newObj3, ((((usqLong) numSlots2 ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) objFormat2 ) << (formatShift())) )) + classIndex2);
									GIV(freeStart) += numBytes3;
									reg = newObj3;
									/* end allocateSmallNewSpaceSlots:format:classIndex: */
									/* end eeInstantiateSmallClassIndex:format:numSlots: */
									l347:
									;
									/* end eeInstantiateSmallClass:numSlots: */
									/* begin storeFloat64:ofObject:withValue: */
									/* begin fetchFloat64:ofObject: */
									value = float64At((array + BaseHeaderSize) + ((sqInt) (((usqInt) index ) << 3) ));
									/* end fetchFloat64:ofObject: */
									float64Atput((reg + BaseHeaderSize) + (0U << 3), value);
									/* end storeFloat64:ofObject:withValue: */
									/* begin storeFloat64:ofObject:withValue: */
									/* begin fetchFloat64:ofObject: */
									value1 = float64At((array + BaseHeaderSize) + ((sqInt) (((usqInt) (index + 1) ) << 3) ));
									/* end fetchFloat64:ofObject: */
									float64Atput((reg + BaseHeaderSize) + (1U << 3), value1);
									/* 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: */
									value2 = float64At((reg2 + BaseHeaderSize) + (0U << 3));
									/* end fetchFloat64:ofObject: */
									float64Atput((array2 + BaseHeaderSize) + ((sqInt) (((usqInt) index2 ) << 3) ), value2);
									/* end storeFloat64:ofObject:withValue: */
									/* begin storeFloat64:ofObject:withValue: */
									/* begin fetchFloat64:ofObject: */
									value11 = float64At((reg2 + BaseHeaderSize) + (1U << 3));
									/* end fetchFloat64:ofObject: */
									float64Atput((array2 + BaseHeaderSize) + ((sqInt) (((usqInt) (index2 + 1) ) << 3) ), value11);
									/* 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: */
									classObj1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassFloat32Register ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									/* end splObj: */
									numSlots1 = 32 / BytesPerWord;
									assert((rawHashBitsOf(classObj1)) != 0);
									/* begin eeInstantiateSmallClassIndex:format:numSlots: */
									classIndex1 = (uint32AtPointer(classObj1 + 4)) & (identityHashHalfWordMask());
									/* begin instSpecOfClassFormat: */
									classFormat1 = (unsignedLongAt((classObj1 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
									objFormat1 = (((usqInt) classFormat1 ) >> (fixedFieldsFieldWidth())) & (formatMask());
									/* end instSpecOfClassFormat: */
									assert((numSlots1 >= 0) && ((classIndex1 != 0) && ((classAtIndex(classIndex1)) != GIV(nilObj))));
									assert((((objFormat1 < (firstByteFormat()))
										 ? objFormat1
										 : objFormat1 & (byteFormatMask()))) == (instSpecOfClass(classAtIndex(classIndex1))));
									/* begin allocateSmallNewSpaceSlots:format:classIndex: */
									assert(numSlots1 < (numSlotsMask()));
									newObj2 = GIV(freeStart);
									numBytes2 = BaseHeaderSize + (((numSlots1 < 1)
										 ? 8
										 : numSlots1 * 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 l305;
										}
									}
									long64Atput(newObj2, ((((usqLong) numSlots1 ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) objFormat1 ) << (formatShift())) )) + classIndex1);
									GIV(freeStart) += numBytes2;
									res2 = newObj2;
									/* end allocateSmallNewSpaceSlots:format:classIndex: */
									/* end eeInstantiateSmallClassIndex:format:numSlots: */
									l305:
									;
									/* 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: */
									classObj3 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassFloat32Register ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									/* end splObj: */
									numSlots3 = 32 / 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()));
									newObj4 = GIV(freeStart);
									numBytes4 = BaseHeaderSize + (((numSlots3 < 1)
										 ? 8
										 : numSlots3 * 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 l298;
										}
									}
									long64Atput(newObj4, ((((usqLong) numSlots3 ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) objFormat3 ) << (formatShift())) )) + classIndex3);
									GIV(freeStart) += numBytes4;
									reg3 = newObj4;
									/* end allocateSmallNewSpaceSlots:format:classIndex: */
									/* end eeInstantiateSmallClassIndex:format:numSlots: */
									l298:
									;
									/* end eeInstantiateSmallClass:numSlots: */
									/* begin storeFloat32:ofObject:withValue: */
									/* begin fetchFloat32:ofObject: */
									value4 = float32At((array3 + BaseHeaderSize) + ((sqInt) (((usqInt) index3 ) << 2) ));
									/* end fetchFloat32:ofObject: */
									float32Atput((reg3 + BaseHeaderSize) + (0U << 2), value4);
									/* end storeFloat32:ofObject:withValue: */
									/* begin storeFloat32:ofObject:withValue: */
									/* begin fetchFloat32:ofObject: */
									value12 = float32At((array3 + BaseHeaderSize) + ((sqInt) (((usqInt) (index3 + 1) ) << 2) ));
									/* end fetchFloat32:ofObject: */
									float32Atput((reg3 + BaseHeaderSize) + (1U << 2), value12);
									/* end storeFloat32:ofObject:withValue: */
									/* begin storeFloat32:ofObject:withValue: */
									/* begin fetchFloat32:ofObject: */
									value21 = float32At((array3 + BaseHeaderSize) + ((sqInt) (((usqInt) (index3 + 2) ) << 2) ));
									/* end fetchFloat32:ofObject: */
									float32Atput((reg3 + BaseHeaderSize) + (2U << 2), value21);
									/* end storeFloat32:ofObject:withValue: */
									/* begin storeFloat32:ofObject:withValue: */
									/* begin fetchFloat32:ofObject: */
									value3 = float32At((array3 + BaseHeaderSize) + ((sqInt) (((usqInt) (index3 + 3) ) << 2) ));
									/* end fetchFloat32:ofObject: */
									float32Atput((reg3 + BaseHeaderSize) + (3U << 2), value3);
									/* 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: */
									value5 = float32At((reg4 + BaseHeaderSize) + (0U << 2));
									/* end fetchFloat32:ofObject: */
									float32Atput((array4 + BaseHeaderSize) + ((sqInt) (((usqInt) index4 ) << 2) ), value5);
									/* end storeFloat32:ofObject:withValue: */
									/* begin storeFloat32:ofObject:withValue: */
									/* begin fetchFloat32:ofObject: */
									value13 = float32At((reg4 + BaseHeaderSize) + (1U << 2));
									/* end fetchFloat32:ofObject: */
									float32Atput((array4 + BaseHeaderSize) + ((sqInt) (((usqInt) (index4 + 1) ) << 2) ), value13);
									/* end storeFloat32:ofObject:withValue: */
									/* begin storeFloat32:ofObject:withValue: */
									/* begin fetchFloat32:ofObject: */
									value22 = float32At((reg4 + BaseHeaderSize) + (2U << 2));
									/* end fetchFloat32:ofObject: */
									float32Atput((array4 + BaseHeaderSize) + ((sqInt) (((usqInt) (index4 + 2) ) << 2) ), value22);
									/* end storeFloat32:ofObject:withValue: */
									/* begin storeFloat32:ofObject:withValue: */
									/* begin fetchFloat32:ofObject: */
									value31 = float32At((reg4 + BaseHeaderSize) + (3U << 2));
									/* end fetchFloat32:ofObject: */
									float32Atput((array4 + BaseHeaderSize) + ((sqInt) (((usqInt) (index4 + 3) ) << 2) ), value31);
									/* 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: */
									classObj4 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassFloat64Register ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									/* end splObj: */
									numSlots4 = 16 / 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()));
									newObj5 = GIV(freeStart);
									numBytes5 = BaseHeaderSize + (((numSlots4 < 1)
										 ? 8
										 : numSlots4 * 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 l321;
										}
									}
									long64Atput(newObj5, ((((usqLong) numSlots4 ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) objFormat4 ) << (formatShift())) )) + classIndex4);
									GIV(freeStart) += numBytes5;
									res3 = newObj5;
									/* end allocateSmallNewSpaceSlots:format:classIndex: */
									/* end eeInstantiateSmallClassIndex:format:numSlots: */
									l321:
									;
									/* 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 backwardJumpCountByte;
						sqInt bcpcDelta;
						sqInt byte;
						sqInt offset;
						sqInt switched;
						sqInt t2;

						byte = byteAtPointer(++local_instructionPointer);
						offset = byte + ((sqInt) (((usqInt) GIV(extB) ) << 8) );
						if (offset < 0) {
							t2 = GIV(numExtB) * 2;
						} else {
							t2 = 0;
						}
						bcpcDelta = t2;
						GIV(extB) = 0;
						GIV(numExtB) = 0;
						local_instructionPointer += offset;
						/* begin ifBackwardsCheckForEvents: */
						if ((offset + bcpcDelta) >= 0) {
							goto l352;
						}
						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 l352;
							}
						}
						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: */
						l352:
						;
						/* 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) GIV(extB) ) << 8) );
						GIV(numExtB) = (GIV(extB) = (GIV(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 l356;
							}
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
						}
						/* begin pop: */
						local_stackPointer += 1 * BytesPerWord;
						/* end pop: */
						l356:
						;
						/* end jumplfTrueBy: */
					}
				}
			}
			BREAK;
			CASE(239)
			{
				/* extJumpIfFalse */
				{
					VM_LABEL(extJumpIfFalse);
					{
						sqInt boolean;
						sqInt byte;
						sqInt offset;

						byte = byteAtPointer(++local_instructionPointer);
						offset = byte + ((sqInt) (((usqInt) GIV(extB) ) << 8) );
						GIV(numExtB) = (GIV(extB) = (GIV(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 l360;
							}
							/* begin fetchNextBytecode */
							/* begin fetchByte */
							currentBytecode = byteAtPointer(++local_instructionPointer);
							/* end fetchByte */
							/* end fetchNextBytecode */
						}
						/* begin pop: */
						local_stackPointer += 1 * BytesPerWord;
						/* end pop: */
						l360:
						;
						/* end jumplfFalseBy: */
					}
				}
			}
			BREAK;
			CASE(240)
			{
				/* extStoreAndPopReceiverVariableBytecode */
				{
					VM_LABEL(extStoreAndPopReceiverVariableBytecode);
					{
						sqInt obj;
						int onCurrentPage;
						sqInt senderOop;
						char *sp;
						char *sp2;
						char *sp3;
						int t10;
						sqInt t11;
						char * theFP;
						StackPage * thePage;
						StackPage *thePage1;
						sqInt thePC;
						sqInt thePC2;
						char *theSP;
						sqInt value;
						sqInt variableIndex;

						variableIndex = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) GIV(extA) ) << 8) );
						GIV(extA) = 0;
						value = unsignedLongAt(local_stackPointer);
						/* begin pop: */
						local_stackPointer += 1 * BytesPerWord;
						/* end pop: */
						/* begin storeMaybeContextReceiverVariable:withValue: */
						/* begin storeMaybeContext:receiverVariable:withValue: */
						obj = longAt(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 t16;
							int t17;
							int t27;
							sqInt t28;
							int t32;
							int t33;
							int t40;
							int t41;

							/* begin instVar:ofContext:put: */
							assert(isMarriedOrWidowedContext(obj));
							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 */
							t16 = (((unsignedLongAt((obj + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1);
							if (t16) {
								t17 = !(isWidowedContext(obj));
							} else {
								t17 = t16;
							}
							if (!t17) {
								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 l372;
								}
								if (value & (tagMask())) {
									goto l372;
								}
								if (!(obj >= 0x20000000000LL)) {
									goto l372;
								}
								if (value >= 0x20000000000LL) {
									goto l372;
								}
								t10 = value >= GIV(nilObj);
								if (t10) {
									t11 = value <= GIV(trueObj);
								} else {
									t11 = t10;
								}
								if (t11) {
									goto l372;
								}
								if (!(value >= (startOfObjectMemory(GIV(memoryMap))))) {
									goto l372;
								}
								remember(getFromPermToNewSpaceRememberedSet(), obj);
								l372:
								;
								/* 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 l376;
							}
							/* 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: */
									thePage1 = GIV(stackPage);
									local_stackPointer = (thePage1->headSP);
									local_framePointer = (thePage1->headFP);
									/* end setStackPointersFromPage: */
								} else {
									markStackPageMostRecentlyUsed(GIV(stackPage));
								}
								goto l376;
							}
							{
								GIV(framePointer) = local_framePointer;
								GIV(stackPointer) = local_stackPointer;
								divorceFrameandContext(theFP, obj);
								local_framePointer = GIV(framePointer);
								local_stackPointer = GIV(stackPointer);
							}
							t27 = variableIndex == MethodIndex;
							if (t27) {
								int t0;

								t0 = ((int) ((thePC2 = unsignedLongAt((obj + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )))) ) < 0;
								if (t0) {
									t28 = ((thePC2 & 7) == 1);
								} else {
									t28 = t0;
								}
							} else {
								t28 = t27;
							}
							if (t28) {
								{
									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)));
							t32 = (obj & (tagMask())) == 0;
							if (t32) {
								t33 = (obj & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask));
							} else {
								t33 = t32;
							}
							if (t33) {
								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 l363;
							}
							if (value & (tagMask())) {
								goto l363;
							}
							if (!(obj >= 0x20000000000LL)) {
								goto l363;
							}
							if (value >= 0x20000000000LL) {
								goto l363;
							}
							t40 = value >= GIV(nilObj);
							if (t40) {
								t41 = value <= GIV(trueObj);
							} else {
								t41 = t40;
							}
							if (t41) {
								goto l363;
							}
							if (!(value >= (startOfObjectMemory(GIV(memoryMap))))) {
								goto l363;
							}
							remember(getFromPermToNewSpaceRememberedSet(), obj);
							l363:
							;
							/* 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));
							assertValidExecutionPointersimbarline(((usqInt) local_instructionPointer ), local_framePointer, local_stackPointer, 1, __LINE__);
							l376:
							;
							/* 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 l371;
									l371:
									;
									/* 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 l365;
							}
							if (value & (tagMask())) {
								goto l365;
							}
							if (!(obj >= 0x20000000000LL)) {
								goto l365;
							}
							if (value >= 0x20000000000LL) {
								goto l365;
							}
							t12 = value >= GIV(nilObj);
							if (t12) {
								t13 = value <= GIV(trueObj);
							} else {
								t13 = t12;
							}
							if (t13) {
								goto l365;
							}
							if (!(value >= (startOfObjectMemory(GIV(memoryMap))))) {
								goto l365;
							}
							remember(getFromPermToNewSpaceRememberedSet(), obj);
							l365:
							;
							/* 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);
					{
						sqInt literal;
						sqInt litVar;
						char *sp;
						char *sp2;
						char *sp3;
						int t17;
						int t18;
						int t25;
						int t26;
						sqInt value;
						sqInt variableIndex;

						variableIndex = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) GIV(extA) ) << 8) );
						value = unsignedLongAt(local_stackPointer);
						/* begin pop: */
						local_stackPointer += 1 * BytesPerWord;
						/* end pop: */
						GIV(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 l381;
								l381:
								;
								/* end cannotAssign:to:withIndex: */
								goto l380;
							}
						}
#            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 l382;
						}
						if (value & (tagMask())) {
							goto l382;
						}
						if (!(litVar >= 0x20000000000LL)) {
							goto l382;
						}
						if (value >= 0x20000000000LL) {
							goto l382;
						}
						t25 = value >= GIV(nilObj);
						if (t25) {
							t26 = value <= GIV(trueObj);
						} else {
							t26 = t25;
						}
						if (t26) {
							goto l382;
						}
						if (!(value >= (startOfObjectMemory(GIV(memoryMap))))) {
							goto l382;
						}
						remember(getFromPermToNewSpaceRememberedSet(), litVar);
						l382:
						;
						/* end possiblePermObjectStoreInto:value: */
						unsignedLongAtput((litVar + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ), value);
						/* end storePointer:ofObject:withValue: */
						l380:
						;
						/* 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 index;
						sqInt valueOop;

						/* begin longStoreTemporaryVariableBytecode */
						/* begin fetchByte */
						index = 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 (index < ((frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
							unsignedLongAtput((local_framePointer + FoxCallerSavedIP) + ((frameNumArgs - index) * BytesPerWord), valueOop);
						} else {
							unsignedLongAtput(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((frameNumArgs - index) * BytesPerWord), valueOop);
						}
						/* end itemporary:in:put: */
						/* end longStoreTemporaryVariableBytecode */
						/* begin pop: */
						local_stackPointer += 1 * BytesPerWord;
						/* end pop: */
					}
				}
			}
			BREAK;
			CASE(243)
			{
				/* extStoreReceiverVariableBytecode */
				{
					VM_LABEL(extStoreReceiverVariableBytecode);
					{
						sqInt anObject;
						sqInt obj;
						int onCurrentPage;
						sqInt senderOop;
						char *sp;
						char *sp2;
						char *sp3;
						int t6;
						sqInt t7;
						char * theFP;
						StackPage * thePage;
						StackPage *thePage1;
						sqInt thePC;
						sqInt thePC2;
						char *theSP;
						sqInt variableIndex;

						variableIndex = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) GIV(extA) ) << 8) );
						GIV(extA) = 0;
						/* begin storeMaybeContextReceiverVariable:withValue: */
						anObject = unsignedLongAt(local_stackPointer);
						/* begin storeMaybeContext:receiverVariable:withValue: */
						obj = longAt(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 t16;
							int t17;
							int t27;
							sqInt t28;
							int t32;
							int t33;
							int t40;
							int t41;

							/* begin instVar:ofContext:put: */
							assert(isMarriedOrWidowedContext(obj));
							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 */
							t16 = (((unsignedLongAt((obj + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1);
							if (t16) {
								t17 = !(isWidowedContext(obj));
							} else {
								t17 = t16;
							}
							if (!t17) {
								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 l399;
								}
								if (anObject & (tagMask())) {
									goto l399;
								}
								if (!(obj >= 0x20000000000LL)) {
									goto l399;
								}
								if (anObject >= 0x20000000000LL) {
									goto l399;
								}
								t10 = anObject >= GIV(nilObj);
								if (t10) {
									t11 = anObject <= GIV(trueObj);
								} else {
									t11 = t10;
								}
								if (t11) {
									goto l399;
								}
								if (!(anObject >= (startOfObjectMemory(GIV(memoryMap))))) {
									goto l399;
								}
								remember(getFromPermToNewSpaceRememberedSet(), obj);
								l399:
								;
								/* 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 l403;
							}
							/* 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: */
									thePage1 = GIV(stackPage);
									local_stackPointer = (thePage1->headSP);
									local_framePointer = (thePage1->headFP);
									/* end setStackPointersFromPage: */
								} else {
									markStackPageMostRecentlyUsed(GIV(stackPage));
								}
								goto l403;
							}
							{
								GIV(framePointer) = local_framePointer;
								GIV(stackPointer) = local_stackPointer;
								divorceFrameandContext(theFP, obj);
								local_framePointer = GIV(framePointer);
								local_stackPointer = GIV(stackPointer);
							}
							t27 = variableIndex == MethodIndex;
							if (t27) {
								int t0;

								t0 = ((int) ((thePC2 = unsignedLongAt((obj + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) )))) ) < 0;
								if (t0) {
									t28 = ((thePC2 & 7) == 1);
								} else {
									t28 = t0;
								}
							} else {
								t28 = t27;
							}
							if (t28) {
								{
									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)));
							t32 = (obj & (tagMask())) == 0;
							if (t32) {
								t33 = (obj & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask));
							} else {
								t33 = t32;
							}
							if (t33) {
								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 l391;
							}
							if (anObject & (tagMask())) {
								goto l391;
							}
							if (!(obj >= 0x20000000000LL)) {
								goto l391;
							}
							if (anObject >= 0x20000000000LL) {
								goto l391;
							}
							t40 = anObject >= GIV(nilObj);
							if (t40) {
								t41 = anObject <= GIV(trueObj);
							} else {
								t41 = t40;
							}
							if (t41) {
								goto l391;
							}
							if (!(anObject >= (startOfObjectMemory(GIV(memoryMap))))) {
								goto l391;
							}
							remember(getFromPermToNewSpaceRememberedSet(), obj);
							l391:
							;
							/* 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));
							assertValidExecutionPointersimbarline(((usqInt) local_instructionPointer ), local_framePointer, local_stackPointer, 1, __LINE__);
							l403:
							;
							/* 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 l396;
									l396:
									;
									/* 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 l393;
							}
							if (anObject & (tagMask())) {
								goto l393;
							}
							if (!(obj >= 0x20000000000LL)) {
								goto l393;
							}
							if (anObject >= 0x20000000000LL) {
								goto l393;
							}
							t12 = anObject >= GIV(nilObj);
							if (t12) {
								t13 = anObject <= GIV(trueObj);
							} else {
								t13 = t12;
							}
							if (t13) {
								goto l393;
							}
							if (!(anObject >= (startOfObjectMemory(GIV(memoryMap))))) {
								goto l393;
							}
							remember(getFromPermToNewSpaceRememberedSet(), obj);
							l393:
							;
							/* 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);
					{
						sqInt anObject;
						sqInt literal;
						sqInt litVar;
						char *sp;
						char *sp2;
						char *sp3;
						int t13;
						int t14;
						int t21;
						int t22;
						sqInt variableIndex;

						variableIndex = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) GIV(extA) ) << 8) );
						GIV(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 l407;
								l407:
								;
								/* end cannotAssign:to:withIndex: */
								goto l406;
							}
						}
#            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 l408;
						}
						if (anObject & (tagMask())) {
							goto l408;
						}
						if (!(litVar >= 0x20000000000LL)) {
							goto l408;
						}
						if (anObject >= 0x20000000000LL) {
							goto l408;
						}
						t21 = anObject >= GIV(nilObj);
						if (t21) {
							t22 = anObject <= GIV(trueObj);
						} else {
							t22 = t21;
						}
						if (t22) {
							goto l408;
						}
						if (!(anObject >= (startOfObjectMemory(GIV(memoryMap))))) {
							goto l408;
						}
						remember(getFromPermToNewSpaceRememberedSet(), litVar);
						l408:
						;
						/* end possiblePermObjectStoreInto:value: */
						unsignedLongAtput((litVar + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ), anObject);
						/* end storePointer:ofObject:withValue: */
						l406:
						;
						/* 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 index;
						sqInt valueOop;

						/* begin fetchByte */
						index = 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 (index < ((frameNumArgs = byteAt((local_framePointer + FoxIFrameFlags) + 1)))) {
							unsignedLongAtput((local_framePointer + FoxCallerSavedIP) + ((frameNumArgs - index) * BytesPerWord), valueOop);
						} else {
							unsignedLongAtput(((local_framePointer + FoxIFReceiver) - BytesPerWord) + ((frameNumArgs - index) * BytesPerWord), valueOop);
						}
						/* end itemporary:in:put: */
					}
				}
			}
			BREAK;
			CASE(248)
			{
				/* callPrimitiveBytecode */
				{
					VM_LABEL(callPrimitiveBytecode);
					{
						sqInt header;
						sqInt header3;

						{
							int t5;
							int t6;

							/* begin methodHeaderOf: */
							assert(isCompiledMethod(GIV(method)));
							header3 = unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
							if (((header3 & 7) == 1)) {
								header = header3;
							} else {
								assert(((usqInt) header3 ) < ((GIV(memoryMap)->newSpaceStart)));
								assert((((((CogMethod *) header3 ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
								header = ((((CogMethod *) header3 ))->methodHeader);
							}
							/* end methodHeaderOf: */
							t5 = header & AlternateHeaderHasPrimFlag;
							if (t5) {
								t6 = ((sqInt) local_instructionPointer ) == ((GIV(method) + ((LiteralStart + ((assert(((header & 7) == 1)), (header >> 3) & AlternateHeaderNumLiteralsMask))) * BytesPerOop)) + BaseHeaderSize);
							} else {
								t6 = t5;
							}
							if (t6) {
								local_instructionPointer = (local_instructionPointer + 3) - 1;
								/* begin fetchNextBytecode */
								/* begin fetchByte */
								currentBytecode = byteAtPointer(++local_instructionPointer);
								/* end fetchByte */
								/* end fetchNextBytecode */
								goto l415;
							} else {
								goto respondToUnknownBytecode;
								goto l415;
							}
						}
					}
				}
				l415:
				;
				/* 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 valuePointer1;

						compiledBlockLiteralIndex = (byteAtPointer(++local_instructionPointer)) + ((sqInt) (((usqInt) GIV(extA) ) << 8) );
						GIV(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));
						header2 = unsignedLongAt((compiledBlock + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
						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 l423;
							}
							context = marryFrameSP(theFP, theSP);
							l423:
							;
							/* 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 l432;
								}
							}
							long64Atput(newObj, ((((usqLong) numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) objFormat ) << (formatShift())) )) + ClassFullBlockClosureCompactIndex);
							GIV(freeStart) += numBytes;
							newClosure2 = newObj;
							/* end allocateSmallNewSpaceSlots:format:classIndex: */
							l432:
							;
							/* 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 = longAt(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: */
								valuePointer1 = unsignedLongAt(local_stackPointer + (((numCopied2 - i) - 1) * BytesPerWord));
								assert(!(isOopForwarded(newClosure)));
								longAtput((newClosure + BaseHeaderSize) + ((sqInt) (((usqInt) (i + startIndex) ) << (shiftForWord())) ), valuePointer1);
								/* 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 frameNumArgs;
						sqInt object;
						sqInt remoteTempIndex;
						char *sp;
						sqInt t13;
						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 frameNumArgs;
						sqInt remoteTempIndex;
						sqInt t13;
						int t20;
						int t21;
						int t28;
						int t29;
						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 l442;
						}
						if (valuePointer & (tagMask())) {
							goto l442;
						}
						if (!(tempVector >= 0x20000000000LL)) {
							goto l442;
						}
						if (valuePointer >= 0x20000000000LL) {
							goto l442;
						}
						t28 = valuePointer >= GIV(nilObj);
						if (t28) {
							t29 = valuePointer <= GIV(trueObj);
						} else {
							t29 = t28;
						}
						if (t29) {
							goto l442;
						}
						if (!(valuePointer >= (startOfObjectMemory(GIV(memoryMap))))) {
							goto l442;
						}
						remember(getFromPermToNewSpaceRememberedSet(), tempVector);
						l442:
						;
						/* 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 frameNumArgs;
						sqInt remoteTempIndex;
						sqInt t14;
						int t21;
						int t22;
						int t29;
						int t30;
						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 l448;
						}
						if (valuePointer & (tagMask())) {
							goto l448;
						}
						if (!(tempVector >= 0x20000000000LL)) {
							goto l448;
						}
						if (valuePointer >= 0x20000000000LL) {
							goto l448;
						}
						t29 = valuePointer >= GIV(nilObj);
						if (t29) {
							t30 = valuePointer <= GIV(trueObj);
						} else {
							t30 = t29;
						}
						if (t30) {
							goto l448;
						}
						if (!(valuePointer >= (startOfObjectMemory(GIV(memoryMap))))) {
							goto l448;
						}
						remember(getFromPermToNewSpaceRememberedSet(), tempVector);
						l448:
						;
						/* 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>>#segmentDataFile:inImage: */
static sqInt NoDbgRegParms
segmentDataFileinImage(sqInt segmentIndex, sqInt imageFileName)
{
	char buffer[255];

	/* begin simulationOnly: */
	/* end simulationOnly: */
	return (snprintf(buffer, 0xFF, "%s/seg%d%s", ((char *) imageFileName ), ((int) segmentIndex ), ".data"), buffer);
}
/* 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 l2;
	}
	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 */
	l2:
	;
	/* 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;
	/* 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 object1;
	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();
		error("should not be reached");
	}
	/* 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: */
		object1 = ((sqInt) cogMethod ) + ((cogMethod->stackCheckOffset));
		unsignedLongAtput((sp4 = GIV(stackPointer) - BytesPerWord), object1);
		GIV(stackPointer) = sp4;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((sp5 = GIV(stackPointer) - BytesPerWord), rcvr);
		GIV(stackPointer) = sp5;
		/* end push: */
		ceEnterCogCodePopReceiverReg();
		error("should not be reached");
	}
	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;
	CogMethod *cogMethod;
	sqInt i;
	sqInt inInterpreter;
	usqInt initialIP;
	sqInt methodHeader;
	sqInt methodHeader2;
	sqInt numArgs;
	sqInt numTemps;
	sqInt object;
	sqInt object1;
	sqInt rcvr;
	sqInt shouldSkipStoreBytecode;
	char *sp;
	char *sp10;
	char *sp2;
	char *sp3;
	char *sp4;
	char *sp5;
	char *sp6;
	char *sp7;
	char *sp8;
	char *sp9;
	sqInt switched;
	CogMethod * theCogMethod;

	cogMethod = ((CogMethod *) 0 );
	/* 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;
		}
	}
	/* begin justActivateNewMethod: */
	/* 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)) {
		theCogMethod = ((CogMethod *) methodHeader2 );
		methodHeader2 = (theCogMethod->methodHeader);
		;
	}
	numTemps = (((usqInt) methodHeader2 ) >> MethodHeaderTempCountShift) & 0x3F;
	numArgs = (((usqInt) methodHeader2 ) >> MethodHeaderArgCountShift) & 15;
	rcvr = unsignedLongAt(GIV(stackPointer) + (numArgs * BytesPerWord));
	assert(!(isOopForwarded(rcvr)));
	if ((cogMethod != null) && (!(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap()))))) {
		/* begin iframeSavedIP:put: */
		assert(!(isMachineCodeFrame(GIV(framePointer))));
		unsignedLongAtput(GIV(framePointer) + FoxIFSavedIP, GIV(instructionPointer));
		/* end iframeSavedIP:put: */
		GIV(instructionPointer) = ceReturnToInterpreterPC();
	}
	/* begin push: */
	unsignedLongAtput((sp8 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
	GIV(stackPointer) = sp8;
	/* end push: */
	/* begin push: */
	unsignedLongAtput((sp9 = GIV(stackPointer) - BytesPerWord), GIV(framePointer));
	GIV(stackPointer) = sp9;
	/* end push: */
	GIV(framePointer) = GIV(stackPointer);
	if (cogMethod == null) {
		initialIP = (GIV(newMethod) + ((LiteralStart + ((assert(((methodHeader2 & 7) == 1)), (methodHeader2 >> 3) & AlternateHeaderNumLiteralsMask))) * BytesPerOop)) + BaseHeaderSize;
		/* begin push: */
		unsignedLongAtput((sp = GIV(stackPointer) - BytesPerWord), GIV(newMethod));
		GIV(stackPointer) = sp;
		/* 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((sp2 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
		GIV(stackPointer) = sp2;
		/* end push: */
		/* begin push: */
		object = ((VMBIGENDIAN)
			 ? ((1 + ((sqInt) (((usqInt) numArgs ) << ((BytesPerWord * 8) - 8)) )) + 0) + 0
			 : ((1 + ((sqInt) (((usqInt) numArgs ) << 8) )) + 0) + 0);
		unsignedLongAtput((sp3 = GIV(stackPointer) - BytesPerWord), object);
		GIV(stackPointer) = sp3;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((sp4 = GIV(stackPointer) - BytesPerWord), 0);
		GIV(stackPointer) = sp4;
		/* end push: */
		GIV(instructionPointer) = initialIP - 1;
	} else {
		/* begin push: */
		object1 = ((usqInt) cogMethod );
		unsignedLongAtput((sp5 = GIV(stackPointer) - BytesPerWord), object1);
		GIV(stackPointer) = sp5;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((sp6 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
		GIV(stackPointer) = sp6;
		/* end push: */
		GIV(instructionPointer) = ((usqInt) cogMethod ) + ((cogMethod->stackCheckOffset));
	}
	/* begin push: */
	unsignedLongAtput((sp10 = GIV(stackPointer) - BytesPerWord), rcvr);
	GIV(stackPointer) = sp10;
	/* end push: */
	for (i = numArgs + 1; i <= numTemps; i += 1) {
		/* begin push: */
		unsignedLongAtput((sp7 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
		GIV(stackPointer) = sp7;
		/* end push: */
	};
	if (methodHeader2 & AlternateHeaderHasPrimFlag) {
		if (!cogMethod) {
			GIV(instructionPointer) += 3;
		}
		if (GIV(primFailCode) != 0) {
			shouldSkipStoreBytecode = reapAndResetErrorCodeToheader(GIV(framePointer), methodHeader2);
			if ((cogMethod == null) && shouldSkipStoreBytecode) {
				GIV(instructionPointer) += 2;
			}
		}
	}
	methodHeader = methodHeader2;
	/* end justActivateNewMethod: */
	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 hash;
	sqInt hash2;
	sqInt hash3;
	sqInt hash4;
	sqInt header;
	sqInt methodHeader;
	sqInt p;
	sqInt primitiveIndex;
	sqInt probe;

	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)));
			header = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			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:inClass: */
			primitiveFunctionPointer = ((void (*)(void)) (((primitiveIndex > MaxPrimitiveIndex)
				 ? 0
				 : primitiveTable[primitiveIndex])) );
			/* end functionPointerFor:inClass: */
		} 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;
	sqInt actualEdenBytes;
	SpurNewSpaceSpace *aNewSpace;
	sqInt bridge;
	sqInt bridgehead;
	usqLong bridgeSpan;
	sqInt bytesRead;
	size_t bytesRead2;
	sqInt bytesRead3;
	sqInt bytesToShift;
	sqInt bytesToShift2;
	VMMemoryMap * cascade0;
	sqInt classArrayClass;
	sqInt classArrayClass2;
	sqInt classArrayObj;
	sqInt classArrayObj2;
	sqInt i;
	sqInt i2;
	sqInt i22;
	sqInt i3;
	sqInt i5;
	sqInt i54;
	sqInt iLimiT;
	sqInt iLimiT2;
	usqInt limit;
	sqInt newBase;
	size_t nextSegmentSize;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt objOop;
	sqInt objOop1;
	sqInt oldBase;
	sqInt oldSpaceBytesRead;
	sqInt oldSpaceBytesRead2;
	sqInt oldStart;
	sqInt oop;
	sqInt oop2;
	sqInt p;
	sqInt permSpaceBytesRead;
	sqInt permSpaceBytesRead2;
	sqInt requestedSurvivorBytes;
	sqInt reserve;
	SpurSegmentInfo *segInfo;
	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 */
		oldStart = GIV(futureSurvivorStart);
		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 l22;
		l22:
		;
		/* 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: */
			interpreterProxy = sqGetInterpreterProxy();
			dummyReferToProxy();
			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 (i5 = InstanceSpecificationIndex + 1, iLimiT = lengthOfformat(classArrayClass, (((usqInt) (longAt(classArrayClass)) ) >> (formatShift())) & (formatMask())); i5 <= iLimiT; i5 += 1) {
				if ((unsignedLongAt((classArrayClass + BaseHeaderSize) + ((sqInt) (((usqInt) (i5 - 1) ) << (shiftForWord())) ))) == classArrayObj) {
					GIV(thisClassIndex) = i5 - 1;
				}
			};
			GIV(classNameIndex) = 6;
			for (i5 = InstanceSpecificationIndex + 1, iLimiT = lengthOfformat(classArrayObj, (((usqInt) (longAt(classArrayObj)) ) >> (formatShift())) & (formatMask())); i5 <= iLimiT; i5 += 1) {
				/* begin fetchPointer:ofObject: */
				oop = unsignedLongAt((classArrayObj + BaseHeaderSize) + ((sqInt) (((usqInt) (i5 - 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) = i5 - 1;
				}
			};
			/* end initializeExtraClassInstVarIndices */
			GIV(method) = (GIV(newMethod) = GIV(nilObj));
			GIV(methodDictLinearSearchLimit) = 8;
			/* begin initialCleanup */
			/* begin flushMethodCache */
			{
				sqInt i;

				for (i = 1; i <= MethodCacheSize; i += 1) {
					GIV(methodCache)[i] = 0;
				};
				GIV(lastMethodCacheProbeWrite) = 0;
			}
			unlinkAllSends();
			/* 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: */
			interpreterProxy = sqGetInterpreterProxy();
			dummyReferToProxy();
			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: */
			objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteArray ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			/* end splObj: */
			assert((rawHashBitsOf(objOop1)) != 0);
			GIV(classByteArrayCompactIndex) = (uint32AtPointer(objOop1 + 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 (i54 = InstanceSpecificationIndex + 1, iLimiT2 = lengthOfformat(classArrayClass2, (((usqInt) (longAt(classArrayClass2)) ) >> (formatShift())) & (formatMask())); i54 <= iLimiT2; i54 += 1) {
				if ((unsignedLongAt((classArrayClass2 + BaseHeaderSize) + ((sqInt) (((usqInt) (i54 - 1) ) << (shiftForWord())) ))) == classArrayObj2) {
					GIV(thisClassIndex) = i54 - 1;
				}
			};
			GIV(classNameIndex) = 6;
			for (i54 = InstanceSpecificationIndex + 1, iLimiT2 = lengthOfformat(classArrayObj2, (((usqInt) (longAt(classArrayObj2)) ) >> (formatShift())) & (formatMask())); i54 <= iLimiT2; i54 += 1) {
				/* begin fetchPointer:ofObject: */
				oop2 = unsignedLongAt((classArrayObj2 + BaseHeaderSize) + ((sqInt) (((usqInt) (i54 - 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) = i54 - 1;
				}
			};
			/* end initializeExtraClassInstVarIndices */
			GIV(method) = (GIV(newMethod) = GIV(nilObj));
			GIV(methodDictLinearSearchLimit) = 8;
			/* begin initialCleanup */
			/* begin flushMethodCache */
			{
				sqInt i;

				for (i3 = 1; i3 <= MethodCacheSize; i3 += 1) {
					GIV(methodCache)[i3] = 0;
				};
				GIV(lastMethodCacheProbeWrite) = 0;
			}
			unlinkAllSends();
			/* 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 *thePage;

	for (i = 0; i < GIV(numStackPages); i += 1) {
		/* begin stackPageAt: */
		thePage = stackPageAtpages(i, GIV(pages));
		/* end stackPageAt: */
		if (!(isFree(thePage))) {
			assertl(assertValidStackedInstructionPointersInline(thePage, ln), ln);
		}
	};
}
/*	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(unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) )))))) {
		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(unsignedLongAt((GIV(method) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ))))) {
		/* 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 object1;
	sqInt oop;
	sqInt oop1;
	sqInt oop2;
	sqInt oop3;
	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: */
		oop1 = unsignedLongAt(GIV(stackPointer) + (3 * BytesPerWord));
		unsignedLongAtput(GIV(stackPointer) + (1 * BytesPerWord), oop1);
		/* end stackValue:put: */
		unsignedLongAtput(GIV(stackPointer) + (2 * BytesPerWord), rcvr);
		unsignedLongAtput(GIV(stackPointer) + (3 * BytesPerWord), ((sqInt) cogMethod ) + entryOffset);
		/* begin callEnilopmart: */
		ceCallCogCodePopReceiverArg1Arg0Regs();
		/* end callEnilopmart: */
	}
	if (((cogMethod->cmNumArgs)) == 1) {
		/* begin stackValue:put: */
		oop2 = unsignedLongAt(GIV(stackPointer));
		unsignedLongAtput(GIV(stackPointer) + (2 * BytesPerWord), oop2);
		/* end stackValue:put: */
		/* begin push: */
		object1 = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
		unsignedLongAtput((sp2 = GIV(stackPointer) - BytesPerWord), object1);
		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(((cogMethod->cmNumArgs)) == 0);
	/* begin stackValue:put: */
	oop3 = unsignedLongAt(GIV(stackPointer));
	unsignedLongAtput(GIV(stackPointer) + (1 * BytesPerWord), oop3);
	/* 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: */
}
/*	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 l5;
			}
			while (((callerFP = pointerForOop(unsignedLongAt(fp + FoxSavedFP)))) != 0) {
				if (callerFP == theFP) {
					frameAbove = fp;
					goto l5;
				}
				fp = callerFP;
			};
			error("did not find theFP in stack page");
			frameAbove = 0;
			l5:
			;
			/* end findFrameAbove:inPage: */
			/* begin newStackPage */
			lruOrFree = (GIV(mostRecentlyUsedPage)->nextPage);
			if (((lruOrFree->baseFP)) == 0) {
				newPage = lruOrFree;
				goto l2;
			}
			divorceFramesIn(lruOrFree);
			newPage = lruOrFree;
			l2:
			;
			/* 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: */
		}
		GIV(instructionPointer) = 0;
		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: */
	}
	GIV(instructionPointer) = unsignedLongAt(GIV(stackPointer));
	if (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 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 object1;
	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: */
	object1 = ceCannotResumePC();
	unsignedLongAtput((sp3 = GIV(stackPointer) - BytesPerWord), object1);
	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 *thePage1;
	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(isMarriedOrWidowedContext(maybeMarriedContext));
		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))))) {
			int t10;
			int t11;
			int t2;
			int t3;

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

				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 l11;
		}
		/* 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: */
				thePage1 = GIV(stackPage);
				GIV(stackPointer) = (thePage1->headSP);
				GIV(framePointer) = (thePage1->headFP);
				/* end setStackPointersFromPage: */
			} else {
				markStackPageMostRecentlyUsed(GIV(stackPage));
			}
			goto l11;
		}
		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)))) {
			int t0;
			int t1;

			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 l5;
		}
		if (anOop & (tagMask())) {
			goto l5;
		}
		if (!(maybeMarriedContext >= 0x20000000000LL)) {
			goto l5;
		}
		if (anOop >= 0x20000000000LL) {
			goto l5;
		}
		if ((anOop >= GIV(nilObj)) && (anOop <= GIV(trueObj))) {
			goto l5;
		}
		if (!(anOop >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l5;
		}
		remember(getFromPermToNewSpaceRememberedSet(), maybeMarriedContext);
		l5:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((maybeMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) slotIndex ) << (shiftForWord())) ), anOop);
		/* end storePointer:ofObject:withValue: */
		if (slotIndex == StackPointerIndex) {
			ensureContextIsExecutionSafeAfterAssignToStackPointer(maybeMarriedContext);
		}
		markStackPageMostRecentlyUsed(GIV(stackPage));
		assertValidExecutionPointersimbarline(((usqInt) GIV(instructionPointer) ), GIV(framePointer), GIV(stackPointer), 1, __LINE__);
		l11:
		;
		/* 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)))) {
			int t0;
			int t1;

			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 l2;
		}
		if (anOop & (tagMask())) {
			goto l2;
		}
		if (!(maybeMarriedContext >= 0x20000000000LL)) {
			goto l2;
		}
		if (anOop >= 0x20000000000LL) {
			goto l2;
		}
		if ((anOop >= GIV(nilObj)) && (anOop <= GIV(trueObj))) {
			goto l2;
		}
		if (!(anOop >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l2;
		}
		remember(getFromPermToNewSpaceRememberedSet(), maybeMarriedContext);
		l2:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((maybeMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) slotIndex ) << (shiftForWord())) ), anOop);
		/* end storePointer:ofObject:withValue: */
	}
	return maybeMarriedContext;
}
/* CoInterpreter>>#ceInterpretMethodFromPIC:receiver: */
sqInt
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)));
		if (methodShouldBeCogged(aMethodObj)) {
			cogselector(aMethodObj, (pic->selector));
		}
	}
	if ((assert(isNonImmediate(aMethodObj)), isCogMethodReference(unsignedLongAt((aMethodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ))))) {
		executeCogMethodfromUnlinkedSendWithReceiver(cogMethodOf(aMethodObj), rcvr);
	}
	GIV(messageSelector) = (pic->selector);
	GIV(newMethod) = aMethodObj;
	/* begin primitiveIndexOfMethod:header: */
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(aMethodObj));
	header = unsignedLongAt((aMethodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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:inClass: */
	primitiveFunctionPointer = ((void (*)(void)) (((primitiveIndex > MaxPrimitiveIndex)
		 ? 0
		 : primitiveTable[primitiveIndex])) );
	/* end functionPointerFor:inClass: */
	GIV(argumentCount) = (pic->cmNumArgs);
	/* begin popStack */
	top = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	GIV(instructionPointer) = top;
	/* end popStack */
	return interpretMethodFromMachineCode();
}
/* CoInterpreter>>#ceMNUFromPICMNUMethod:receiver: */
sqInt
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(unsignedLongAt((aMethodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) )))))) {
			/* 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));
		header = unsignedLongAt((aMethodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		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:inClass: */
		primitiveFunctionPointer = ((void (*)(void)) (((primitiveIndex > MaxPrimitiveIndex)
			 ? 0
			 : primitiveTable[primitiveIndex])) );
		/* end functionPointerFor:inClass: */
		return interpretMethodFromMachineCode();
	}
	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);
	return 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 *theFP1;
	char *theFP2;
	char *theFP3;
	char *theFP4;
	char *theFP5;
	char *theFP6;
	StackPage *thePage;
	StackPage *thePage2;
	StackPage *thePage3;
	StackPage *thePage4;
	char *theSP;
	char *theSP1;
	char *theSP2;
	char *theSP3;
	char *theSP4;
	sqInt top;
	sqInt unwindContextOrNilOrZero;
	sqInt valuePointer;
	sqInt valuePointer1;

	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: */
	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 */
	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: */
			theFP1 = GIV(framePointer);
			theSP = GIV(stackPointer);
			if (((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP1 + FoxMethod)) )))
				 ? ((unsignedLongAt(theFP1 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
				 : (byteAt((theFP1 + FoxIFrameFlags) + 2)) != 0)) {
				assert(isContext(frameContext(theFP1)));
				ourContext = unsignedLongAt(theFP1 + FoxThisContext);
				goto l8;
			}
			ourContext = marryFrameSP(theFP1, theSP);
			l8:
			;
			/* 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: */
		theFP2 = GIV(framePointer);
		theSP1 = 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 l13;
		}
		ourContext = marryFrameSP(theFP2, theSP1);
		l13:
		;
		/* 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: */
		theFP4 = GIV(framePointer);
		theSP4 = GIV(stackPointer);
		if (((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP4 + FoxMethod)) )))
			 ? ((unsignedLongAt(theFP4 + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
			 : (byteAt((theFP4 + FoxIFrameFlags) + 2)) != 0)) {
			assert(isContext(frameContext(theFP4)));
			ourContext2 = unsignedLongAt(theFP4 + FoxThisContext);
			goto l17;
		}
		ourContext2 = marryFrameSP(theFP4, theSP4);
		l17:
		;
		/* 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: */
			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((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: */
		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: */
		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: */
				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 {
				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: */
					valuePointer1 = GIV(nilObj);
					assert(!(isOopForwarded(currentCtx)));
					longAtput((currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), valuePointer1);
					/* 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: */
sqInt
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);
	return null;
}
/*	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 fieldIndex1;
	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: */
		fieldIndex = ((usqInt) classTag ) >> (classTableMajorIndexShift());
		classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (classTablePage == GIV(nilObj)) {
			classObj = null;
			goto l4;
		}
		/* begin fetchPointer:ofObject: */
		fieldIndex1 = classTag & ((1U << (classTableMajorIndexShift())) - 1);
		classObj = unsignedLongAt((classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		l4:
		;
		/* end classAtIndex: */
		if (((errSelIdx = lookupOrdinaryNoMNUEtcInClass(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(unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) )))))) {
		/* begin executeNewMethod */
		/* begin executeNewMethod: */
		inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
		/* begin executePrimitiveFromInterpreter:ifFail: */
		if (primitiveFunctionPointer != 0) {
			int t18;

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

				executeQuickPrimitive();
				/* begin returnToExecutive: */
				returntoExecutive(popStack(), inInterpreter);
				/* end returnToExecutive: */
				goto l8;
			}
			/* 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) {
				int t0;
				int t1;

				if (((freeStart()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart())) != (freeStart()))) {
					/* 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) {
				sqInt t1;

				/* begin returnToExecutive: */
				returntoExecutive(popStack(), inInterpreter);
				/* end returnToExecutive: */
				goto l8;
			}
		}
		{
			{
				/* 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();
		}
		l8:
		;
		/* end executePrimitiveFromInterpreter:ifFail: */
		/* end executeNewMethod: */
		/* end executeNewMethod */
		assert(0);
	}
	return interpretMethodFromMachineCode();
}
/*	Send from an Open PIC 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.self printFrame: stackPage headFP WithSP: stackPage headSPself printStringOf: selector */
/* CoInterpreter>>#ceSendFromInLineCacheMiss: */
sqInt
ceSendFromInLineCacheMiss(CogMethod *cogMethodOrPIC)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt classObj;
	sqInt classTablePage;
	sqInt classTag;
	CogMethod *cogMethod;
	sqInt errSelIdx;
	sqInt fieldIndex;
	sqInt fieldIndex1;
	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 );
	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 (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 {
		if (((((cogMethodOrPIC->selector)) & (tagMask())) == 0) && (((long64At((cogMethodOrPIC->selector))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			setSelectorOfto(cogMethodOrPIC, handleForwardedSelectorFaultFor((cogMethodOrPIC->selector)));
			return ceSendFromInLineCacheMiss(cogMethodOrPIC);
		}
		if (classTag == (isForwardedObjectClassIndexPun())) {
			handleForwardedSendFaultForReceiverstackDelta(rcvr, 1);
			return ceSendFromInLineCacheMiss(cogMethodOrPIC);
		}
		GIV(messageSelector) = (cogMethodOrPIC->selector);
		/* begin classAtIndex: */
		assert((classTag >= 0) && ((classTag <= (tagMask())) || ((classTag >= (arrayClassIndexPun())) && (classTag <= (classIndexMask())))));
		/* begin fetchPointer:ofObject: */
		fieldIndex = ((usqInt) classTag ) >> (classTableMajorIndexShift());
		classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (classTablePage == GIV(nilObj)) {
			classObj = null;
			goto l4;
		}
		/* begin fetchPointer:ofObject: */
		fieldIndex1 = classTag & ((1U << (classTableMajorIndexShift())) - 1);
		classObj = unsignedLongAt((classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		l4:
		;
		/* end classAtIndex: */
		if (((errSelIdx = lookupOrdinaryNoMNUEtcInClass(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(unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) )))))) {
		/* begin executeNewMethod */
		/* begin executeNewMethod: */
		inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
		/* begin executePrimitiveFromInterpreter:ifFail: */
		if (primitiveFunctionPointer != 0) {
			int t18;

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

				executeQuickPrimitive();
				/* begin returnToExecutive: */
				returntoExecutive(popStack(), inInterpreter);
				/* end returnToExecutive: */
				goto l8;
			}
			/* 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) {
				int t0;
				int t1;

				if (((freeStart()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart())) != (freeStart()))) {
					/* 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) {
				sqInt t1;

				/* begin returnToExecutive: */
				returntoExecutive(popStack(), inInterpreter);
				/* end returnToExecutive: */
				goto l8;
			}
		}
		{
			{
				/* 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();
		}
		l8:
		;
		/* end executePrimitiveFromInterpreter:ifFail: */
		/* end executeNewMethod: */
		/* end executeNewMethod */
		assert(0);
	}
	return interpretMethodFromMachineCode();
}
/*	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. Smalltalk 
	stack looks like 
	receiver 
	args 
	head sp ->	sender return pc 
	methodClassBinding is an association whose value is the class above which 
	to start the lookup. */
/* 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. Smalltalk 
	stack looks like 
	receiver 
	args 
	head sp ->	sender return pc 
	methodClass is the class above which to start the lookup. 
	 
	If an MNU then defer to handleMNUInMachineCodeTo:... which will dispatch 
	the MNU and 
	may choose to allocate a closed PIC with a fast MNU dispatch for this 
	send. Otherwise 
	attempt to link the send site as efficiently as possible. All link 
	attempts may fail; e.g. 
	because we're out of code memory. 
	 
	Continue execution via either executeMethod or 
	interpretMethodFromMachineCode: depending on whether the target method is 
	cogged or not. */
/* CoInterpreter>>#ceSend:above:to:numArgs: */
sqInt
ceSendabovetonumArgs(sqInt selector, sqInt methodClass, sqInt rcvr, sqInt numArgs)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt classObj;
	sqInt classObj1;
	sqInt classPointer;
	sqInt classTablePage;
	sqInt classTag;
	CogMethod *cogMethod;
	CogMethod *cogMethod2;
	sqInt err;
	sqInt errSelIdx;
	sqInt fieldIndex;
	sqInt fieldIndex1;
	sqInt hash;
	sqInt inInterpreter;
	sqInt methodHeader;
	sqInt methodHeader2;
	sqInt methodHeader3;
	sqInt nArgs;
	CogMethod *newCogMethod;
	sqInt objOop;
	char *savedFramePointer;
	char *savedStackPointer;
	sqInt succeeded;
	sqInt top;
	sqInt top2;

	nArgs = 0;
	savedFramePointer = ((char *) 0 );
	savedStackPointer = ((char *) 0 );
	assertCStackWellAligned();
	assert(addressCouldBeOop(rcvr));
	/* begin sendBreakpoint:receiver: */
	sendBreakpointreceiver(firstFixedFieldOfMaybeImmediate(selector), lengthOfMaybeImmediate(selector), rcvr);
	/* end sendBreakpoint:receiver: */
	/* begin classTagForClass: */
	/* 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);
	}
	classObj1 = objOop;
	/* end followField:ofObject: */
	/* end superclassOf: */
	{
		assert(addressCouldBeClassObj(classObj1));
		classTag = ((((hash = (uint32AtPointer(classObj1 + 4)) & (identityHashHalfWordMask()))) != 0)
			 ? hash
			 : ((objCouldBeClassObj(classObj1))
				 ? ((((err = enterIntoClassTable(classObj1))) != 0)
					 ? -err
					 : (/* begin rawHashBitsOf: */ (uint32AtPointer(classObj1 + 4)) & (identityHashHalfWordMask()) /* end rawHashBitsOf: */))
				 : -PrimErrBadReceiver));
	}
	/* end classTagForClass: */
	GIV(argumentCount) = numArgs;
	if (lookupInMethodCacheSelclassTag(selector, classTag)) {
		/* 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: */
	} else {
		assert(!(isForwardedClassTag(classTag)));
		if (((selector & (tagMask())) == 0) && (((long64At(selector)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			return ceSendabovetonumArgs(handleForwardedSelectorFaultFor(selector), methodClass, rcvr, numArgs);
		}
		GIV(messageSelector) = selector;
		/* begin classAtIndex: */
		assert((classTag >= 0) && ((classTag <= (tagMask())) || ((classTag >= (arrayClassIndexPun())) && (classTag <= (classIndexMask())))));
		/* begin fetchPointer:ofObject: */
		fieldIndex = ((usqInt) classTag ) >> (classTableMajorIndexShift());
		classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (classTablePage == GIV(nilObj)) {
			classObj = null;
			goto l4;
		}
		/* begin fetchPointer:ofObject: */
		fieldIndex1 = classTag & ((1U << (classTableMajorIndexShift())) - 1);
		classObj = unsignedLongAt((classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		l4:
		;
		/* end classAtIndex: */
		if (((errSelIdx = lookupOrdinaryNoMNUEtcInClass(classObj))) != 0) {
			if ((errSelIdx == SelectorDoesNotUnderstand) && (((usqInt) ((cogMethod = cogMNUPICSelectorreceivermethodOperandnumArgs(GIV(messageSelector), rcvr, mnuMethodOrNilFor(rcvr), GIV(argumentCount)))) ) > (minCogMethodAddress()))) {
				linkSendAtintooffsetreceiver(longAt(GIV(stackPointer)), mframeHomeMethod(GIV(framePointer)), cogMethod, noCheckEntryOffset(), rcvr);
			}
			handleMNUInMachineCodeToclassForMessage(errSelIdx, rcvr, classObj);
			assert(0);
		}
	}
	if (((GIV(newMethod) & (tagMask())) == 0) && ((((((usqInt) (longAt(GIV(newMethod))) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && (isCogMethodReference(unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) )))))) {
		/* 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);
		} else {
			if (((cogMethod->selector)) != selector) {
				{
					newCogMethod = cogselector(GIV(newMethod), selector);
					if (!(newCogMethod == null)) {
						cogMethod = newCogMethod;
					}
				}
			}
		}
		if (((cogMethod->selector)) == selector) {
			linkSendAtintooffsetreceiver(longAt(GIV(stackPointer)), mframeHomeMethod(GIV(framePointer)), cogMethod, noCheckEntryOffset(), rcvr);
		}
		/* begin popStack */
		top = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		GIV(instructionPointer) = top;
		/* end popStack */
		/* begin executeNewMethod */
		/* begin executeNewMethod: */
		inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
		/* begin executePrimitiveFromInterpreter:ifFail: */
		if (primitiveFunctionPointer != 0) {
			int t18;

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

				executeQuickPrimitive();
				/* begin returnToExecutive: */
				returntoExecutive(popStack(), inInterpreter);
				/* end returnToExecutive: */
				goto l14;
			}
			/* 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) {
				int t0;
				int t1;

				if (((freeStart()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart())) != (freeStart()))) {
					/* 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 l15;
			l15:
			;
			/* end slowPrimitiveResponse */
			if (succeeded) {
				sqInt t1;

				/* begin returnToExecutive: */
				returntoExecutive(popStack(), inInterpreter);
				/* end returnToExecutive: */
				goto l14;
			}
		}
		{
			{
				/* 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();
		}
		l14:
		;
		/* end executePrimitiveFromInterpreter:ifFail: */
		/* end executeNewMethod: */
		/* end executeNewMethod */
		assert(0);
	}
	/* begin popStack */
	top2 = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	GIV(instructionPointer) = top2;
	/* end popStack */
	return interpretMethodFromMachineCode();
}
/*	Entry-point for an unlinked send in a CogMethod. Smalltalk stack looks 
	like receiver 
	args 
	head sp ->	sender return pc 
	 
	If an MNU then defer to handleMNUInMachineCodeTo:... which will dispatch 
	the MNU and 
	may choose to allocate a closed PIC with a fast MNU dispatch for this 
	send. Otherwise 
	attempt to link the send site as efficiently as possible. All link 
	attempts may fail; e.g. 
	because we're out of code memory. 
	 
	Continue execution via either executeMethod or 
	interpretMethodFromMachineCode: depending on whether the target method is 
	cogged or not. */
/* CoInterpreter>>#ceSend:super:to:numArgs: */
sqInt
ceSendsupertonumArgs(sqInt selector, sqInt superNormalBar, sqInt rcvr, sqInt numArgs)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt classObj;
	sqInt classObj1;
	sqInt classPointer;
	sqInt classTablePage;
	sqInt classTag;
	CogMethod *cogMethod;
	CogMethod *cogMethod2;
	sqInt err;
	sqInt errSelIdx;
	sqInt fieldIndex;
	sqInt fieldIndex1;
	sqInt hash;
	sqInt inInterpreter;
	sqInt literal;
	sqInt methodHeader;
	sqInt methodHeader2;
	sqInt methodHeader3;
	sqInt methodPointer;
	sqInt nArgs;
	CogMethod *newCogMethod;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop3;
	sqInt offset;
	char *savedFramePointer;
	char *savedStackPointer;
	sqInt succeeded;
	sqInt tagBits;
	sqInt top;
	sqInt top2;

	nArgs = 0;
	savedFramePointer = ((char *) 0 );
	savedStackPointer = ((char *) 0 );
	assertCStackWellAligned();
	assert(addressCouldBeOop(rcvr));
	/* begin sendBreakpoint:receiver: */
	sendBreakpointreceiver(firstFixedFieldOfMaybeImmediate(selector), lengthOfMaybeImmediate(selector), rcvr);
	/* end sendBreakpoint:receiver: */
	if (superNormalBar == 0) {
		if (((tagBits = rcvr & (tagMask()))) != 0) {
			classTag = tagBits;
		} else {
			/* begin classIndexOf: */
			classTag = (longAt(rcvr)) & (classIndexMask());
			/* end classIndexOf: */
		}
	} else {
		/* begin classTagForClass: */
		/* begin superclassOf: */
		/* begin methodClassOf: */
		if (isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) ))) {
			methodPointer = ((mframeHomeMethod(GIV(framePointer)))->methodObject);
		} else {
			/* begin iframeMethod: */
			methodPointer = 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))) {
			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: */
			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);
		}
		classObj1 = objOop;
		/* end followField:ofObject: */
		/* end superclassOf: */
		{
			assert(addressCouldBeClassObj(classObj1));
			classTag = ((((hash = (uint32AtPointer(classObj1 + 4)) & (identityHashHalfWordMask()))) != 0)
				 ? hash
				 : ((objCouldBeClassObj(classObj1))
					 ? ((((err = enterIntoClassTable(classObj1))) != 0)
						 ? -err
						 : (/* begin rawHashBitsOf: */ (uint32AtPointer(classObj1 + 4)) & (identityHashHalfWordMask()) /* end rawHashBitsOf: */))
					 : -PrimErrBadReceiver));
		}
		/* end classTagForClass: */
	}
	GIV(argumentCount) = numArgs;
	if (lookupInMethodCacheSelclassTag(selector, classTag)) {
		/* 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: */
	} else {
		if (((selector & (tagMask())) == 0) && (((long64At(selector)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			return ceSendsupertonumArgs(handleForwardedSelectorFaultFor(selector), superNormalBar, rcvr, numArgs);
		}
		if (classTag == (isForwardedObjectClassIndexPun())) {
			assert(superNormalBar == 0);
			return ceSendsupertonumArgs(selector, superNormalBar, handleForwardedSendFaultForReceiverstackDelta(rcvr, 1), numArgs);
		}
		GIV(messageSelector) = selector;
		/* begin classAtIndex: */
		assert((classTag >= 0) && ((classTag <= (tagMask())) || ((classTag >= (arrayClassIndexPun())) && (classTag <= (classIndexMask())))));
		/* begin fetchPointer:ofObject: */
		fieldIndex = ((usqInt) classTag ) >> (classTableMajorIndexShift());
		classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (classTablePage == GIV(nilObj)) {
			classObj = null;
			goto l8;
		}
		/* begin fetchPointer:ofObject: */
		fieldIndex1 = classTag & ((1U << (classTableMajorIndexShift())) - 1);
		classObj = unsignedLongAt((classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		l8:
		;
		/* end classAtIndex: */
		if (((errSelIdx = lookupOrdinaryNoMNUEtcInClass(classObj))) != 0) {
			if ((errSelIdx == SelectorDoesNotUnderstand) && (((usqInt) ((cogMethod = cogMNUPICSelectorreceivermethodOperandnumArgs(GIV(messageSelector), rcvr, mnuMethodOrNilFor(rcvr), GIV(argumentCount)))) ) > (minCogMethodAddress()))) {
				linkSendAtintooffsetreceiver(longAt(GIV(stackPointer)), mframeHomeMethod(GIV(framePointer)), cogMethod, ((superNormalBar == 0)
					 ? entryOffset()
					 : noCheckEntryOffset()), rcvr);
			}
			handleMNUInMachineCodeToclassForMessage(errSelIdx, rcvr, classObj);
			assert(0);
		}
	}
	if (((GIV(newMethod) & (tagMask())) == 0) && ((((((usqInt) (longAt(GIV(newMethod))) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) && (isCogMethodReference(unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) )))))) {
		/* 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);
		} else {
			if (((cogMethod->selector)) != selector) {
				{
					newCogMethod = cogselector(GIV(newMethod), selector);
					if (!(newCogMethod == null)) {
						cogMethod = newCogMethod;
					}
				}
			}
		}
		if (((cogMethod->selector)) == selector) {
			linkSendAtintooffsetreceiver(longAt(GIV(stackPointer)), mframeHomeMethod(GIV(framePointer)), cogMethod, ((superNormalBar == 0)
				 ? entryOffset()
				 : noCheckEntryOffset()), rcvr);
		} else {
			if (superNormalBar == 0) {
				patchToOpenPICFornumArgsreceiver(selector, numArgs, rcvr);
			}
		}
		/* begin popStack */
		top = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		GIV(instructionPointer) = top;
		/* end popStack */
		/* begin executeNewMethod */
		/* begin executeNewMethod: */
		inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
		/* begin executePrimitiveFromInterpreter:ifFail: */
		if (primitiveFunctionPointer != 0) {
			int t18;

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

				executeQuickPrimitive();
				/* begin returnToExecutive: */
				returntoExecutive(popStack(), inInterpreter);
				/* end returnToExecutive: */
				goto l20;
			}
			/* 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) {
				int t0;
				int t1;

				if (((freeStart()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart())) != (freeStart()))) {
					/* 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) {
				sqInt t1;

				/* begin returnToExecutive: */
				returntoExecutive(popStack(), inInterpreter);
				/* end returnToExecutive: */
				goto l20;
			}
		}
		{
			{
				/* 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();
		}
		l20:
		;
		/* end executePrimitiveFromInterpreter:ifFail: */
		/* end executeNewMethod: */
		/* end executeNewMethod */
		assert(0);
	}
	/* begin popStack */
	top2 = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	GIV(instructionPointer) = top2;
	/* end popStack */
	return interpretMethodFromMachineCode();
}
/*	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: */ longAt(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 selector1;
	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: */
	selector1 = (cogMethod->selector);
	sendBreakpointreceiver(firstFixedFieldOfMaybeImmediate(selector1), lengthOfMaybeImmediate(selector1), 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;
}
/*	Check if the argument is an ok object. 
	If this is a pointers object, check that its fields are all okay oops. */
/* CoInterpreter>>#checkOkayFields: */
static sqInt NoDbgRegParms
checkOkayFields(sqInt oop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt fieldOop;
	sqInt hasYoung;
	sqInt i;

	if ((oop == null) || (oop == 0)) {
		return 1;
	}
	if (((oop & 7) == 1)) {
		return 1;
	}
	if (!(checkOkayOop(oop))) {
		return 0;
	}
	if (!(checkOopHasOkayClass(oop))) {
		return 0;
	}
	if (!((((((usqInt) (longAt(oop)) ) >> (formatShift())) & (formatMask())) <= 5) || (((((usqInt) (longAt(oop)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())))) {
		return 1;
	}
	hasYoung = 0;
	if (((((usqInt) (longAt(oop)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
		i = ((literalCountOfMethodHeader(methodHeaderOf(oop))) + LiteralStart) - 1;
	} else {
		if (((oop & (tagMask())) == 0) && (((longAt(oop)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
			i = (CtxtTempFrameStart + (fetchStackPointerOf(oop))) - 1;
		} else {
			i = (lengthOfformat(oop, (((usqInt) (longAt(oop)) ) >> (formatShift())) & (formatMask()))) - 1;
		}
	}
	while (i >= 0) {
		fieldOop = unsignedLongAt((oop + BaseHeaderSize) + ((sqInt) (((usqInt) i ) << (shiftForWord())) ));
		if ((fieldOop & (smallIntegerTag())) == 0) {
			if ((i == 0) && (((((usqInt) (longAt(oop)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()))) {
				if ((methodFor(pointerForOop(fieldOop))) == 0) {
					{
						print("method ");
						printHex(oop);
						print(" has an invalid cog method reference");
					}
					return 0;
				}
			} else {
				hasYoung = hasYoung || (((fieldOop & (tagMask())) == 0) && (((fieldOop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (fieldOop >= ((GIV(memoryMap)->newSpaceStart)))));
				if (!(checkOkayOop(fieldOop))) {
					return 0;
				}
				if (!(checkOopHasOkayClass(fieldOop))) {
					return 0;
				}
			}
		}
		i -= 1;
	};
	if (hasYoung) {
		/* begin checkOkayYoungReferrer: */
		if (oopisLessThan(oop, (GIV(memoryMap)->newSpaceEnd))) {
			return 1;
		}
		if (!(((((usqInt) (long64At(oop)) ) >> (rememberedBitShift())) & 1) != 0)) {
			{
				print("remembered bit is not set in ");
				printHex(oop);
				/* begin cr */
				print("\n");
				/* end cr */
			}
			return 0;
		}
		if (isInRememberedSet(getFromOldSpaceRememberedSet(), oop)) {
			return 1;
		}
		if (isInRememberedSet(getFromPermToNewSpaceRememberedSet(), oop)) {
			return 1;
		}
		{
			printHex(oop);
			print(" has remembered bit set but is not in remembered set");
			/* begin cr */
			print("\n");
			/* end cr */
		}
		return 0;
		/* end checkOkayYoungReferrer: */
	}
	return 1;
}
/*	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. */
/* CoInterpreter>>#checkStackIntegrity */
static sqInt
checkStackIntegrity(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *callerFP;
	CogMethod *cogMethod;
	char *frameRcvrOffset;
	sqInt i;
	sqInt methodField;
	int ok;
	sqInt oop;
	char *theFP;
	StackPage *thePage;
	char *theSP;

	ok = 1;
	for (i = 0; i < GIV(numStackPages); i += 1) {
		/* begin stackPageAt: */
		thePage = stackPageAtpages(i, GIV(pages));
		/* end stackPageAt: */
		if (!(isFree(thePage))) {
			if (thePage == GIV(stackPage)) {
				theSP = GIV(stackPointer);
				theFP = GIV(framePointer);
			} else {
				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) && ((heapMapAtWord(pointerForOop(oop))) == 0)) {
						printFrameThingandFrameat("object leak in frame temp", theFP, theSP);
						ok = 0;
					}
					theSP += BytesPerWord;
				};
				if (((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
					 ? (/* begin mframeHasContext: */ ((unsignedLongAt(theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0 /* end mframeHasContext: */)
					 : (/* begin iframeHasContext: */ (byteAt((theFP + FoxIFrameFlags) + 2)) != 0 /* end iframeHasContext: */))) {
					oop = unsignedLongAt(theFP + FoxThisContext);
					if ((oop & (tagMask())) || ((heapMapAtWord(pointerForOop(oop))) == 0)) {
						printFrameThingandFrameat("object leak in frame ctxt", theFP, theFP + FoxThisContext);
						ok = 0;
					}
					if (!(((oop & (tagMask())) == 0) && (((longAt(oop)) & (classIndexMask())) == ClassMethodContextCompactIndex))) {
						printFrameThingandFrameat("frame ctxt should be context", theFP, theFP + 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", theFP, theFP + FoxThisContext);
						ok = 0;
					}
					if (!((((oop & (tagMask())) == 0) && (((longAt(oop)) & (classIndexMask())) == ClassMethodContextCompactIndex)) && ((frameOfMarriedContext(oop)) == theFP))) {
						printFrameThingandFrameat("frame ctxt should be married to this frame ", theFP, theFP + FoxThisContext);
						ok = 0;
					}
				}
				if (isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) ))) {
					/* begin mframeHomeMethod: */
					methodField = unsignedLongAt(theFP + FoxMethod);
					cogMethod = ((CogMethod *) (methodField & MFMethodMask) );
					/* end mframeHomeMethod: */
					if ((heapMapAtWord(pointerForOop(cogMethod))) == 0) {
						printFrameThingandFrameat("object leak in mframe mthd", theFP, theFP + FoxMethod);
						ok = 0;
					}
				} else {
					oop = unsignedLongAt(theFP + FoxMethod);
					if ((oop & (tagMask())) || ((heapMapAtWord(pointerForOop(oop))) == 0)) {
						printFrameThingandFrameat("object leak in iframe mthd", theFP, theFP + FoxMethod);
						ok = 0;
					}
				}
				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) && ((heapMapAtWord(pointerForOop(oop))) == 0)) {
					printFrameThingandFrameat("object leak in frame arg", theFP, theSP);
					ok = 0;
				}
				theSP += BytesPerWord;
			};
		}
	};
	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(((usqInt) (stackTop()) ) != 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 theIP, char *theFP)
{
	CogMethod *cogMethod;

	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: */
	}
	return ((((usqInt) ((((((theIP == (ceReturnToInterpreterPC()))
		 ? unsignedLongAt(theFP + FoxIFSavedIP)
		 : theIP)) - (unsignedLongAt(theFP + FoxMethod))) - BaseHeaderSize) + 2) ) << 3) | 1);
}
/*	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 l1;
			}
			theContext = marryFrameSP(theFP, theSP);
			l1:
			;
			/* 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);
	}
	/* begin setMethod: */
	aMethodObj = unsignedLongAt(GIV(framePointer) + FoxMethod);
	assert(((usqInt) aMethodObj ) >= (startOfObjectMemory(getMemoryMap())));
	{
		GIV(method) = aMethodObj;
		assert(isOopCompiledMethod(GIV(method)));
	}
	/* end setMethod: */
	if (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: */
}
/*	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: */
}
/*	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: */
}
/*	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 fieldIndex1;
	sqInt methodHeader;
	sqInt methodHeader2;
	sqInt referent;
	sqInt selector;
	sqInt selector1;

	/* begin findNewMethodInClassTag:ifFound: */
	classTag = classTagArg;
	if (inlineLookupInMethodCacheSelclassTag(GIV(messageSelector), classTag)) {
		{
			/* begin ifAppropriateCompileToNativeCode:selector: */
			selector1 = 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, selector1);
				}
			} else {
				if (((assert(((methodHeader2 & 7) == 1)), (methodHeader2 >> 3) & AlternateHeaderNumLiteralsMask)) <= maxLiteralCountForCompile) {
					cogselector(GIV(newMethod), selector1);
				} else {
					maybeFlagMethodAsInterpreted(GIV(newMethod));
				}
			}
			/* end ifAppropriateCompileToNativeCode:selector: */
		}
	} else {
		int t0;
		int t1;
		int t16;
		int t17;
		int t2;

		if ((((GIV(messageSelector) & (tagMask())) == 0) && (((long64At(GIV(messageSelector))) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) || (classTag == (isForwardedObjectClassIndexPun()))) {
			int t0;
			int t1;

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

				GIV(messageSelector) = handleForwardedSelectorFaultFor(GIV(messageSelector));
			}
			if (classTag == (isForwardedObjectClassIndexPun())) {
				sqInt t0;

				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 l6;
			}
		}
		/* begin classAtIndex: */
		assert((classTag >= 0) && ((classTag <= (tagMask())) || ((classTag >= (arrayClassIndexPun())) && (classTag <= (classIndexMask())))));
		/* begin fetchPointer:ofObject: */
		fieldIndex = ((usqInt) classTag ) >> (classTableMajorIndexShift());
		classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (classTablePage == GIV(nilObj)) {
			GIV(lkupClass) = null;
			goto l5;
		}
		/* begin fetchPointer:ofObject: */
		fieldIndex1 = classTag & ((1U << (classTableMajorIndexShift())) - 1);
		GIV(lkupClass) = unsignedLongAt((classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		l5:
		;
		/* 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));
	}
	l6:
	;
	/* 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 primIdx1;

	{
		/* begin methodHeaderOf: */
		assert(isCompiledMethod(methodObj));
		header2 = unsignedLongAt((methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		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;
			primIdx1 = (byteAt(firstBytecode + 1)) + ((sqInt) (((usqInt) (byteAt(firstBytecode + 2)) ) << 8) );
		} else {
			primIdx1 = 0;
		}
		if ((primIdx1 == 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 = primIdx1;
	}
	if ((primIdx == PrimNumberExternalCall) && ((assert(isNonImmediate(methodObj)), /* begin isCogMethodReference: */ (methodHeader = unsignedLongAt((methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ))), 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);
		}
	}
}
/*	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. 
	 
	Override to handle machine code frames */
/* CoInterpreter>>#followForwardingPointersInStackZone: */
static void NoDbgRegParms
followForwardingPointersInStackZone(sqInt theBecomeEffectsFlags)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *callerFP;
	sqInt i;
	sqInt newOop;
	sqInt numArgs;
	sqInt offset;
	sqInt oop;
	sqInt referent;
	sqInt referent2;
	sqInt referent3;
	char *theFP;
	usqInt theIPPtr;
	StackPage *thePage;
	char *theSP;
	char *theSP1;

	/* begin writeBackHeadFramePointers */
	assert((GIV(framePointer) - GIV(stackPointer)) < (LargeContextSlots * BytesPerOop));
	assert(GIV(stackPage) == (mostRecentlyUsedPage()));
	assert(!(isFree(GIV(stackPage))));
	/* begin setHeadFP:andSP:inPage: */
	theSP1 = GIV(stackPointer);
	assert(theSP1 < GIV(framePointer));
	assert((theSP1 < ((GIV(stackPage)->baseAddress))) && (theSP1 > (((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 = theSP1);
	}
	/* 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);
	for (i = 0; i < GIV(numStackPages); i += 1) {
		/* begin stackPageAt: */
		thePage = stackPageAtpages(i, GIV(pages));
		/* end stackPageAt: */
		if (!(((thePage->baseFP)) == 0)) {
			assert(ifCurrentStackPageHasValidHeadPointers(thePage));
			theFP = (thePage->headFP);
			theIPPtr = ((thePage == GIV(stackPage))
				 ? 0
				 : ((usqInt) ((thePage->headSP)) ));
			while (1) {
				assert(addressIsInPage(thePage, theFP));
				assert((theIPPtr == 0) || (addressIsInPage(thePage, ((void *) theIPPtr ))));
				if (isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) ))) {
					oop = unsignedLongAt(theFP + FoxMFReceiver);
					if (((oop & (tagMask())) == 0) && (((long64At(oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						unsignedLongAtput(theFP + FoxMFReceiver, followForwarded(oop));
					}
					assert(!(isForwarded(((mframeHomeMethod(theFP))->methodObject))));
				} else {
					oop = unsignedLongAt(theFP + FoxIFReceiver);
					if (((oop & (tagMask())) == 0) && (((long64At(oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
						unsignedLongAtput(theFP + FoxIFReceiver, followForwarded(oop));
					}
					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 + FoxIFSavedIP, (unsignedLongAt(theFP + FoxIFSavedIP)) + offset);
						unsignedLongAtput(theFP + FoxMethod, (oop = newOop));
					}
				}
				if ((((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
					 ? (/* begin mframeHasContext: */ ((unsignedLongAt(theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0 /* end mframeHasContext: */)
					 : (/* begin iframeHasContext: */ (byteAt((theFP + FoxIFrameFlags) + 2)) != 0 /* end iframeHasContext: */))) && (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 = ((thePage->baseAddress)) - BytesPerWord;
			while (theSP <= ((thePage->baseAddress))) {
				oop = unsignedLongAt(theSP);
				if (((long64At(oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
					unsignedLongAtput(theSP, followForwarded(oop));
				}
				theSP += BytesPerWord;
			};
		}
	};
}
/*	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 l1;
		}
		if ((GIV(longRunningPrimitiveStartUsecs) > 0) && ((GIV(longRunningPrimitiveCheckMethod) == GIV(newMethod)) && (GIV(longRunningPrimitiveCheckSequenceNumber) == GIV(statCheckForEvents)))) {
			GIV(longRunningPrimitiveStopUsecs) = ioUTCMicroseconds();
			assert(GIV(longRunningPrimitiveStopUsecs) > GIV(longRunningPrimitiveStartUsecs));
			goto l1;
		}
		if (GIV(longRunningPrimitiveStopUsecs) == 0) {
			GIV(longRunningPrimitiveCheckSequenceNumber) = GIV(statCheckForEvents);
			GIV(longRunningPrimitiveCheckMethod) = GIV(newMethod);
			GIV(longRunningPrimitiveStartUsecs) = ioUTCMicroseconds();
			sqLowLevelMFence();
		}
		l1:
		;
		/* end checkForLongRunningPrimitive */
		sqLowLevelMFence();
		if (GIV(deferSmash)) {
			GIV(deferredSmash) = 1;
			sqLowLevelMFence();
		} else {
			forceInterruptCheck();
		}
	}
}
/*	In the StackInterpreter the saved ip field of a base frame holds the 
	base frame's caller context. But in the Cog VM the first word on the 
	stack holds the base frame's caller context, which is immediately 
	above the stacked receiver. */
/* CoInterpreter>>#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;
}
/* 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> */
/* 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)) )))
		 ? longAt(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:inClass: */
	functionPointer = ((void (*)(void)) (((primIndex > MaxPrimitiveIndex)
		 ? 0
		 : primitiveTable[primIndex])) );
	/* end functionPointerFor:inClass: */
	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:stackDelta: */
static sqInt NoDbgRegParms
handleForwardedSendFaultForReceiverstackDelta(sqInt forwardedReceiver, sqInt stackDelta)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt rcvr;
	sqInt rcvrStackIndex;
	sqInt referent;

	assert(isOopForwarded(forwardedReceiver));
	rcvrStackIndex = GIV(argumentCount) + stackDelta;
	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)) )))
		 ? longAt(GIV(framePointer) + FoxMFReceiver)
		 : unsignedLongAt(GIV(framePointer) + FoxIFReceiver)))) {
		followForwardedObjectFieldstoDepth(((isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))
			 ? longAt(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 = lookupMNUInClass((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(unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) )))))) {
		/* begin push: */
		unsignedLongAtput((sp2 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
		GIV(stackPointer) = sp2;
		/* end push: */
		executeCogMethodfromUnlinkedSendWithReceiver(cogMethodOf(GIV(newMethod)), rcvr);
		assert(0);
	}
	return interpretMethodFromMachineCode();
}
/*	<Integer> */
/* CoInterpreter>>#iframeIsBlockActivation: */
static sqInt NoDbgRegParms
iframeIsBlockActivation(char *theFP)
{
	return (byteAt((theFP + FoxIFrameFlags) + 3)) != 0;
}
/* CoInterpreter>>#iframeReceiver: */
static sqInt NoDbgRegParms
iframeReceiver(char *theFP)
{
	return unsignedLongAt(theFP + FoxIFReceiver);
}
/* CoInterpreter>>#iframeSavedIP: */
static sqInt NoDbgRegParms
iframeSavedIP(char *theFP)
{
	return unsignedLongAt(theFP + FoxIFSavedIP);
}
/*	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 = (256 * BytesPerWord) + ((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 sqInt
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) {
		int t18;

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

			executeQuickPrimitive();
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), 0);
			/* end returnToExecutive: */
			goto l3;
		}
		/* 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) {
			int t0;
			int t1;

			if (((freeStart()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart())) != (freeStart()))) {
				/* 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 l2;
		l2:
		;
		/* end slowPrimitiveResponse */
		if (succeeded) {
			sqInt t1;

			/* begin returnToExecutive: */
			returntoExecutive(popStack(), 0);
			/* end returnToExecutive: */
			goto l3;
		}
	}
	{
		activateNewMethod();
		siglongjmp(reenterInterpreter, ReturnToInterpreter);
		return null;
	}
	l3:
	;
	/* end executePrimitiveFromInterpreter:ifFail: */
	return 0;
}
/* 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.self printFrame: stackPage headFP WithSP: stackPage headSPself printStringOf: selector */
/* CoInterpreter>>#lookupMNU:receiver: */
sqInt
lookupMNUreceiver(sqInt selector, sqInt rcvr)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt classTag;
	sqInt erridx;
	sqInt inCache;
	sqInt tagBits;

	if (((tagBits = rcvr & (tagMask()))) != 0) {
		classTag = tagBits;
	} else {
		/* begin classIndexOf: */
		classTag = (longAt(rcvr)) & (classIndexMask());
		/* end classIndexOf: */
	}
	inCache = lookupInMethodCacheSelclassTag(selector, classTag);
	if (!inCache) {
		GIV(messageSelector) = selector;
		erridx = lookupMNUInClass(classAtIndex(classTag));
		if (erridx != 0) {
			assert(erridx <= (maxLookupNoMNUErrorCode()));
			return erridx;
		}
	}
	return GIV(newMethod);
}
/*	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.self printFrame: stackPage headFP WithSP: stackPage headSPself printStringOf: selector */
/* CoInterpreter>>#lookupOrdinary:receiver: */
sqInt
lookupOrdinaryreceiver(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;
		if (((erridx = lookupOrdinaryNoMNUEtcInClass(classAtIndex(classTag)))) != 0) {
			assert(erridx <= (maxLookupNoMNUErrorCode()));
			return erridx;
		}
	}
	return GIV(newMethod);
}
/*	<Integer>Marry aContext with the base frame of a new stack page. Build the base 
	frame to reflect the context's state. Answer the new page. Override to 
	hold the caller context in a different place, In the StackInterpreter we 
	use the caller saved ip, but in the Cog VM caller saved ip is the 
	ceBaseReturn: trampoline. Simply hold the caller context in the first word 
	of the stack. */
/* CoInterpreter>>#makeBaseFrameFor: */
static StackPage * NoDbgRegParms
makeBaseFrameFor(sqInt aContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	CogMethod *cogMethod;
	CogMethod *cogMethod2;
	sqInt header;
	sqInt header2;
	sqInt i;
	StackPage *lruOrFree;
	sqInt maybeClosure;
	sqInt numArgs;
	sqInt objOop;
	sqInt objOop2;
	sqInt oop;
	sqInt oop2;
	StackPage *page;
	char *pointer;
	sqInt rawHeader;
	sqInt rcvr;
	sqInt stackPtrIndex;
	sqInt theIP;
	sqInt theMethod;
	int yetToCompact;

	assert(isContext(aContext));
	assert(isSingleContext(aContext));
	assert(goodContextSize(aContext));
	theIP = unsignedLongAt((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ));
	assert(HasBeenReturnedFromMCPC < 0);
	theIP = ((((theIP & 7) == 1))
		 ? theIP >> 3
		 : HasBeenReturnedFromMCPC);
	/* begin followObjField:ofObject: */
	/* begin fetchPointer:ofObject: */
	objOop = unsignedLongAt((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(isNonImmediate(objOop));
	if (((long64At(objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		objOop = fixFollowedFieldofObjectwithInitialValue(MethodIndex, aContext, objOop);
	}
	theMethod = objOop;
	/* end followObjField:ofObject: */
	/* begin newStackPage */
	lruOrFree = (GIV(mostRecentlyUsedPage)->nextPage);
	if (((lruOrFree->baseFP)) == 0) {
		page = lruOrFree;
		goto l2;
	}
	divorceFramesIn(lruOrFree);
	page = lruOrFree;
	l2:
	;
	/* end newStackPage */
	unsignedLongAtput((pointer = (page->baseAddress)), followObjFieldofObject(SenderIndex, aContext));
	unsignedLongAtput((pointer -= BytesPerWord), aContext);
	/* begin followField:ofObject: */
	/* begin fetchPointer:ofObject: */
	objOop2 = unsignedLongAt((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ReceiverIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	if (((objOop2 & (tagMask())) == 0) && (((long64At(objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
		objOop2 = fixFollowedFieldofObjectwithInitialValue(ReceiverIndex, aContext, objOop2);
	}
	rcvr = objOop2;
	/* end followField:ofObject: */
	maybeClosure = unsignedLongAt((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ClosureIndex ) << (shiftForWord())) ));
	if (maybeClosure != GIV(nilObj)) {
		if (((long64At(maybeClosure)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
			maybeClosure = fixFollowedFieldofObjectwithInitialValue(ClosureIndex, aContext, maybeClosure);
		}
		/* 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: */
		longAtput((pointer -= BytesPerWord), maybeClosure);
	} else {
		/* begin methodHeaderOf: */
		assert(isCompiledMethod(theMethod));
		header2 = unsignedLongAt((theMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		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;
		if ((header & AlternateHeaderHasPrimFlag) && (theIP == (1 + ((((assert(((header & 7) == 1)), (header >> 3) & AlternateHeaderNumLiteralsMask)) + LiteralStart) * BytesPerOop)))) {
			theIP += 3;
		}
		unsignedLongAtput((pointer -= BytesPerWord), rcvr);
	}
	for (i = 1; i <= numArgs; i += 1) {
		unsignedLongAtput((pointer -= BytesPerWord), unsignedLongAt((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) (ReceiverIndex + i) ) << (shiftForWord())) )));
	};
	unsignedLongAtput((pointer -= BytesPerWord), ceBaseFrameReturnPC());
	unsignedLongAtput((pointer -= BytesPerWord), 0);
	(page->headFP = pointer);
	if (theIP < 0) {
		/* begin ensureMethodIsCogged:maybeClosure: */
		/* begin fetchPointer:ofObject: */
		rawHeader = unsignedLongAt((theMethod + 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 l8;
		}
		yetToCompact = 1;
		while (1) {
			if (maybeClosure != GIV(nilObj)) {
				cogMethod2 = cogFullBlockMethodnumCopied(theMethod, (numSlotsOf(maybeClosure)) - FullClosureFirstCopiedValueIndex);
			} else {
				cogMethod2 = cogselector(theMethod, 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;
		l8:
		;
		/* end ensureMethodIsCogged:maybeClosure: */
		theMethod = ((sqInt) cogMethod );
		if (maybeClosure != GIV(nilObj)) {
			assert((((signed) theIP ) >> 16) >= -1);
			theIP = ((theIP == HasBeenReturnedFromMCPC)
				 ? ceCannotResumePC()
				 : ((sqInt) theMethod ) - theIP);
			unsignedLongAtput((pointer -= BytesPerWord), (theMethod + MFMethodFlagHasContextFlag) + MFMethodFlagIsBlockFlag);
		} else {
			assert((((signed) theIP ) >> 16) >= -1);
			theIP = ((theIP == HasBeenReturnedFromMCPC)
				 ? ceCannotResumePC()
				 : ((sqInt) theMethod ) - theIP);
			unsignedLongAtput((pointer -= BytesPerWord), theMethod + MFMethodFlagHasContextFlag);
		}
		unsignedLongAtput((pointer -= BytesPerWord), aContext);
	} else {
		unsignedLongAtput((pointer -= BytesPerWord), theMethod);
		unsignedLongAtput((pointer -= BytesPerWord), aContext);
		unsignedLongAtput((pointer -= BytesPerWord), ((VMBIGENDIAN)
			 ? ((1 + ((sqInt) (((usqInt) numArgs ) << ((BytesPerWord * 8) - 8)) )) + (1ULL << ((BytesPerWord * 8) - 16))) + (((maybeClosure != GIV(nilObj))
				 ? 1ULL << ((BytesPerWord * 8) - 24)
				 : 0))
			 : ((1 + ((sqInt) (((usqInt) numArgs ) << 8) )) + (1U << 16)) + (((maybeClosure != GIV(nilObj))
				 ? 1U << 24
				 : 0))));
		unsignedLongAtput((pointer -= BytesPerWord), 0);
		{
			assert((theIP >= (((LiteralStart + (literalCountOf(theMethod))) * BytesPerOop) + 1)) && (theIP <= (lengthOf(theMethod))));
			theIP = ((theMethod + theIP) + BaseHeaderSize) - 2;
		}
	}
	(page->baseFP = (page->headFP));
	assert(frameHasContext((page->baseFP)));
	assert((frameNumArgs((page->baseFP))) == numArgs);
	unsignedLongAtput((pointer -= BytesPerWord), rcvr);
	/* 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) {
		longAtput((pointer -= BytesPerWord), unsignedLongAt((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) (ReceiverIndex + i) ) << (shiftForWord())) )));
		/* begin storePointerUnchecked:ofObject:withValue: */
		assert(!(isOopForwarded(aContext)));
		longAtput((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) (ReceiverIndex + i) ) << (shiftForWord())) ), GIV(nilObj));
		/* end storePointerUnchecked:ofObject:withValue: */
	};
	unsignedLongAtput((pointer -= BytesPerWord), theIP);
	(page->headSP = pointer);
	assert(contexthasValidInversePCMappingOfin(aContext, theIP, (page->baseFP)));
	/* begin storePointerUnchecked:ofObject:withValue: */
	assert(!(isOopForwarded(aContext)));
	longAtput((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), (assert(((oopForPointer((page->baseFP))) & (BytesPerWord - 1)) == 0), (oopForPointer((page->baseFP))) + (smallIntegerTag())));
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	assert(!(isOopForwarded(aContext)));
	longAtput((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), (assert(((oopForPointer(0)) & (BytesPerWord - 1)) == 0), (oopForPointer(0)) + (smallIntegerTag())));
	/* end storePointerUnchecked:ofObject:withValue: */
	assert((((fetchPointerofObject(SenderIndex, aContext)) & 7) == 1));
	assert((frameOfMarriedContext(aContext)) == ((page->baseFP)));
	assert(validStackPageBaseFrame(page));
	return page;
}
/*	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);
		}
	};
}
/* CoInterpreter>>#mapStackPages */
static void NeverInline
mapStackPages(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *callerFP;
	char *frameRcvrOffset;
	sqInt i;
	int numLivePages;
	sqInt oop;
	char *theFP;
	sqInt theIP;
	char *theIPPtr;
	StackPage *thePage;
	char *theSP;

	theIP = 0;
	numLivePages = 0;
	for (i = 0; i < GIV(numStackPages); i += 1) {
		/* begin stackPageAt: */
		thePage = stackPageAtpages(i, GIV(pages));
		/* end stackPageAt: */
		if (!(((thePage->baseFP)) == 0)) {
			assert(ifCurrentStackPageHasValidHeadPointers(thePage));
			numLivePages += 1;
			theSP = (thePage->headSP);
			theFP = (thePage->headFP);
			if (thePage == GIV(stackPage)) {
				theIPPtr = (((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) ))) || ((unsignedLongAt(theFP + FoxIFSavedIP)) == 0))
					 ? 0
					 : theFP + FoxIFSavedIP);
			} else {
				theIPPtr = theSP;
				theSP += BytesPerWord;
			}
			while (1) {
				assert(addressIsInPage(thePage, theFP));
				assert(addressIsInPage(thePage, theSP));
				assert((theIPPtr == 0) || (addressIsInPage(thePage, theIPPtr)));
				frameRcvrOffset = ((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
					 ? theFP + FoxMFReceiver
					 : theFP + FoxIFReceiver);
				while (theSP <= frameRcvrOffset) {
					oop = unsignedLongAt(theSP);
					if (((oop & (tagMask())) == 0) && (shouldRemapObj(oop))) {
						unsignedLongAtput(theSP, remapObj(oop));
					}
					theSP += BytesPerWord;
				};
				if (((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
					 ? ((unsignedLongAt(theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
					 : (byteAt((theFP + FoxIFrameFlags) + 2)) != 0)) {
					if (shouldRemapObj(unsignedLongAt(theFP + FoxThisContext))) {
						unsignedLongAtput(theFP + FoxThisContext, remapObj(unsignedLongAt(theFP + FoxThisContext)));
					}
					if (!(GIV(gcPhaseInProgress) == SlidingCompactionInProgress)) {
						assert((isMarriedOrWidowedContext(frameContext(theFP))) && ((frameOfMarriedContext(frameContext(theFP))) == theFP));
					}
				}
				if (!(isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))) {
					if (shouldRemapObj(unsignedLongAt(theFP + FoxMethod))) {
						if (theIPPtr != 0) {
							theIP = unsignedLongAt(theIPPtr);
							if (theIP == (ceReturnToInterpreterPC())) {
								assert((iframeSavedIP(theFP)) > (iframeMethod(theFP)));
								theIPPtr = theFP + FoxIFSavedIP;
								theIP = unsignedLongAt(theIPPtr);
							} else {
								assert(theIP > (iframeMethod(theFP)));
							}
							theIP -= unsignedLongAt(theFP + FoxMethod);
						}
						unsignedLongAtput(theFP + FoxMethod, remapObj(unsignedLongAt(theFP + FoxMethod)));
						if (theIPPtr != 0) {
							unsignedLongAtput(theIPPtr, theIP + (unsignedLongAt(theFP + FoxMethod)));
						}
					}
				}
				if (!(((callerFP = pointerForOop(unsignedLongAt(theFP + FoxSavedFP)))) != 0)) 
					break;
				theSP = ((theIPPtr = theFP + FoxCallerSavedIP)) + BytesPerWord;
				theFP = callerFP;
			};
			theSP = (theFP + FoxCallerSavedIP) + BytesPerWord;
			while (theSP <= ((thePage->baseAddress))) {
				oop = unsignedLongAt(theSP);
				if (((oop & (tagMask())) == 0) && (shouldRemapObj(oop))) {
					unsignedLongAtput(theSP, remapObj(oop));
				}
				theSP += BytesPerWord;
			};
		}
	};
	/* begin recordLivePagesOnMapping: */
	GIV(statNumMaps) += 1;
	GIV(statPageCountWhenMappingSum) += numLivePages;
	GIV(statMaxPageCountWhenMapping) = ((GIV(statMaxPageCountWhenMapping) < numLivePages) ? numLivePages : GIV(statMaxPageCountWhenMapping));
	/* end recordLivePagesOnMapping: */
}
/*	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 *thePage;

	for (i = 0; i < GIV(numStackPages); i += 1) {
		/* begin stackPageAt: */
		thePage = stackPageAtpages(i, GIV(pages));
		/* end stackPageAt: */
		if (!(isFree(thePage))) {
			markCogMethodsAndReferentsOnPage(thePage);
		}
	};
}
/*	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);
		}
	};
}
/* CoInterpreter>>#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));
		}
		if (isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) ))) {
			/* begin markAndTraceMachineCodeMethod: */
			aCogMethod = ((CogMethod *) ((unsignedLongAt(theFP + FoxMethod)) & MFMethodMask) );
			markAndTrace((aCogMethod->methodObject));
			/* end markAndTraceMachineCodeMethod: */
		} else {
			markAndTrace(unsignedLongAt(theFP + FoxMethod));
		}
		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;
	};
}
/*	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));
	header = unsignedLongAt((methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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 longAt(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 *page;
	int unused;

	minUnused = (((stackPageAt(0))->baseAddress)) - (((stackPageAt(0))->lastAddress));
	for (i = 0; i < GIV(numStackPages); i += 1) {
		/* begin stackPageAt: */
		page = stackPageAtpages(i, GIV(pages));
		/* end stackPageAt: */
		p = (page->lastAddress);
		do{
			p += BytesPerWord;
		}while(((longAtPointer(p)) == 0) && (p <= ((page->baseAddress))));
		unused = (p - BytesPerWord) - ((page->lastAddress));
		if (unused < minUnused) {
			minUnused = unused;
		}
	};
	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 l9;
			}
			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 l9;
				/* end followField:ofObject: */
			}
			index += 1;
			if (index == length) {
				if (wrapAround) {
					mnuMethod = null;
					goto l9;
				}
				wrapAround = 1;
				index = SelectorStart;
			}
		};
		mnuMethod = null;
		l9:
		;
		/* end lookupMethodFor:InDictionary: */
		if ((mnuMethod != null) && ((!(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;
}
/*	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. */
/* CoInterpreter>>#moveFramesIn:through:toPage: */
static char * NoDbgRegParms
moveFramesInthroughtoPage(StackPage *oldPage, char *theFP, StackPage *newPage)
{
	char *callerFP;
	usqInt callerIP;
	int delta;
	char *fpInNewPage;
	char *newFP;
	char *newSP;
	sqInt numArgs;
	char *offsetCallerFP;
	char *source;
	sqInt stackedReceiverOffset;
	sqInt theContext;
	char *theFP1;
	char *theSP;

	assert(!(isBaseFrame(theFP)));
	assert(validStackPageBaseFrames());
	callerFP = pointerForOop(unsignedLongAt(theFP + FoxSavedFP));
	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 l4;
	}
	theContext = marryFrameSP(theFP, theSP);
	l4:
	;
	/* end ensureFrameIsMarried:SP: */
	{
		unsignedLongAtput((newSP = (newPage->baseAddress)), unsignedLongAt(callerFP + FoxThisContext));
		unsignedLongAtput((newSP -= BytesPerWord), theContext);
	}
	/* 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: */
	for (source = theFP + stackedReceiverOffset; source >= ((oldPage->headSP)); source += -BytesPerWord) {
		newSP -= BytesPerWord;
		longAtput(newSP, longAt(source));
	};
	delta = newSP - ((oldPage->headSP));
	newFP = (((newPage->baseAddress)) - stackedReceiverOffset) - (2 * BytesPerWord);
	/* begin setHeadFP:andSP:inPage: */
	theFP1 = ((oldPage->headFP)) + delta;
	assert(newSP < theFP1);
	assert((newSP < ((newPage->baseAddress))) && (newSP > (((newPage->realStackLimit)) - (LargeContextSlots * BytesPerOop))));
	assert((theFP1 < ((newPage->baseAddress))) && (theFP1 > (((newPage->realStackLimit)) - ((LargeContextSlots * BytesPerOop) / 2))));
	{
		(newPage->headFP = theFP1);
		(newPage->headSP = newSP);
	}
	/* end setHeadFP:andSP:inPage: */
	(newPage->baseFP = newFP);
	callerIP = oopForPointer(pointerForOop(unsignedLongAt(theFP + FoxCallerSavedIP)));
	if (((usqInt) callerIP ) >= (startOfObjectMemory(getMemoryMap()))) {
		/* begin iframeSavedIP:put: */
		assert(!(isMachineCodeFrame(callerFP)));
		unsignedLongAtput(callerFP + FoxIFSavedIP, callerIP);
		/* end iframeSavedIP:put: */
		callerIP = ceReturnToInterpreterPC();
	}
	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{
		offsetCallerFP = pointerForOop(unsignedLongAt(fpInNewPage + FoxSavedFP));
		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)) {
			theContext = unsignedLongAt(fpInNewPage + FoxThisContext);
			/* begin storePointerUnchecked:ofObject:withValue: */
			assert(!(isOopForwarded(theContext)));
			longAtput((theContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), (assert(((oopForPointer(fpInNewPage)) & (BytesPerWord - 1)) == 0), (oopForPointer(fpInNewPage)) + (smallIntegerTag())));
			/* end storePointerUnchecked:ofObject:withValue: */
			/* begin storePointerUnchecked:ofObject:withValue: */
			assert(!(isOopForwarded(theContext)));
			longAtput((theContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), (assert(((oopForPointer(offsetCallerFP)) & (BytesPerWord - 1)) == 0), (oopForPointer(offsetCallerFP)) + (smallIntegerTag())));
			/* end storePointerUnchecked:ofObject:withValue: */
		}
		fpInNewPage = offsetCallerFP;
	}while(fpInNewPage != 0);
	assert(validStackPageBaseFrames());
	return newFP;
}
/*	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 l3;
	}
	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;
	l3:
	;
	/* 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 l1;
	}
	assert((mcpc >= ((sqInt) cogMethod )) && (mcpc <= (((sqInt) cogMethod ) + ((cogMethod->blockSize)))));
	bcpc = bytecodePCForstartBcpcin(mcpc, startBcpc, cogMethod);
	l1:
	;
	/* 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) );
}
/*	Answer if classTag x messageSelector => newMethod is in the lookup cache. 
	This is for assert checking to check that open PICs find entries. */
/* CoInterpreter>>#newMethodInLookupCacheAt:and: */
static sqInt NoDbgRegParms
newMethodInLookupCacheAtand(sqInt selector, sqInt classTag)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt hash;
	sqInt p;
	sqInt probe;

	hash = selector ^ ((sqInt) (((usqInt) classTag ) << 2) );
	for (p = 0; p < CacheProbeMax; p += 1) {
		probe = (((usqInt) hash ) >> p) & MethodCacheMask;
		if (((GIV(methodCache)[probe + MethodCacheSelector]) == selector) && (((GIV(methodCache)[probe + MethodCacheClass]) == classTag) && ((GIV(methodCache)[probe + MethodCacheMethod]) == GIV(newMethod)))) {
			return 1;
		}
	};
	return 0;
}
/*	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 anArray1;
	sqInt anArray2;
	sqInt anArray3;
	sqInt anObj;
	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 iLimiT1;
	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 permObj;
	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 l16;
				}
				assert(!(isForwarded(schedAssoc)));
				followForwardedObjectFieldstoDepth(schedAssoc, 1);
				if (schedAssoc == GIV(nilObj)) {
					goto l16;
				}
				/* 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;
					};
				};
				l16:
				;
				/* 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)))) {
						int t0;
						int t1;

						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 l39;
					}
					if (obj2 & (tagMask())) {
						goto l39;
					}
					if (!(anArray >= 0x20000000000LL)) {
						goto l39;
					}
					if (obj2 >= 0x20000000000LL) {
						goto l39;
					}
					if ((obj2 >= GIV(nilObj)) && (obj2 <= GIV(trueObj))) {
						goto l39;
					}
					if (!(obj2 >= (startOfObjectMemory(GIV(memoryMap))))) {
						goto l39;
					}
					remember(getFromPermToNewSpaceRememberedSet(), anArray);
					l39:
					;
					/* end possiblePermObjectStoreInto:value: */
					unsignedLongAtput((anArray + BaseHeaderSize) + ((sqInt) (((usqInt) TheLowSpaceSemaphore ) << (shiftForWord())) ), obj2);
					/* end storePointer:ofObject:withValue: */
				}
				/* end followSemaphoreIn:at: */
				/* begin followSemaphoreIn:at: */
				anArray1 = GIV(specialObjectsOop);
				/* begin fetchPointer:ofObject: */
				obj3 = unsignedLongAt((anArray1 + 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(anArray1)));
					if (((anArray1 & (tagMask())) == 0) && ((anArray1 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
						int t0;
						int t1;

						if (((obj3 & (tagMask())) == 0) && (((obj3 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (obj3 >= ((GIV(memoryMap)->newSpaceStart))))) {
							/* begin possibleOldObjectStoreInto: */
							if (!(((((usqInt) (long64At(anArray1)) ) >> (rememberedBitShift())) & 1) != 0)) {
								remember(GIV(fromOldSpaceRememberedSet), anArray1);
							}
							/* end possibleOldObjectStoreInto: */
						}
					}
					/* begin possiblePermObjectStoreInto:value: */
					if (((((usqInt) (long64At(anArray1)) ) >> (rememberedBitShift())) & 1) != 0) {
						goto l58;
					}
					if (obj3 & (tagMask())) {
						goto l58;
					}
					if (!(anArray1 >= 0x20000000000LL)) {
						goto l58;
					}
					if (obj3 >= 0x20000000000LL) {
						goto l58;
					}
					if ((obj3 >= GIV(nilObj)) && (obj3 <= GIV(trueObj))) {
						goto l58;
					}
					if (!(obj3 >= (startOfObjectMemory(GIV(memoryMap))))) {
						goto l58;
					}
					remember(getFromPermToNewSpaceRememberedSet(), anArray1);
					l58:
					;
					/* end possiblePermObjectStoreInto:value: */
					unsignedLongAtput((anArray1 + BaseHeaderSize) + ((sqInt) (((usqInt) TheInterruptSemaphore ) << (shiftForWord())) ), obj3);
					/* end storePointer:ofObject:withValue: */
				}
				/* end followSemaphoreIn:at: */
				/* begin followSemaphoreIn:at: */
				anArray2 = GIV(specialObjectsOop);
				/* begin fetchPointer:ofObject: */
				obj4 = unsignedLongAt((anArray2 + 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(anArray2)));
					if (((anArray2 & (tagMask())) == 0) && ((anArray2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
						int t0;
						int t1;

						if (((obj4 & (tagMask())) == 0) && (((obj4 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (obj4 >= ((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 l27;
					}
					if (obj4 & (tagMask())) {
						goto l27;
					}
					if (!(anArray2 >= 0x20000000000LL)) {
						goto l27;
					}
					if (obj4 >= 0x20000000000LL) {
						goto l27;
					}
					if ((obj4 >= GIV(nilObj)) && (obj4 <= GIV(trueObj))) {
						goto l27;
					}
					if (!(obj4 >= (startOfObjectMemory(GIV(memoryMap))))) {
						goto l27;
					}
					remember(getFromPermToNewSpaceRememberedSet(), anArray2);
					l27:
					;
					/* end possiblePermObjectStoreInto:value: */
					unsignedLongAtput((anArray2 + BaseHeaderSize) + ((sqInt) (((usqInt) TheTimerSemaphore ) << (shiftForWord())) ), obj4);
					/* end storePointer:ofObject:withValue: */
				}
				/* end followSemaphoreIn:at: */
				/* begin followSemaphoreIn:at: */
				anArray3 = GIV(specialObjectsOop);
				/* begin fetchPointer:ofObject: */
				obj5 = unsignedLongAt((anArray3 + 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(anArray3)));
					if (((anArray3 & (tagMask())) == 0) && ((anArray3 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
						int t0;
						int t1;

						if (((obj5 & (tagMask())) == 0) && (((obj5 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (obj5 >= ((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 l33;
					}
					if (obj5 & (tagMask())) {
						goto l33;
					}
					if (!(anArray3 >= 0x20000000000LL)) {
						goto l33;
					}
					if (obj5 >= 0x20000000000LL) {
						goto l33;
					}
					if ((obj5 >= GIV(nilObj)) && (obj5 <= GIV(trueObj))) {
						goto l33;
					}
					if (!(obj5 >= (startOfObjectMemory(GIV(memoryMap))))) {
						goto l33;
					}
					remember(getFromPermToNewSpaceRememberedSet(), anArray3);
					l33:
					;
					/* end possiblePermObjectStoreInto:value: */
					unsignedLongAtput((anArray3 + 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)))) {
						int t0;
						int t1;

						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 l59;
					}
					if (xArray & (tagMask())) {
						goto l59;
					}
					if (!(GIV(specialObjectsOop) >= 0x20000000000LL)) {
						goto l59;
					}
					if (xArray >= 0x20000000000LL) {
						goto l59;
					}
					if ((xArray >= GIV(nilObj)) && (xArray <= GIV(trueObj))) {
						goto l59;
					}
					if (!(xArray >= (startOfObjectMemory(GIV(memoryMap))))) {
						goto l59;
					}
					remember(getFromPermToNewSpaceRememberedSet(), GIV(specialObjectsOop));
					l59:
					;
					/* end possiblePermObjectStoreInto:value: */
					unsignedLongAtput((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ExternalObjectsArray ) << (shiftForWord())) ), xArray);
					/* end storePointer:ofObject:withValue: */
					/* end splObj:put: */
				}
				for (i4 = 0, iLimiT1 = (numSlotsOf(xArray)) - 1; i4 <= iLimiT1; 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)))) {
							int t0;
							int t1;

							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 l41;
						}
						if (obj & (tagMask())) {
							goto l41;
						}
						if (!(xArray >= 0x20000000000LL)) {
							goto l41;
						}
						if (obj >= 0x20000000000LL) {
							goto l41;
						}
						if ((obj >= GIV(nilObj)) && (obj <= GIV(trueObj))) {
							goto l41;
						}
						if (!(obj >= (startOfObjectMemory(GIV(memoryMap))))) {
							goto l41;
						}
						remember(getFromPermToNewSpaceRememberedSet(), xArray);
						l41:
						;
						/* 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 l62;
					}
					flag("endianness");
					followingWord = unsignedLongAt(followingWordAddress);
					currentObject = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
						 ? followingWordAddress + BaseHeaderSize
						 : followingWordAddress);
					l62:
					;
					/* 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 */
			{
				sqInt i;

				for (i = 1; i <= MethodCacheSize; i += 1) {
					GIV(methodCache)[i] = 0;
				};
				GIV(lastMethodCacheProbeWrite) = 0;
			}
			unlinkAllSends();
			/* 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>>#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 */
}
/* CoInterpreter>>#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 */
	}
}
/* 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;
	usqInt index;
	sqInt methodField;
	usqInt numArgs;
	sqInt numTemps;
	char *rcvrAddress;
	sqInt rcvrOrClosure;
	sqInt theMethod;
	sqInt 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);
		/* begin iframeNumArgs: */
		numArgs = byteAt((theFP + FoxIFrameFlags) + 1);
		/* end iframeNumArgs: */
		/* begin temporaryCountOfMethodHeader: */
		/* begin methodHeaderOf: */
		assert(isCompiledMethod(theMethod));
		header2 = unsignedLongAt((theMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		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: */
	}
	if (((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
		 ? ((unsignedLongAt(theFP + FoxMethod)) & MFMethodFlagIsBlockFlag) != 0
		 : (byteAt((theFP + FoxIFrameFlags) + 3)) != 0)) {
		rcvrOrClosure = unsignedLongAt(theFP + (frameStackedReceiverOffset(theFP)));
		if (((rcvrOrClosure & (tagMask())) == 0) && ((addressCouldBeObj(rcvrOrClosure)) && ((fetchClassOfNonImm(rcvrOrClosure)) == (unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassBlockClosure ) << (shiftForWord())) )))))) {
			numTemps = numArgs + (stSizeOf(rcvrOrClosure));
		} else {
			numTemps = numArgs;
		}
	}
	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);
	if (isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) ))) {
		printFrameFlagsForFP(theFP);
	}
	printFrameOopat("context", theFP + FoxThisContext);
	if (!(isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))) {
		printFrameFlagsForFP(theFP);
	}
	if (isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) ))) {
		rcvrAddress = theFP + FoxMFReceiver;
	} else {
		printFrameThingatextra("saved ip", theFP + FoxIFSavedIP, (((unsignedLongAt(theFP + FoxIFSavedIP)) == 0)
			 ? 0
			 : (((unsignedLongAt(theFP + FoxIFSavedIP)) - theMethod) + 2) - BaseHeaderSize));
		rcvrAddress = theFP + FoxIFReceiver;
	}
	printFrameOopat("receiver", rcvrAddress);
	topThing = longAt(theSP);
	if (oopisGreaterThanOrEqualToandLessThan(topThing, theMethod, theMethodEnd)) {
		for (addr = rcvrAddress - BytesPerWord; addr >= (theSP + BytesPerWord); addr += -BytesPerWord) {
			index = ((rcvrAddress - addr) / BytesPerWord) + numArgs;
			if (index <= numTemps) {
				printFrameOopindexat("temp", index - 1, addr);
			} else {
				printFrameOopat(((((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
					 ? ((unsignedLongAt(theFP + FoxMethod)) & MFMethodFlagIsBlockFlag) != 0
					 : (byteAt((theFP + FoxIFrameFlags) + 3)) != 0))
					 ? "temp/stck"
					 : "stck"), addr);
			}
		};
		printFrameThingatextra("frame ip", theSP, ((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
			 ? topThing - theMethod
			 : ((topThing - theMethod) + 2) - BaseHeaderSize));
	} else {
		for (addr = rcvrAddress - BytesPerWord; addr >= theSP; addr += -BytesPerWord) {
			index = ((rcvrAddress - addr) / BytesPerWord) + numArgs;
			if (index <= numTemps) {
				printFrameOopindexat("temp", index - 1, addr);
			} else {
				printFrameOopat(((((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
					 ? ((unsignedLongAt(theFP + FoxMethod)) & MFMethodFlagIsBlockFlag) != 0
					 : (byteAt((theFP + FoxIFrameFlags) + 3)) != 0))
					 ? "temp/stck"
					 : "stck"), addr);
			}
		};
	}
	return 0;
}
/* CoInterpreter>>#printLogEntryAt: */
static void NoDbgRegParms
printLogEntryAt(sqInt i)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt intOrClass;
	sqInt selectorMethodOrProcess;
	sqInt source;
	char * traceSources[] = {
		"?", "m", "i", "callbackEnter", "callbackLeave", "enterCritical", "exitCritical",
		"resume", "signal", "suspend", "wait", "yield", "eventcheck"
	};

	intOrClass = GIV(traceLog)[i];
	selectorMethodOrProcess = GIV(traceLog)[i + 1];
	source = GIV(traceLog)[i + 2];
	if (source <= TraceIsFromInterpreter) {
		{
			print(GIV(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(GIV(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 l4;
			l4:
			;
			/* 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;
}
/* CoInterpreter>>#rawHeaderOf: */
sqInt
rawHeaderOf(sqInt methodPointer)
{
	return unsignedLongAt((methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
}
/*	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)
{
	vm_printf("stack page bytes %lld available headroom %lld minimum unused headroom %lld\n", ((unsigned long long) (stackPageByteSize()) ), ((unsigned long long) (((stackPageByteSize()) - ((((256 * BytesPerWord) < (((stackPageByteSize()) - ((IFrameSlots + 64) * BytesPerWord)) - (osCogStackPageHeadroom()))) ? 256 * BytesPerWord : ((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((((usqInt) GIV(instructionPointer) ) > (minCogMethodAddress())) && (((usqInt) GIV(instructionPointer) ) < (maxCogMethodAddress())));
			if ((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 = longAt(GIV(framePointer) + FoxMFReceiver);
				/* end mframeReceiver: */
			}
		} else {
			/* begin mframeReceiver: */
			retValue = longAt(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: */
	}
	/* begin setMethod: */
	aMethodObj = unsignedLongAt(GIV(framePointer) + FoxMethod);
	assert(((usqInt) aMethodObj ) >= (startOfObjectMemory(getMemoryMap())));
	{
		GIV(method) = aMethodObj;
		assert(isOopCompiledMethod(GIV(method)));
	}
	/* end setMethod: */
	fullyInInterpreter = inInterpreter;
	if (GIV(instructionPointer) == (ceReturnToInterpreterPC())) {
		GIV(instructionPointer) = ((usqInt) (unsignedLongAt(GIV(framePointer) + FoxIFSavedIP)) );
		fullyInInterpreter = 0;
	}
	assertValidExecutionPointersimbarline(GIV(instructionPointer), GIV(framePointer), GIV(stackPointer), 1, __LINE__);
	if (!fullyInInterpreter) {
		siglongjmp(reenterInterpreter, ReturnToInterpreter);
	}
	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: */
	}
	/* 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 (GIV(instructionPointer) == (ceReturnToInterpreterPC())) {
		/* begin iframeSavedIP: */
		GIV(instructionPointer) = unsignedLongAt(GIV(framePointer) + FoxIFSavedIP);
		/* end iframeSavedIP: */
	}
	if (inInterpreter) {
		return null;
	}
	siglongjmp(reenterInterpreter, ReturnToInterpreter);
	return 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>>#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)) )))
		 ? longAt(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)) )))
		 ? (/* begin mtemporary:in: */ ((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))) /* end mtemporary:in: */)
		 : (/* begin itemporary:in: */ ((0 < ((frameNumArgs2 = byteAt((theFP + FoxIFrameFlags) + 1))))
			 ? unsignedLongAt((theFP + FoxCallerSavedIP) + (frameNumArgs2 * BytesPerWord))
			 : unsignedLongAt(((theFP + FoxIFReceiver) - BytesPerWord) + (frameNumArgs2 * BytesPerWord))) /* end itemporary:in: */)));
	/* begin space */
	printChar(' ');
	/* end space */
	shortPrintOop(rcvr);
	return 0;
}
/* CoInterpreter>>#stackLimitAddress */
usqInt
stackLimitAddress(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return (usqInt)&GIV(stackLimit);
}
/*	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) 
	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:  */
/* CoInterpreter>>#stackLimitOffset */
static sqInt
stackLimitOffset(void)
{
	return (IFrameSlots + 64) * BytesPerWord;
}
/*	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)))) {
			int t0;
			int t1;

			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 l1;
		}
		if (contextToReturnTo & (tagMask())) {
			goto l1;
		}
		if (!(contextToReturnFrom >= 0x20000000000LL)) {
			goto l1;
		}
		if (contextToReturnTo >= 0x20000000000LL) {
			goto l1;
		}
		if ((contextToReturnTo >= GIV(nilObj)) && (contextToReturnTo <= GIV(trueObj))) {
			goto l1;
		}
		if (!(contextToReturnTo >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l1;
		}
		remember(getFromPermToNewSpaceRememberedSet(), contextToReturnFrom);
		l1:
		;
		/* 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)))) {
			int t0;
			int t1;

			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 l3;
		}
		if (HasBeenReturnedFromMCPCOop & (tagMask())) {
			goto l3;
		}
		if (!(contextToReturnFrom >= 0x20000000000LL)) {
			goto l3;
		}
		{
			goto l3;
		}
		if ((HasBeenReturnedFromMCPCOop >= GIV(nilObj)) && (HasBeenReturnedFromMCPCOop <= GIV(trueObj))) {
			goto l3;
		}
		if (!(HasBeenReturnedFromMCPCOop >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l3;
		}
		remember(getFromPermToNewSpaceRememberedSet(), contextToReturnFrom);
		l3:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((contextToReturnFrom + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), HasBeenReturnedFromMCPCOop);
		/* end storePointer:ofObject:withValue: */
	}
	GIV(instructionPointer) = 0;
	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 *thePage;

	for (i = 0; i < GIV(numStackPages); i += 1) {
		/* begin stackPageAt: */
		thePage = stackPageAtpages(i, GIV(pages));
		/* end stackPageAt: */
		if (!(isFree(thePage))) {
			theIPPtr = (thePage->headSP);
			theFP = (thePage->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;
			};
		}
	};
}
/*	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;
		header = unsignedLongAt((aMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		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;
}
/*	Check that the base frame in the stack page has a valid sender and saved 
	context.  */
/* CoInterpreter>>#validStackPageBaseFrame: */
static sqInt NoDbgRegParms
validStackPageBaseFrame(StackPage *aPage)
{
	sqInt savedThisContext;
	sqInt senderContextOrNil;

	senderContextOrNil = unsignedLongAt((aPage->baseAddress));
	savedThisContext = unsignedLongAt(((aPage->baseAddress)) - BytesPerWord);
	if (!(asserta(((((aPage->baseFP)) + (frameStackedReceiverOffset((aPage->baseFP)))) + (2 * BytesPerWord)) == ((aPage->baseAddress))))) {
		return 0;
	}
	if (!(asserta(addressCouldBeObj(senderContextOrNil)))) {
		return 0;
	}
	if (!(asserta(addressCouldBeObj(savedThisContext)))) {
		return 0;
	}
	if (!(asserta((senderContextOrNil == (nilObject())) || (isContext(senderContextOrNil))))) {
		return 0;
	}
	if (!(asserta(isContext(savedThisContext)))) {
		return 0;
	}
	if (!(asserta((frameCallerContext((aPage->baseFP))) == senderContextOrNil))) {
		return 0;
	}
	if (!(asserta((frameContext((aPage->baseFP))) == savedThisContext))) {
		return 0;
	}
	return 1;
}
/* 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 activeContext1;
	sqInt address;
	sqInt address1;
	sqInt currentObject;
	sqInt fmt;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	sqInt prevObj;
	sqInt prevObj2;
	sqInt prevPrevObj;
	sqInt prevPrevObj2;

	GIV(instructionPointer) = 0;
	{
		activeContext1 = 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 l1;
			}
			flag("endianness");
			followingWord = unsignedLongAt(followingWordAddress);
			objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress + BaseHeaderSize
				 : followingWordAddress);
			l1:
			;
			/* end objectAfter:limit: */
		};
		/* begin objectStartingAt: */
		address1 = ((eden()).start);
		numSlots2 = byteAt(address1 + 7);
		objOop2 = ((numSlots2 == (numSlotsMask()))
			 ? address1 + BaseHeaderSize
			 : address1);
		/* 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 l2;
			}
			flag("endianness");
			followingWord2 = unsignedLongAt(followingWordAddress2);
			objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress2 + BaseHeaderSize
				 : followingWordAddress2);
			l2:
			;
			/* 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: */
			limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			followingWordAddress4 = addressAfter(objOop22);
			if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
				objOop22 = limit1;
				goto l6;
			}
			flag("endianness");
			followingWord4 = unsignedLongAt(followingWordAddress4);
			objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress4 + BaseHeaderSize
				 : followingWordAddress4);
			l6:
			;
			/* 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 l5;
			}
			flag("endianness");
			followingWord3 = unsignedLongAt(followingWordAddress3);
			currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress3 + BaseHeaderSize
				 : followingWordAddress3);
			l5:
			;
			/* end objectAfter:limit: */
		};
		/* end allPermSpaceObjectsDo: */
		/* end allObjectsDo: */
		/* end bereaveAllMarriedContextsForSnapshotFlushingExternalPrimitivesIf: */
		activeContext = activeContext1;
	}
	voidCogCompiledCode();
	return activeContext;
}
/* CoInterpreter>>#whereIs: */
char *
whereIs(sqInt anOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *somewhere;
	char *where;

	{
		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 l2;
				}
				if (oopisGreaterThanOrEqualToandLessThan(anOop, ((futureSpace()).start), futureSurvivorStart())) {
					where = " is in future space";
					goto l2;
				}
				if (oopisGreaterThanOrEqualToandLessThan(anOop, ((pastSpace()).start), GIV(pastSpaceStart))) {
					where = " is in past space";
					goto l2;
				}
				where = " is in new space";
				goto l2;
			}
			if (oopisGreaterThanOrEqualToandLessThan(anOop, (GIV(memoryMap)->oldSpaceStart), (GIV(memoryMap)->oldSpaceEnd))) {
				if (segmentContainingObj(anOop)) {
					where = " is in old space";
					goto l2;
				}
				where = " is between old space segments";
				goto l2;
			}
			if (oopisGreaterThanOrEqualToandLessThan(anOop, (GIV(memoryMap)->permSpaceStart), (GIV(memoryMap)->permSpaceEnd))) {
				where = " is in permanent space";
				goto l2;
			}
			where = null;
			l2:
			;
			/* end whereIsMaybeHeapThing: */
			if (!(where == null)) {
				return where;
			}
		}
		{
			/* begin whereIsMaybeStackThing: */
			if (oopisGreaterThanOrEqualToandLessThan(anOop, GIV(stackBasePlus1) - 1, GIV(pages))) {
				where = " is in the stack zone";
				goto l1;
			}
			where = null;
			l1:
			;
			/* 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);
	}
}
/* CoInterpreterPrimitives>>#frameIsMarked: */
static sqInt NoDbgRegParms
frameIsMarked(sqInt theFPInt)
{
	sqInt methodField;

	methodField = longAt(theFPInt + FoxMethod);
	return ((((usqInt) methodField ) < (startOfObjectMemory(getMemoryMap())))
		 ? (methodField & 4) != 0
		 : ((longAt(theFPInt + FoxIFrameFlags)) & 2) != 0);
}
/*	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 l2;
		}
		/* begin isClassOfNonImm:equalTo:compactClassIndex: */
		assert(!(isImmediate(receiverArg)));
		/* begin classIndexOf: */
		ccIndex = (longAt(receiverArg)) & (classIndexMask());
		/* end classIndexOf: */
		{
			ok = ClassLargePositiveIntegerCompactIndex == ccIndex;
			goto l2;
		}
		/* end isClassOfNonImm:equalTo:compactClassIndex: */
		l2:
		;
		/* 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;
	};
	if ((selector == (fetchPointerofObject(16 * 2, splObj(SpecialSelectors)))) || (selector == (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 classObj1;
	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 l2;
		}
		nEntries = mapPCDataForinto(cogMethod, data2);
		if (nEntries == 0) {
			data = 0;
			goto l2;
		}
		if (nEntries < nSlots) {
			shortentoIndexableSize(data2, nEntries);
		}
		data = data2;
		l2:
		;
		/* end pcDataFor: */
		if (data == -1) {
			return (GIV(primFailCode) = PrimErrNoMemory);
		}
	}
	if (data == 0) {
		/* begin instantiateClass:indexableSize: */
		classObj1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ));
		data = instantiateClassindexableSizeisPinnedisOldSpace(classObj1, 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 classObj1;
	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: */
		classObj1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ));
		data2 = instantiateClassindexableSizeisPinnedisOldSpace(classObj1, nSlots, 0, 0);
		/* end instantiateClass:indexableSize: */
		if (!data2) {
			data = -1;
			goto l3;
		}
		nEntries = profilingDataForinto(cogMethod, data2);
		if (nEntries == 0) {
			data = 0;
			goto l3;
		}
		if (nEntries < nSlots) {
			shortentoIndexableSize(data2, nEntries);
		}
		data = data2;
		l3:
		;
		/* 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 l1;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		index = 0;
		goto l1;
	}
	/* end checkedIntegerValueOf: */
	l1:
	;
	/* end stackIntegerValue: */
	if (GIV(primFailCode)) {
		GIV(primFailCode) = PrimErrBadArgument;
		return;
	}
	thisReceiver = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	rawHeader = unsignedLongAt((thisReceiver + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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;
	}
	rawHeader = unsignedLongAt((thisReceiver + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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)) {
			((((CogMethod *) rawHeader ))->methodHeader = 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)))) {
			int t0;
			int t1;

			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 l2;
		}
		if (newValue & (tagMask())) {
			goto l2;
		}
		if (!(thisReceiver >= 0x20000000000LL)) {
			goto l2;
		}
		if (newValue >= 0x20000000000LL) {
			goto l2;
		}
		if ((newValue >= GIV(nilObj)) && (newValue <= GIV(trueObj))) {
			goto l2;
		}
		if (!(newValue >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l2;
		}
		remember(getFromPermToNewSpaceRememberedSet(), thisReceiver);
		l2:
		;
		/* 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;
	CogMethod *cogMethod;
	CogMethod *cogMethod2;
	CogMethod *cogMethod3;
	SpurImageHeaderStruct header;
	SpurImageHeaderStruct header2;
	sqInt i;
	sqInt i2;
	sqInt i3;
	extern char imageName[];
	usqInt initialIP;
	usqInt initialIP2;
	usqInt initialIP3;
	sqInt integerPointer;
	sqInt methodHeader;
	sqInt methodHeader2;
	sqInt methodHeader3;
	sqInt newFormatToUse;
	sqInt numArgs;
	sqInt numArgs2;
	sqInt numArgs3;
	sqInt numTemps;
	sqInt numTemps2;
	sqInt numTemps3;
	sqInt object;
	sqInt object1;
	sqInt object11;
	sqInt object12;
	sqInt object2;
	sqInt object3;
	sqInt object4;
	sqInt objOop;
	sqInt objOop1;
	sqInt oop;
	sqInt rcvr;
	sqInt rcvr2;
	sqInt rcvr3;
	sqInt rcvr4;
	sqInt savedTenuringThreshold;
	sqInt shouldSkipStoreBytecode;
	sqInt shouldSkipStoreBytecode2;
	sqInt shouldSkipStoreBytecode3;
	size_t sizeToWrite;
	char *sp;
	char *sp10;
	char *sp102;
	char *sp103;
	char *sp11;
	char *sp12;
	char *sp13;
	char *sp2;
	char *sp22;
	char *sp23;
	char *sp24;
	char *sp3;
	char *sp32;
	char *sp33;
	char *sp34;
	char *sp4;
	char *sp42;
	char *sp43;
	char *sp44;
	char *sp5;
	char *sp52;
	char *sp53;
	char *sp6;
	char *sp62;
	char *sp63;
	char *sp7;
	char *sp72;
	char *sp73;
	char *sp8;
	char *sp82;
	char *sp83;
	char *sp9;
	char *sp92;
	char *sp93;
	sqInt stackIndex;
	int stackModified;
	CogMethod * theCogMethod;
	CogMethod * theCogMethod2;
	CogMethod * theCogMethod3;
	sqInt threshold;
	sqInt valuePointer;

	cogMethod = ((CogMethod *) 0 );
	cogMethod2 = ((CogMethod *) 0 );
	cogMethod3 = ((CogMethod *) 0 );
	newFormatToUse = 0;
	rcvr = 0;
	/* begin snapshot */
	if (GIV(argumentCount) > 1) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadNumArgs;
		/* end primitiveFailFor: */
		/* begin justActivateNewMethod: */
		/* 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)) {
			theCogMethod = ((CogMethod *) methodHeader );
			methodHeader = (theCogMethod->methodHeader);
			{
				cogMethod = theCogMethod;
			}
		}
		numTemps = (((usqInt) methodHeader ) >> MethodHeaderTempCountShift) & 0x3F;
		numArgs = (((usqInt) methodHeader ) >> MethodHeaderArgCountShift) & 15;
		rcvr2 = unsignedLongAt(GIV(stackPointer) + (numArgs * BytesPerWord));
		assert(!(isOopForwarded(rcvr2)));
		if ((cogMethod != null) && (!(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap()))))) {
			/* begin iframeSavedIP:put: */
			assert(!(isMachineCodeFrame(GIV(framePointer))));
			unsignedLongAtput(GIV(framePointer) + FoxIFSavedIP, GIV(instructionPointer));
			/* end iframeSavedIP:put: */
			GIV(instructionPointer) = ceReturnToInterpreterPC();
		}
		/* begin push: */
		unsignedLongAtput((sp8 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
		GIV(stackPointer) = sp8;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((sp9 = GIV(stackPointer) - BytesPerWord), GIV(framePointer));
		GIV(stackPointer) = sp9;
		/* end push: */
		GIV(framePointer) = GIV(stackPointer);
		if (cogMethod == null) {
			initialIP = (GIV(newMethod) + ((LiteralStart + ((assert(((methodHeader & 7) == 1)), (methodHeader >> 3) & AlternateHeaderNumLiteralsMask))) * BytesPerOop)) + BaseHeaderSize;
			/* begin push: */
			unsignedLongAtput((sp11 = GIV(stackPointer) - BytesPerWord), GIV(newMethod));
			GIV(stackPointer) = sp11;
			/* 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((sp22 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
			GIV(stackPointer) = sp22;
			/* end push: */
			/* begin push: */
			object2 = ((VMBIGENDIAN)
				 ? ((1 + ((sqInt) (((usqInt) numArgs ) << ((BytesPerWord * 8) - 8)) )) + 0) + 0
				 : ((1 + ((sqInt) (((usqInt) numArgs ) << 8) )) + 0) + 0);
			unsignedLongAtput((sp32 = GIV(stackPointer) - BytesPerWord), object2);
			GIV(stackPointer) = sp32;
			/* end push: */
			/* begin push: */
			unsignedLongAtput((sp42 = GIV(stackPointer) - BytesPerWord), 0);
			GIV(stackPointer) = sp42;
			/* end push: */
			GIV(instructionPointer) = initialIP - 1;
		} else {
			/* begin push: */
			object1 = ((usqInt) cogMethod );
			unsignedLongAtput((sp5 = GIV(stackPointer) - BytesPerWord), object1);
			GIV(stackPointer) = sp5;
			/* end push: */
			/* begin push: */
			unsignedLongAtput((sp6 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
			GIV(stackPointer) = sp6;
			/* end push: */
			GIV(instructionPointer) = ((usqInt) cogMethod ) + ((cogMethod->stackCheckOffset));
		}
		/* begin push: */
		unsignedLongAtput((sp10 = GIV(stackPointer) - BytesPerWord), rcvr2);
		GIV(stackPointer) = sp10;
		/* end push: */
		for (i = numArgs + 1; i <= numTemps; i += 1) {
			/* begin push: */
			unsignedLongAtput((sp7 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
			GIV(stackPointer) = sp7;
			/* end push: */
		};
		if (methodHeader & AlternateHeaderHasPrimFlag) {
			if (!cogMethod) {
				GIV(instructionPointer) += 3;
			}
			if (GIV(primFailCode) != 0) {
				shouldSkipStoreBytecode = reapAndResetErrorCodeToheader(GIV(framePointer), methodHeader);
				if ((cogMethod == null) && shouldSkipStoreBytecode) {
					GIV(instructionPointer) += 2;
				}
			}
		}
		goto l25;
		/* end justActivateNewMethod: */
	}
	if (GIV(argumentCount) == 1) {
		/* begin stackIntegerValue: */
		integerPointer = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
		/* begin checkedIntegerValueOf: */
		if (((integerPointer & 7) == 1)) {
			newFormatToUse = integerPointer >> 3;
			goto l16;
		} else {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			newFormatToUse = 0;
			goto l16;
		}
		/* end checkedIntegerValueOf: */
		l16:
		;
		/* end stackIntegerValue: */
		if ((newFormatToUse >= 3) && (newFormatToUse <= 4)) {
			/* begin setFormatToUse: */
			GIV(formatToUse) = newFormatToUse;
			/* end setFormatToUse: */
		} else {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			/* begin justActivateNewMethod: */
			/* 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)) {
				theCogMethod2 = ((CogMethod *) methodHeader2 );
				methodHeader2 = (theCogMethod2->methodHeader);
				{
					cogMethod2 = theCogMethod2;
				}
			}
			numTemps2 = (((usqInt) methodHeader2 ) >> MethodHeaderTempCountShift) & 0x3F;
			numArgs2 = (((usqInt) methodHeader2 ) >> MethodHeaderArgCountShift) & 15;
			rcvr3 = unsignedLongAt(GIV(stackPointer) + (numArgs2 * BytesPerWord));
			assert(!(isOopForwarded(rcvr3)));
			if ((cogMethod2 != null) && (!(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap()))))) {
				/* begin iframeSavedIP:put: */
				assert(!(isMachineCodeFrame(GIV(framePointer))));
				unsignedLongAtput(GIV(framePointer) + FoxIFSavedIP, GIV(instructionPointer));
				/* end iframeSavedIP:put: */
				GIV(instructionPointer) = ceReturnToInterpreterPC();
			}
			/* begin push: */
			unsignedLongAtput((sp82 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
			GIV(stackPointer) = sp82;
			/* end push: */
			/* begin push: */
			unsignedLongAtput((sp92 = GIV(stackPointer) - BytesPerWord), GIV(framePointer));
			GIV(stackPointer) = sp92;
			/* end push: */
			GIV(framePointer) = GIV(stackPointer);
			if (cogMethod2 == null) {
				initialIP2 = (GIV(newMethod) + ((LiteralStart + ((assert(((methodHeader2 & 7) == 1)), (methodHeader2 >> 3) & AlternateHeaderNumLiteralsMask))) * BytesPerOop)) + BaseHeaderSize;
				/* begin push: */
				unsignedLongAtput((sp12 = GIV(stackPointer) - BytesPerWord), GIV(newMethod));
				GIV(stackPointer) = sp12;
				/* 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((sp23 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
				GIV(stackPointer) = sp23;
				/* end push: */
				/* begin push: */
				object3 = ((VMBIGENDIAN)
					 ? ((1 + ((sqInt) (((usqInt) numArgs2 ) << ((BytesPerWord * 8) - 8)) )) + 0) + 0
					 : ((1 + ((sqInt) (((usqInt) numArgs2 ) << 8) )) + 0) + 0);
				unsignedLongAtput((sp33 = GIV(stackPointer) - BytesPerWord), object3);
				GIV(stackPointer) = sp33;
				/* end push: */
				/* begin push: */
				unsignedLongAtput((sp43 = GIV(stackPointer) - BytesPerWord), 0);
				GIV(stackPointer) = sp43;
				/* end push: */
				GIV(instructionPointer) = initialIP2 - 1;
			} else {
				/* begin push: */
				object11 = ((usqInt) cogMethod2 );
				unsignedLongAtput((sp52 = GIV(stackPointer) - BytesPerWord), object11);
				GIV(stackPointer) = sp52;
				/* end push: */
				/* begin push: */
				unsignedLongAtput((sp62 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
				GIV(stackPointer) = sp62;
				/* end push: */
				GIV(instructionPointer) = ((usqInt) cogMethod2 ) + ((cogMethod2->stackCheckOffset));
			}
			/* begin push: */
			unsignedLongAtput((sp102 = GIV(stackPointer) - BytesPerWord), rcvr3);
			GIV(stackPointer) = sp102;
			/* end push: */
			for (i2 = numArgs2 + 1; i2 <= numTemps2; i2 += 1) {
				/* begin push: */
				unsignedLongAtput((sp72 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
				GIV(stackPointer) = sp72;
				/* end push: */
			};
			if (methodHeader2 & AlternateHeaderHasPrimFlag) {
				if (!cogMethod2) {
					GIV(instructionPointer) += 3;
				}
				if (GIV(primFailCode) != 0) {
					shouldSkipStoreBytecode2 = reapAndResetErrorCodeToheader(GIV(framePointer), methodHeader2);
					if ((cogMethod2 == null) && shouldSkipStoreBytecode2) {
						GIV(instructionPointer) += 2;
					}
				}
			}
			goto l25;
			/* end justActivateNewMethod: */
		}
	}
	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: */
	objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	objOop = unsignedLongAt((objOop1 + 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)))) {
		int t0;
		int t1;

		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 l11;
	}
	if (activeContext & (tagMask())) {
		goto l11;
	}
	if (!(activeProc >= 0x20000000000LL)) {
		goto l11;
	}
	if (activeContext >= 0x20000000000LL) {
		goto l11;
	}
	if ((activeContext >= GIV(nilObj)) && (activeContext <= GIV(trueObj))) {
		goto l11;
	}
	if (!(activeContext >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l11;
	}
	remember(getFromPermToNewSpaceRememberedSet(), activeProc);
	l11:
	;
	/* 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 l24;
		} else {
			SIW_writeImageFilefromHeader(imageName, header);
			goto l24;
		}
		l24:
		;
		/* 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 justActivateNewMethod: */
		/* 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)) {
			theCogMethod3 = ((CogMethod *) methodHeader3 );
			methodHeader3 = (theCogMethod3->methodHeader);
			;
		}
		numTemps3 = (((usqInt) methodHeader3 ) >> MethodHeaderTempCountShift) & 0x3F;
		numArgs3 = (((usqInt) methodHeader3 ) >> MethodHeaderArgCountShift) & 15;
		rcvr4 = unsignedLongAt(GIV(stackPointer) + (numArgs3 * BytesPerWord));
		assert(!(isOopForwarded(rcvr4)));
		if ((cogMethod3 != null) && (!(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap()))))) {
			/* begin iframeSavedIP:put: */
			assert(!(isMachineCodeFrame(GIV(framePointer))));
			unsignedLongAtput(GIV(framePointer) + FoxIFSavedIP, GIV(instructionPointer));
			/* end iframeSavedIP:put: */
			GIV(instructionPointer) = ceReturnToInterpreterPC();
		}
		/* begin push: */
		unsignedLongAtput((sp83 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
		GIV(stackPointer) = sp83;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((sp93 = GIV(stackPointer) - BytesPerWord), GIV(framePointer));
		GIV(stackPointer) = sp93;
		/* end push: */
		GIV(framePointer) = GIV(stackPointer);
		if (cogMethod3 == null) {
			initialIP3 = (GIV(newMethod) + ((LiteralStart + ((assert(((methodHeader3 & 7) == 1)), (methodHeader3 >> 3) & AlternateHeaderNumLiteralsMask))) * BytesPerOop)) + BaseHeaderSize;
			/* begin push: */
			unsignedLongAtput((sp13 = GIV(stackPointer) - BytesPerWord), GIV(newMethod));
			GIV(stackPointer) = sp13;
			/* 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))) == methodHeader3);
			/* end setMethod:methodHeader: */
			/* begin push: */
			unsignedLongAtput((sp24 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
			GIV(stackPointer) = sp24;
			/* end push: */
			/* begin push: */
			object4 = ((VMBIGENDIAN)
				 ? ((1 + ((sqInt) (((usqInt) numArgs3 ) << ((BytesPerWord * 8) - 8)) )) + 0) + 0
				 : ((1 + ((sqInt) (((usqInt) numArgs3 ) << 8) )) + 0) + 0);
			unsignedLongAtput((sp34 = GIV(stackPointer) - BytesPerWord), object4);
			GIV(stackPointer) = sp34;
			/* end push: */
			/* begin push: */
			unsignedLongAtput((sp44 = GIV(stackPointer) - BytesPerWord), 0);
			GIV(stackPointer) = sp44;
			/* end push: */
			GIV(instructionPointer) = initialIP3 - 1;
		} else {
			/* begin push: */
			object12 = ((usqInt) cogMethod3 );
			unsignedLongAtput((sp53 = GIV(stackPointer) - BytesPerWord), object12);
			GIV(stackPointer) = sp53;
			/* end push: */
			/* begin push: */
			unsignedLongAtput((sp63 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
			GIV(stackPointer) = sp63;
			/* end push: */
			GIV(instructionPointer) = ((usqInt) cogMethod3 ) + ((cogMethod3->stackCheckOffset));
		}
		/* begin push: */
		unsignedLongAtput((sp103 = GIV(stackPointer) - BytesPerWord), rcvr4);
		GIV(stackPointer) = sp103;
		/* end push: */
		for (i3 = numArgs3 + 1; i3 <= numTemps3; i3 += 1) {
			/* begin push: */
			unsignedLongAtput((sp73 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
			GIV(stackPointer) = sp73;
			/* end push: */
		};
		if (methodHeader3 & AlternateHeaderHasPrimFlag) {
			if (!cogMethod3) {
				GIV(instructionPointer) += 3;
			}
			if (GIV(primFailCode) != 0) {
				shouldSkipStoreBytecode3 = reapAndResetErrorCodeToheader(GIV(framePointer), methodHeader3);
				if ((cogMethod3 == null) && shouldSkipStoreBytecode3) {
					GIV(instructionPointer) += 2;
				}
			}
		}
		/* end justActivateNewMethod: */
	}
	l25:
	;
	/* end snapshot */
	if ((unsignedLongAt(GIV(framePointer) + FoxMethod)) == GIV(newMethod)) {
		GIV(instructionPointer) -= 1;
	}
	siglongjmp(reenterInterpreter, ReturnToInterpreter);
}
/*	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 *theFP1;
	StackPage *thePage;
	StackPage *thePage2;
	StackPage *thePage3;
	char *theSP;
	sqInt thisCtx;
	sqInt valuePointer;
	sqInt valuePointer1;

	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 l21;
				}
				while (((callerFP = pointerForOop(unsignedLongAt(fp + FoxSavedFP)))) != 0) {
					if (callerFP == contextsFP) {
						frameAbove = fp;
						goto l21;
					}
					fp = callerFP;
				};
				error("did not find theFP in stack page");
				frameAbove = 0;
				l21:
				;
				/* 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 l26;
					}
					while (((callerFP2 = pointerForOop(unsignedLongAt(fp2 + FoxSavedFP)))) != 0) {
						if (callerFP2 == theFP) {
							frameAbove = fp2;
							goto l26;
						}
						fp2 = callerFP2;
					};
					error("did not find theFP in stack page");
					frameAbove = 0;
					l26:
					;
					/* 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 l27;
						}
						while (((callerFP3 = pointerForOop(unsignedLongAt(fp3 + FoxSavedFP)))) != 0) {
							if (callerFP3 == contextsFP) {
								frameAbove = fp3;
								goto l27;
							}
							fp3 = callerFP3;
						};
						error("did not find theFP in stack page");
						frameAbove = 0;
						l27:
						;
						/* 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: */
						theFP1 = (thePage->baseFP);
						assert(isBaseFrame(theFP1));
						/* begin stackPageFor: */
						/* begin stackPageAt: */
						thePage3 = stackPageAtpages((assert((((char *) theFP1 ) >= (GIV(stackBasePlus1) - 1)) && (((char *) theFP1 ) <= ((char *) GIV(pages) ))), pageIndexForstackBasePlus1bytesPerPage(theFP1, 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: */
					valuePointer1 = GIV(nilObj);
					assert(!(isOopForwarded(currentCtx)));
					longAtput((currentCtx + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), valuePointer1);
					/* 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)))) {
			int t0;
			int t1;

			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 l32;
		}
		if (aContextOrNil & (tagMask())) {
			goto l32;
		}
		if (!(thisCtx >= 0x20000000000LL)) {
			goto l32;
		}
		if (aContextOrNil >= 0x20000000000LL) {
			goto l32;
		}
		if ((aContextOrNil >= GIV(nilObj)) && (aContextOrNil <= GIV(trueObj))) {
			goto l32;
		}
		if (!(aContextOrNil >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l32;
		}
		remember(getFromPermToNewSpaceRememberedSet(), thisCtx);
		l32:
		;
		/* 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);
}
/*	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 address1;
	StackPage *aPage;
	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 limit1;
	sqInt methodHeader;
	sqInt methodHeader2;
	sqInt methodObj;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	sqInt object;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	sqInt oop;
	sqInt prevObj;
	sqInt prevObj2;
	sqInt prevPrevObj;
	sqInt prevPrevObj2;
	int probe;
	sqInt scanHeapForContexts;
	sqInt senderOop;
	char *sp;
	char *sp2;
	char *theFP;
	char *theFrame;
	StackPage *thePage;
	char *theSP;
	char *theSP1;
	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 l1;
		}
		if (obj == GIV(falseObj)) {
			scanHeapForContexts = 0;
			goto l1;
		}
		/* begin success: */
		{
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
		}
		/* end success: */
		scanHeapForContexts = null;
		l1:
		;
		/* 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 l9;
	}
	activeContext = marryFrameSP(theFP, theSP);
	l9:
	;
	/* 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: */
	theSP1 = GIV(stackPointer);
	assert(theSP1 < GIV(framePointer));
	assert((theSP1 < ((GIV(stackPage)->baseAddress))) && (theSP1 > (((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 = theSP1);
	}
	/* 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;
			for (i2 = 0; i2 < GIV(numStackPages); i2 += 1) {
				/* begin stackPageAt: */
				aPage = stackPageAtpages(i2, GIV(pages));
				/* end stackPageAt: */
				if (!(isFree(aPage))) {
					markStackPageMostRecentlyUsed(GIV(stackPage));
					if (divorceAMachineCodeFrameWithCogMethodin(cogMethod, aPage)) {
						divorcedSome2 = 1;
					}
				}
			};
			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 l19;
			}
			flag("endianness");
			followingWord = unsignedLongAt(followingWordAddress);
			objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress + BaseHeaderSize
				 : followingWordAddress);
			l19:
			;
			/* end objectAfter:limit: */
		};
		/* begin objectStartingAt: */
		address1 = ((eden()).start);
		numSlots2 = byteAt(address1 + 7);
		objOop2 = ((numSlots2 == (numSlotsMask()))
			 ? address1 + BaseHeaderSize
			 : address1);
		/* 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 l16;
			}
			flag("endianness");
			followingWord2 = unsignedLongAt(followingWordAddress2);
			objOop2 = (((((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 ((((longAt(objOop22)) & (classIndexMask())) == ClassMethodContextCompactIndex) && ((unsignedLongAt((objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ))) == methodObj)) {
							widowOrForceToBytecodePC(objOop22);
						}
					}
				}
			}
			prevPrevObj2 = prevObj2;
			prevObj2 = objOop22;
			/* begin objectAfter:limit: */
			limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			followingWordAddress4 = addressAfter(objOop22);
			if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
				objOop22 = limit1;
				goto l20;
			}
			flag("endianness");
			followingWord4 = unsignedLongAt(followingWordAddress4);
			objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress4 + BaseHeaderSize
				 : followingWordAddress4);
			l20:
			;
			/* 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 l17;
			}
			flag("endianness");
			followingWord3 = unsignedLongAt(followingWordAddress3);
			currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress3 + BaseHeaderSize
				 : followingWordAddress3);
			l17:
			;
			/* 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);
	}
	/* 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: */
}
/* CoInterpreterPrimitives>>#unmarkAllFrames */
static void
unmarkAllFrames(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt flags;
	sqInt i;
	sqInt methodField;
	char *theFP;
	StackPage *thePage;

	for (i = 0; i < GIV(numStackPages); i += 1) {
		/* begin stackPageAt: */
		thePage = stackPageAtpages(i, GIV(pages));
		/* end stackPageAt: */
		if (!(isFree(thePage))) {
			theFP = (thePage->headFP);
			do{
				methodField = unsignedLongAt(theFP + FoxMethod);
				if (((usqInt) methodField ) < (startOfObjectMemory(getMemoryMap()))) {
					if ((methodField & 4) != 0) {
						unsignedLongAtput(theFP + FoxMethod, methodField - 4);
					}
				} else {
					flags = unsignedLongAt(theFP + FoxIFrameFlags);
					if ((flags & 2) != 0) {
						unsignedLongAtput(theFP + FoxIFrameFlags, flags - 2);
					}
				}
			}while(((theFP = pointerForOop(unsignedLongAt(theFP + FoxSavedFP)))) != 0);
		}
	};
}
/* 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;
	sqInt fv;
	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 fullFileName1;
	sqInt fv;
	char lineBuffer[1024];
	char lineBuffer2[1024];
	ComposedMetadataStruct metadata;
	ComposedMetadataStruct *metadataPointer;
	sqInt newBase;
	sqInt oldBase;
	SpurSegmentInfo *segInfo;
	SpurSegmentInfo *segInfo2;
	int segmentIndex;
	ComposedMetadataStruct segmentMetadata;
	size_t segmentSize;
	sqInt startingAddress;
	char structName[255];
	size_t totalBytesRead;

	fieldValue = 0;
	fn = 0;
	/* begin prepareSegmentsToRead */
	/* begin clearSegments */
	GIV(numSegments) = 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");
			fullFileName1 = buffer3;
		}
		/* end segmentFileName:withExtension:inImage:into:bufferSize: */
		/* end segmentMetadataFile:inImage: */
		/* begin simulationOnly: */
		/* end simulationOnly: */
		file2 = sqImageFileOpen(fullFileName1, "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 segmentDataFile:inImage: */
		/* begin simulationOnly: */
		/* end simulationOnly: */
		{
			snprintf(buffer2, 0xFF, "%s/seg%d%s", ((char *) imageFileName ), ((int) segmentIndex ), ".data");
			fullFileName = buffer2;
		}
		/* end segmentDataFile:inImage: */
		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;
	SpurSegmentInfo *aSegment;
	char buffer[255];
	char buffer2[255];
	char buffer3[255];
	size_t bytesWritten;
	sqImageFile dataFile;
	sqInt fieldName;
	sqInt fieldName2;
	sqInt fieldValue;
	sqInt fieldValue2;
	sqImageFile file;
	sqInt fullFileName;
	sqInt fullFileName1;
	sqInt i;
	sqInt iLimiT;
	ComposedMetadataStruct metadata;
	sqImageFile metadataFile;
	sqInt name;
	sqInt name2;
	size_t nWritten;
	size_t oldSpaceBytesWritten;
	size_t permanentSpaceBytesWritten;
	sqInt r;
	sqInt segmentIndex;
	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, buffer, 0xFF), "w");
	if (!file) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		goto l3;
		/* 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);
	l3:
	;
	/* 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 l1;
			/* end primitiveFail */
		}
		r = unlink(segmentDataFileinImage(segmentIndex2, imageFileName));
		if (r != 0) {
			logError("Error deleting %s", segmentDataFileinImage(segmentIndex2, imageFileName));
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			goto l1;
			/* end primitiveFail */
		}
		segmentIndex2 += 1;
	};
	l1:
	;
	/* end ensureDeleteSegments: */
	if (GIV(primFailCode)) {
		oldSpaceBytesWritten = 0;
		goto l2;
	}
	/* 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: */
	l2:
	;
	/* 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(buffer3, 0xFF, "%s/%s", ((char *) imageFileName ), ((char *) "permSpace.ston" ));
		fullFileName = buffer3;
		/* end permSpaceFileName:inImage:into:bufferSize: */
	}
	metadataFile = sqImageFileOpen(fullFileName, "w");
	if (!metadataFile) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		goto l5;
		/* 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);
	l5:
	;
	/* 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(buffer2, 0xFF, "%s/%s", ((char *) imageFileName ), ((char *) "permSpace.data" ));
		fullFileName1 = buffer2;
	}
	dataFile = sqImageFileOpen(fullFileName1, "wb");
	if (!dataFile) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		permanentSpaceBytesWritten = null;
		goto l6;
		/* end primitiveFail */
	}
	nWritten = 0;
	if (size > 0) {
		nWritten = sqImageFileWrite(start, 1, size, dataFile);
	}
	sqImageFileClose(dataFile);
	permanentSpaceBytesWritten = nWritten;
	/* end writeDataStatingAt:withSize:inFileName: */
	/* end writePermanentSpaceData: */
	l6:
	;
	/* 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 fullFileName1;
	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(buffer, 0xFF, "%s/seg%d%s", ((char *) imageFileName ), ((int) segmentIndex ), ".ston");
		fullFileName = buffer;
	}
	/* end segmentFileName:withExtension:inImage:into:bufferSize: */
	/* end segmentMetadataFile:inImage: */
	metadataFile = sqImageFileOpen(fullFileName, "w");
	if (!metadataFile) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		goto l1;
		/* 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);
	l1:
	;
	/* end writeMetadata:inFileName: */
	/* end writeSegmentMetadata:nextIndex:inImage: */
	/* begin writeSegmentData:nextIndex:inImage: */
	/* begin writeDataStatingAt:withSize:inFileName: */
	start = ((sqInt) ((void *) ((segment->segStart)) ) );
	size = (segment->segSize);
	/* begin segmentDataFile:inImage: */
	/* begin simulationOnly: */
	/* end simulationOnly: */
	{
		snprintf(buffer2, 0xFF, "%s/seg%d%s", ((char *) imageFileName ), ((int) segmentIndex ), ".data");
		fullFileName1 = buffer2;
	}
	/* end segmentDataFile:inImage: */
	dataFile = sqImageFileOpen(fullFileName1, "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 l2;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	assert(!(isImmediate(oop)));
	/* begin classIndexOf: */
	ccIndex = (longAt(oop)) & (classIndexMask());
	/* end classIndexOf: */
	{
		isString = ClassByteStringCompactIndex == ccIndex;
		goto l2;
	}
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	l2:
	;
	/* 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 l4;
	}
	if (fmt >= (firstByteFormat())) {
		len = (numSlots << (shiftForWord())) - (fmt & 7);
		goto l4;
	}
	if (fmt >= (firstShortFormat())) {
		len = (numSlots << ((shiftForWord()) - 1)) - (fmt & 3);
		goto l4;
	}
	if (fmt >= (firstLongFormat())) {
		len = (numSlots << ((shiftForWord()) - 2)) - (fmt & 1);
		goto l4;
	}
	if (fmt == (sixtyFourBitIndexableFormat())) {
		len = numSlots;
		goto l4;
	}
	len = 0;
	l4:
	;
	/* 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 objOop1;

	/* 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: */
		objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		objOop = unsignedLongAt((objOop1 + 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 classOop1;
	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 l2;
		}
		l2:
		;
		/* end isClassOfNonImm:equalTo:compactClassIndex: */
		if (ok) {
			return 0;
		}
		/* begin isClassOfNonImm:equalTo:compactClassIndex: */
		classOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargeNegativeInteger ) << (shiftForWord())) ));
		assert(!(isImmediate(oop)));
		/* begin classIndexOf: */
		ccIndex2 = (longAt(oop)) & (classIndexMask());
		/* end classIndexOf: */
		{
			ok = ClassLargeNegativeIntegerCompactIndex == ccIndex2;
			goto l4;
		}
		l4:
		;
		/* 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 l2;
	}
	l2:
	;
	/* 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 classOop1;
	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: */
	classOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(oop)));
	/* begin classIndexOf: */
	ccIndex2 = (longAt(oop)) & (classIndexMask());
	/* end classIndexOf: */
	{
		ok = ClassLargePositiveIntegerCompactIndex == ccIndex2;
		goto l4;
	}
	l4:
	;
	/* 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 l2;
		}
		l2:
		;
		/* 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 l2;
	}
	l2:
	;
	/* 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 l2;
	}
	l2:
	;
	/* 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;
	usqLong fmt;
	sqLong hdr;
	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: */
	/* 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 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())) && ((hdr & (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 classFormat1;
	sqInt fixedFields2;
	usqLong fmt2;
	sqLong hdr2;
	sqInt index;
	usqInt numSlots22;
	usqInt numSlots3;
	sqInt rcvr;
	sqInt reasonCode1;
	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 l28;
		/* end primitiveFailFor: */
	}
	if (((index & (smallIntegerTag())) == 0) || ((GIV(argumentCount) > 2) && (((long64At(rcvr)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		goto l28;
		/* 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 l28;
		/* end primitiveFailFor: */
	}
	index = index >> 3;
	{
		/* begin stObject:at:put: */
		/* begin baseHeader: */
		hdr2 = long64At(rcvr);
		/* end baseHeader: */
		if ((hdr2 & (classIndexMask())) == ClassMethodContextCompactIndex) {
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadReceiver;
			goto l27;
			/* end primitiveFailFor: */
		}
		fmt2 = (((unsigned sqLong) hdr2 ) >> (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: */
		classFormat1 = (unsignedLongAt((class2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
		fixedFields2 = classFormat1 & ((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)))) {
					int t0;
					int t1;

					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 l26;
				}
				if (value & (tagMask())) {
					goto l26;
				}
				if (!(rcvr >= 0x20000000000LL)) {
					goto l26;
				}
				if (value >= 0x20000000000LL) {
					goto l26;
				}
				if ((value >= GIV(nilObj)) && (value <= GIV(trueObj))) {
					goto l26;
				}
				if (!(value >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l26;
				}
				remember(getFromPermToNewSpaceRememberedSet(), rcvr);
				l26:
				;
				/* 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: */
			reasonCode1 = ((fmt2 <= 1)
				 ? PrimErrBadReceiver
				 : PrimErrBadIndex);
			GIV(primFailCode) = reasonCode1;
			/* end primitiveFailFor: */
		}
		l27:
		;
		/* 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: */
	}
	l28:
	;
	/* 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 classOop1;
	sqInt fmt;
	sqInt fmt2;
	usqInt integerArgumentValue;
	usqInt integerReceiverValue;
	sqInt ok;
	sqInt ok2;
	sqInt oop;
	sqInt oop1;
	sqInt oop2;
	char *sp;
	sqInt value;
	sqInt value2;

	/* begin positiveMachineIntegerValueOf: */
	oop1 = unsignedLongAt(GIV(stackPointer));
	if (((oop1 & 7) == 1)) {
		value = oop1 >> 3;
		if (value < 0) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			integerArgumentValue = ((usqIntptr_t) null );
			goto l4;
			/* end primitiveFail */
		}
		integerArgumentValue = ((usqIntptr_t) value );
		goto l4;
	}
	if (oop1 & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerArgumentValue = 0;
		goto l4;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(oop1)));
	/* begin classIndexOf: */
	ccIndex = (longAt(oop1)) & (classIndexMask());
	/* end classIndexOf: */
	{
		ok = ClassLargePositiveIntegerCompactIndex == ccIndex;
		goto l2;
	}
	l2:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (!ok) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerArgumentValue = 0;
		goto l4;
	}
	/* begin numBytesOfBytes: */
	fmt = (((usqInt) (longAt(oop1)) ) >> (formatShift())) & (formatMask());
	assert(fmt >= (firstByteFormat()));
	bs = ((numSlotsOf(oop1)) << (shiftForWord())) - (fmt & 7);
	/* end numBytesOfBytes: */
	if (bs > (sizeof(usqIntptr_t))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerArgumentValue = 0;
		goto l4;
	}
	if (((sizeof(usqIntptr_t)) == 8) && (bs > 4)) {
		integerArgumentValue = ((usqIntptr_t) (SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((oop1 + BaseHeaderSize) + (0U << 3)))) );
		goto l4;
	} else {
		integerArgumentValue = ((usqIntptr_t) ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((oop1 + BaseHeaderSize) + (0U << 2)))) ) );
		goto l4;
	}
	l4:
	;
	/* end positiveMachineIntegerValueOf: */
	/* begin positiveMachineIntegerValueOf: */
	oop2 = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (((oop2 & 7) == 1)) {
		value2 = oop2 >> 3;
		if (value2 < 0) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			integerReceiverValue = ((usqIntptr_t) null );
			goto l8;
			/* end primitiveFail */
		}
		integerReceiverValue = ((usqIntptr_t) value2 );
		goto l8;
	}
	if (oop2 & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerReceiverValue = 0;
		goto l8;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	classOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(oop2)));
	/* begin classIndexOf: */
	ccIndex2 = (longAt(oop2)) & (classIndexMask());
	/* end classIndexOf: */
	{
		ok2 = ClassLargePositiveIntegerCompactIndex == ccIndex2;
		goto l5;
	}
	l5:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (!ok2) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerReceiverValue = 0;
		goto l8;
	}
	/* begin numBytesOfBytes: */
	fmt2 = (((usqInt) (longAt(oop2)) ) >> (formatShift())) & (formatMask());
	assert(fmt2 >= (firstByteFormat()));
	bs2 = ((numSlotsOf(oop2)) << (shiftForWord())) - (fmt2 & 7);
	/* end numBytesOfBytes: */
	if (bs2 > (sizeof(usqIntptr_t))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerReceiverValue = 0;
		goto l8;
	}
	if (((sizeof(usqIntptr_t)) == 8) && (bs2 > 4)) {
		integerReceiverValue = ((usqIntptr_t) (SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((oop2 + BaseHeaderSize) + (0U << 3)))) );
		goto l8;
	} else {
		integerReceiverValue = ((usqIntptr_t) ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((oop2 + BaseHeaderSize) + (0U << 2)))) ) );
		goto l8;
	}
	l8:
	;
	/* 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 classOop1;
	sqInt fmt;
	sqInt fmt2;
	usqInt integerArgumentValue;
	usqInt integerReceiverValue;
	sqInt ok;
	sqInt ok2;
	sqInt oop;
	sqInt oop1;
	sqInt oop2;
	char *sp;
	sqInt value;
	sqInt value2;

	/* begin positiveMachineIntegerValueOf: */
	oop1 = unsignedLongAt(GIV(stackPointer));
	if (((oop1 & 7) == 1)) {
		value = oop1 >> 3;
		if (value < 0) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			integerArgumentValue = ((usqIntptr_t) null );
			goto l4;
			/* end primitiveFail */
		}
		integerArgumentValue = ((usqIntptr_t) value );
		goto l4;
	}
	if (oop1 & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerArgumentValue = 0;
		goto l4;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	classOop = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(oop1)));
	/* begin classIndexOf: */
	ccIndex = (longAt(oop1)) & (classIndexMask());
	/* end classIndexOf: */
	{
		ok = ClassLargePositiveIntegerCompactIndex == ccIndex;
		goto l2;
	}
	l2:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (!ok) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerArgumentValue = 0;
		goto l4;
	}
	/* begin numBytesOfBytes: */
	fmt = (((usqInt) (longAt(oop1)) ) >> (formatShift())) & (formatMask());
	assert(fmt >= (firstByteFormat()));
	bs = ((numSlotsOf(oop1)) << (shiftForWord())) - (fmt & 7);
	/* end numBytesOfBytes: */
	if (bs > (sizeof(usqIntptr_t))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerArgumentValue = 0;
		goto l4;
	}
	if (((sizeof(usqIntptr_t)) == 8) && (bs > 4)) {
		integerArgumentValue = ((usqIntptr_t) (SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((oop1 + BaseHeaderSize) + (0U << 3)))) );
		goto l4;
	} else {
		integerArgumentValue = ((usqIntptr_t) ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((oop1 + BaseHeaderSize) + (0U << 2)))) ) );
		goto l4;
	}
	l4:
	;
	/* end positiveMachineIntegerValueOf: */
	/* begin positiveMachineIntegerValueOf: */
	oop2 = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (((oop2 & 7) == 1)) {
		value2 = oop2 >> 3;
		if (value2 < 0) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			integerReceiverValue = ((usqIntptr_t) null );
			goto l8;
			/* end primitiveFail */
		}
		integerReceiverValue = ((usqIntptr_t) value2 );
		goto l8;
	}
	if (oop2 & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerReceiverValue = 0;
		goto l8;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	classOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(oop2)));
	/* begin classIndexOf: */
	ccIndex2 = (longAt(oop2)) & (classIndexMask());
	/* end classIndexOf: */
	{
		ok2 = ClassLargePositiveIntegerCompactIndex == ccIndex2;
		goto l5;
	}
	l5:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (!ok2) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerReceiverValue = 0;
		goto l8;
	}
	/* begin numBytesOfBytes: */
	fmt2 = (((usqInt) (longAt(oop2)) ) >> (formatShift())) & (formatMask());
	assert(fmt2 >= (firstByteFormat()));
	bs2 = ((numSlotsOf(oop2)) << (shiftForWord())) - (fmt2 & 7);
	/* end numBytesOfBytes: */
	if (bs2 > (sizeof(usqIntptr_t))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerReceiverValue = 0;
		goto l8;
	}
	if (((sizeof(usqIntptr_t)) == 8) && (bs2 > 4)) {
		integerReceiverValue = ((usqIntptr_t) (SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((oop2 + BaseHeaderSize) + (0U << 3)))) );
		goto l8;
	} else {
		integerReceiverValue = ((usqIntptr_t) ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((oop2 + BaseHeaderSize) + (0U << 2)))) ) );
		goto l8;
	}
	l8:
	;
	/* 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 {
			sqInt t1;

			if (!(integerArgument >= -61)) {
				{
					/* begin primitiveFail */
					if (!GIV(primFailCode)) {
						GIV(primFailCode) = 1;
					}
					/* end primitiveFail */
					return;
				}
			}
			shifted = ((sqInt) integerReceiver ) >> (0 - integerArgument);
		}
		{
			sqInt t0;

			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 l1;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		shift = 0;
		goto l1;
	}
	/* end checkedIntegerValueOf: */
	l1:
	;
	/* 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 classOop1;
	sqInt fmt;
	sqInt fmt2;
	sqInt integerArgument;
	usqInt integerArgumentValue;
	sqInt integerReceiver;
	usqInt integerReceiverValue;
	sqInt ok;
	sqInt ok2;
	sqInt oop;
	sqInt oop1;
	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 l4;
				/* end primitiveFail */
			}
			integerArgumentValue = ((usqIntptr_t) value );
			goto l4;
		}
		if (integerArgument & (tagMask())) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			integerArgumentValue = 0;
			goto l4;
		}
		/* 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 l2;
		}
		l2:
		;
		/* end isClassOfNonImm:equalTo:compactClassIndex: */
		if (!ok) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			integerArgumentValue = 0;
			goto l4;
		}
		/* 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 l4;
		}
		if (((sizeof(usqIntptr_t)) == 8) && (bs > 4)) {
			integerArgumentValue = ((usqIntptr_t) (SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((integerArgument + BaseHeaderSize) + (0U << 3)))) );
			goto l4;
		} else {
			integerArgumentValue = ((usqIntptr_t) ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((integerArgument + BaseHeaderSize) + (0U << 2)))) ) );
			goto l4;
		}
		l4:
		;
		/* 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 l8;
				/* end primitiveFail */
			}
			integerReceiverValue = ((usqIntptr_t) value2 );
			goto l8;
		}
		if (integerReceiver & (tagMask())) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			integerReceiverValue = 0;
			goto l8;
		}
		/* begin isClassOfNonImm:equalTo:compactClassIndex: */
		classOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
		assert(!(isImmediate(integerReceiver)));
		/* begin classIndexOf: */
		ccIndex2 = (longAt(integerReceiver)) & (classIndexMask());
		/* end classIndexOf: */
		{
			ok2 = ClassLargePositiveIntegerCompactIndex == ccIndex2;
			goto l5;
		}
		l5:
		;
		/* end isClassOfNonImm:equalTo:compactClassIndex: */
		if (!ok2) {
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			integerReceiverValue = 0;
			goto l8;
		}
		/* 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 l8;
		}
		if (((sizeof(usqIntptr_t)) == 8) && (bs2 > 4)) {
			integerReceiverValue = ((usqIntptr_t) (SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((integerReceiver + BaseHeaderSize) + (0U << 3)))) );
			goto l8;
		} else {
			integerReceiverValue = ((usqIntptr_t) ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((integerReceiver + BaseHeaderSize) + (0U << 2)))) ) );
			goto l8;
		}
		l8:
		;
		/* end positiveMachineIntegerValueOf: */
		if (!GIV(primFailCode)) {
			/* begin pop:thenPush: */
			oop1 = positiveMachineIntegerFor(integerArgumentValue ^ integerReceiverValue);
			unsignedLongAtput((sp2 = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), oop1);
			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 aBool;
	sqInt freeChunk;
	sqInt i;
	sqInt integerVal;
	sqInt integerVal1;
	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 l2;
						}
					};
					integerVal = 0;
					goto l2;
				}
				integerVal = bytesInObject(freeChunk);
				l2:
				;
				/* 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)) {
			aBool = 1;
			goto l1;
		}
		if (obj == GIV(falseObj)) {
			aBool = 0;
			goto l1;
		}
		/* begin success: */
		{
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
		}
		/* end success: */
		aBool = null;
		l1:
		;
		/* end booleanValueOf: */
		if (!GIV(primFailCode)) {
			{
				/* begin pop:thenPushInteger: */
				integerVal1 = (((GIV(totalFreeOldSpace) + ((((eden()).limit)) - GIV(freeStart))) + ((((pastSpace()).limit)) - GIV(pastSpaceStart))) + ((((futureSpace()).limit)) - (((futureSpace()).limit)))) - (interpreterAllocationReserveBytes());
				unsignedLongAtput((sp3 = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), ((((usqInt) integerVal1 ) << 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 l2;
	}
	arg = oop;
	l2:
	;
	/* 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 l3;
	}
	rcvr = oop2;
	l3:
	;
	/* 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: */
	}
}
/*	Primitive. Void the VM profile histograms. */
/* InterpreterPrimitives>>#primitiveClearVMProfile */
static void
primitiveClearVMProfile(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	ioClearProfile();
	/* begin pop: */
	GIV(stackPointer) += GIV(argumentCount) * BytesPerWord;
	/* end pop: */
}
/*	Take a boolean which if true turns or keeps clock logging on. Answer an 
	array supplying 
	the size of the clock logs, the address of the usecs log, the index in it, 
	the address of the 
	msecs log, and the index into it. */
/* InterpreterPrimitives>>#primitiveClockLogAddresses */
EXPORT(sqInt)
primitiveClockLogAddresses(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt classObj;
	sqInt midx;
	void *msecs;
	sqInt objOop;
	sqInt objOop1;
	sqInt objOop2;
	sqInt objOop3;
	sqInt objOop4;
	sqInt oop;
	sqInt oop1;
	sqInt oop3;
	sqInt result;
	sqInt runInNOut;
	char *sp;
	sqInt uidx;
	void *usecs;
	sqInt v1;
	sqInt v2;

	midx = 0;
	msecs = ((void *) 0 );
	uidx = 0;
	usecs = ((void *) 0 );
	if (GIV(argumentCount) != 1) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	runInNOut = (unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord))) == GIV(trueObj);
	ioGetClockLogSizeUsecsIdxMsecsIdx(&runInNOut, &usecs, &uidx, &msecs, &midx);
	/* begin instantiateClass:indexableSize: */
	classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassArray ) << (shiftForWord())) ));
	result = instantiateClassindexableSizeisPinnedisOldSpace(classObj, 5, 0, 0);
	/* end instantiateClass:indexableSize: */
	if (result == 0) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	/* begin pushRemappableOop: */
	assert(addressCouldBeOop(result));
	GIV(remapBuffer)[(GIV(remapBufferCount) += 1)] = result;
	if (!(GIV(remapBufferCount) <= RemapBufferSize)) {
		error("remapBuffer overflow");
	}
	/* end pushRemappableOop: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	objOop = GIV(remapBuffer)[GIV(remapBufferCount)];
	assert(!(isOopForwarded(objOop)));
	longAtput((objOop + BaseHeaderSize) + (0U << (shiftForWord())), ((((usqInt) runInNOut ) << 3) | 1));
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin positive32BitIntegerFor: */
	{
		v1 = (((((usqInt) ((unsigned int) ((usqInt) usecs ) ) ) & 0xFFFFFFFFU) << 3) | 1);
		goto l5;
	}
	l5:
	;
	/* end positive32BitIntegerFor: */
	/* begin positive32BitIntegerFor: */
	{
		v2 = (((((usqInt) ((unsigned int) ((usqInt) msecs ) ) ) & 0xFFFFFFFFU) << 3) | 1);
		goto l6;
	}
	l6:
	;
	/* end positive32BitIntegerFor: */
	if (GIV(primFailCode)) {
		/* begin popRemappableOop */
		oop = GIV(remapBuffer)[GIV(remapBufferCount)];
		GIV(remapBufferCount) -= 1;
		/* end popRemappableOop */
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	/* begin storePointer:ofObject:withValue: */
	objOop3 = GIV(remapBuffer)[GIV(remapBufferCount)];
	assert(!(isForwarded(objOop3)));
	if (((objOop3 & (tagMask())) == 0) && ((objOop3 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		int t0;
		int t1;

		if (((v1 & (tagMask())) == 0) && (((v1 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (v1 >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(objOop3)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), objOop3);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(objOop3)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l7;
	}
	if (v1 & (tagMask())) {
		goto l7;
	}
	if (!(objOop3 >= 0x20000000000LL)) {
		goto l7;
	}
	if (v1 >= 0x20000000000LL) {
		goto l7;
	}
	if ((v1 >= GIV(nilObj)) && (v1 <= GIV(trueObj))) {
		goto l7;
	}
	if (!(v1 >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l7;
	}
	remember(getFromPermToNewSpaceRememberedSet(), objOop3);
	l7:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((objOop3 + BaseHeaderSize) + (1U << (shiftForWord())), v1);
	/* end storePointer:ofObject:withValue: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	objOop1 = GIV(remapBuffer)[GIV(remapBufferCount)];
	assert(!(isOopForwarded(objOop1)));
	longAtput((objOop1 + BaseHeaderSize) + (2U << (shiftForWord())), ((((usqInt) uidx ) << 3) | 1));
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin storePointer:ofObject:withValue: */
	objOop4 = GIV(remapBuffer)[GIV(remapBufferCount)];
	assert(!(isForwarded(objOop4)));
	if (((objOop4 & (tagMask())) == 0) && ((objOop4 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		int t0;
		int t1;

		if (((v2 & (tagMask())) == 0) && (((v2 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (v2 >= ((GIV(memoryMap)->newSpaceStart))))) {
			/* begin possibleOldObjectStoreInto: */
			if (!(((((usqInt) (long64At(objOop4)) ) >> (rememberedBitShift())) & 1) != 0)) {
				remember(GIV(fromOldSpaceRememberedSet), objOop4);
			}
			/* end possibleOldObjectStoreInto: */
		}
	}
	/* begin possiblePermObjectStoreInto:value: */
	if (((((usqInt) (long64At(objOop4)) ) >> (rememberedBitShift())) & 1) != 0) {
		goto l9;
	}
	if (v2 & (tagMask())) {
		goto l9;
	}
	if (!(objOop4 >= 0x20000000000LL)) {
		goto l9;
	}
	if (v2 >= 0x20000000000LL) {
		goto l9;
	}
	if ((v2 >= GIV(nilObj)) && (v2 <= GIV(trueObj))) {
		goto l9;
	}
	if (!(v2 >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l9;
	}
	remember(getFromPermToNewSpaceRememberedSet(), objOop4);
	l9:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((objOop4 + BaseHeaderSize) + (3U << (shiftForWord())), v2);
	/* end storePointer:ofObject:withValue: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	objOop2 = GIV(remapBuffer)[GIV(remapBufferCount)];
	assert(!(isOopForwarded(objOop2)));
	longAtput((objOop2 + BaseHeaderSize) + (4U << (shiftForWord())), ((((usqInt) midx ) << 3) | 1));
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin pop:thenPush: */
	/* begin popRemappableOop */
	oop3 = GIV(remapBuffer)[GIV(remapBufferCount)];
	GIV(remapBufferCount) -= 1;
	oop1 = oop3;
	/* end popRemappableOop */
	unsignedLongAtput((sp = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), oop1);
	GIV(stackPointer) = sp;
	/* end pop:thenPush: */
	return 0;
}
/*	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 l2;
		/* end primitiveFail */
	}
	if (format >= (firstShortFormat())) {
		if (format >= (firstByteFormat())) {
			if ((fillValue > 0xFF) || (format >= (firstCompiledMethodFormat()))) {
				/* begin primitiveFail */
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
				goto l2;
				/* 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 l2;
				/* 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 l2;
				/* 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: */
	l2:
	;
	/* end primitiveConstantFillSpur */
}
/*	Primitive. Start or stop the VM profiler. The first argument is a boolean 
	to switch profiling on or off. The second argument is an integer or nil. 
	If an integer it determines the maximum number of samples in the VM's 
	sample buffer. Answer the current number of samples in the buffer. */
/* InterpreterPrimitives>>#primitiveControlVMProfiling */
static void
primitiveControlVMProfiling(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt bufferSize;
	sqInt numSamples;
	sqInt onOffBar;
	char *sp;

	if (GIV(argumentCount) != 2) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	if (((onOffBar = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord)))) == GIV(trueObj)) {
		onOffBar = 1;
	} else {
		if (onOffBar == GIV(falseObj)) {
			onOffBar = 0;
		} else {
			{
				/* begin primitiveFail */
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
				/* end primitiveFail */
				return;
			}
		}
	}
	if (((bufferSize = unsignedLongAt(GIV(stackPointer)))) == GIV(nilObj)) {
		bufferSize = 0;
	} else {
		if (!((((bufferSize & 7) == 1)) && (((bufferSize = bufferSize >> 3)) > 0))) {
			{
				/* begin primitiveFail */
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
				/* end primitiveFail */
				return;
			}
		}
	}
	numSamples = ioControlNewProfile(onOffBar, bufferSize);
	/* begin pop:thenPushInteger: */
	unsignedLongAtput((sp = GIV(stackPointer) + ((3 - 1) * BytesPerWord)), ((((usqInt) numSamples ) << 3) | 1));
	GIV(stackPointer) = sp;
	/* end pop:thenPushInteger: */
}
/*	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 l4;
		}
		if (fmt <= (sixtyFourBitIndexableFormat())) {
			length = ((sqInt) numBytes );
			goto l4;
		}
		if (fmt >= (firstShortFormat())) {
			length = numBytes - ((sqInt) (((usqInt) (fmt & 3) ) << 1) );
			goto l4;
		}
		length = numBytes - ((sqInt) (((usqInt) (fmt & 1) ) << 2) );
		l4:
		;
		/* 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)))) {
				int t0;
				int t1;

				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 l5;
			}
			if (valuePointer & (tagMask())) {
				goto l5;
			}
			if (!(rcvr >= 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(), rcvr);
			l5:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) i ) << (shiftForWord())) ), valuePointer);
			/* end storePointer:ofObject:withValue: */
		};
	}
	/* begin pop: */
	GIV(stackPointer) += GIV(argumentCount) * BytesPerWord;
	/* end pop: */
}
/*	Crash the VM by indirecting through a null pointer. If the sole argument 
	is true crash in this thread, and if it is false crash in a new thread. If 
	the argument is an integer use the method that implies. 
	bit 0 = thread to crash in; 1 => this thread 
	bit 1 = crash method; 0 => indirect through null pointer; 1 => call exit */
/* InterpreterPrimitives>>#primitiveCrashVM */
EXPORT(sqInt)
primitiveCrashVM(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt crashInThisThread;
	sqInt obj;

	if ((((unsignedLongAt(GIV(stackPointer))) & 7) == 1)) {
		crashInThisThread = (unsignedLongAt(GIV(stackPointer))) >> 3;
	} else {
		/* begin booleanValueOf: */
		obj = unsignedLongAt(GIV(stackPointer));
		if (obj == GIV(trueObj)) {
			crashInThisThread = 1;
			goto l1;
		}
		if (obj == GIV(falseObj)) {
			crashInThisThread = 0;
			goto l1;
		}
		/* begin success: */
		{
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
		}
		/* end success: */
		crashInThisThread = null;
		l1:
		;
		/* end booleanValueOf: */
	}
	if (GIV(primFailCode) || (GIV(argumentCount) != 1)) {
		return (GIV(primFailCode) = PrimErrBadNumArgs);
	}
	crashInThisOrAnotherThread(crashInThisThread);
	/* begin pop: */
	GIV(stackPointer) += 1 * BytesPerWord;
	/* end pop: */
	return 0;
}
/*	Pass in a non-negative value to disable the architectures powermanager if 
	any, zero to enable. This is a named (not numbered) primitive in the null 
	module (ie the VM) */
/* InterpreterPrimitives>>#primitiveDisablePowerManager */
EXPORT(sqInt)
primitiveDisablePowerManager(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt integer;
	sqInt integerPointer;

	/* begin stackIntegerValue: */
	integerPointer = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((integerPointer & 7) == 1)) {
		integer = integerPointer >> 3;
		goto l2;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integer = 0;
		goto l2;
	}
	/* end checkedIntegerValueOf: */
	l2:
	;
	/* end stackIntegerValue: */
	if (!GIV(primFailCode)) {
		ioDisablePowerManager(integer);
		/* begin pop: */
		GIV(stackPointer) += 1 * BytesPerWord;
		/* end pop: */
	}
	return 0;
}
/* 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 l1;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerReceiver = 0;
		goto l1;
	}
	/* end checkedIntegerValueOf: */
	l1:
	;
	/* end stackIntegerValue: */
	/* begin stackIntegerValue: */
	integerPointer2 = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((integerPointer2 & 7) == 1)) {
		integerArgument = integerPointer2 >> 3;
		goto l2;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerArgument = 0;
		goto l2;
	}
	/* end checkedIntegerValueOf: */
	l2:
	;
	/* 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;

	pwr = 0;
	/* begin stackFloatValue: */
	rcvr = floatValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	/* 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) {
			int t1;
			int t2;

			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 l3;
				}
				rcvr = null;
				goto l3;
				/* end smallFloatValueOf: */
			}
			if ((tagBits == (smallIntegerTag())) && (((shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) rcvrOop ) << shift) ) ) >> shift) == rcvrOop))) {
				rcvr = ((double) (rcvrOop >> 3) );
				goto l3;
			}
		} else {
			if (((longAt(rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
				fetchFloatAtinto(rcvrOop + BaseHeaderSize, result);
				rcvr = result;
				goto l3;
			}
		}
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		rcvr = 0.0;
		l3:
		;
		/* end loadFloatOrIntFrom: */
		/* begin loadFloatOrIntFrom: */
		if (((tagBits2 = argOop & (tagMask()))) != 0) {
			int t1;
			int t2;

			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 l6;
				}
				arg = null;
				goto l6;
				/* end smallFloatValueOf: */
			}
			if ((tagBits2 == (smallIntegerTag())) && (((shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) argOop ) << shift2) ) ) >> shift2) == argOop))) {
				arg = ((double) (argOop >> 3) );
				goto l6;
			}
		} else {
			if (((longAt(argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
				fetchFloatAtinto(argOop + BaseHeaderSize, result2);
				arg = result2;
				goto l6;
			}
		}
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		arg = 0.0;
		l6:
		;
		/* 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 l2;
	}
	l2:
	;
	/* 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 fieldIndex1;
	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: */
		fieldIndex1 = ((VMBIGENDIAN)
			 ? 1
			 : 0);
		uint32AtPointerput((rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << 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;

	result = 0;
	result2 = 0;
	value = 0;
	value2 = 0;
	/* begin primitiveFloatDivide:byArg: */
	rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	argOop = unsignedLongAt(GIV(stackPointer));
	/* begin loadFloatOrIntFrom: */
	if (((tagBits = rcvrOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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 l3;
			}
			rcvr = null;
			goto l3;
			/* end smallFloatValueOf: */
		}
		if ((tagBits == (smallIntegerTag())) && (((shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) rcvrOop ) << shift) ) ) >> shift) == rcvrOop))) {
			rcvr = ((double) (rcvrOop >> 3) );
			goto l3;
		}
	} else {
		if (((longAt(rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(rcvrOop + BaseHeaderSize, result);
			rcvr = result;
			goto l3;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	rcvr = 0.0;
	l3:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	if (((tagBits2 = argOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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 l6;
			}
			arg = null;
			goto l6;
			/* end smallFloatValueOf: */
		}
		if ((tagBits2 == (smallIntegerTag())) && (((shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) argOop ) << shift2) ) ) >> shift2) == argOop))) {
			arg = ((double) (argOop >> 3) );
			goto l6;
		}
	} else {
		if (((longAt(argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(argOop + BaseHeaderSize, result2);
			arg = result2;
			goto l6;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	arg = 0.0;
	l6:
	;
	/* 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;

	result = 0;
	result2 = 0;
	value = 0;
	value2 = 0;
	/* begin primitiveFloatEqual:toArg: */
	rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	argOop = unsignedLongAt(GIV(stackPointer));
	/* begin loadFloatOrIntFrom: */
	if (((tagBits = rcvrOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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 l3;
			}
			rcvr = null;
			goto l3;
			/* end smallFloatValueOf: */
		}
		if ((tagBits == (smallIntegerTag())) && (((shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) rcvrOop ) << shift) ) ) >> shift) == rcvrOop))) {
			rcvr = ((double) (rcvrOop >> 3) );
			goto l3;
		}
	} else {
		if (((longAt(rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(rcvrOop + BaseHeaderSize, result);
			rcvr = result;
			goto l3;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	rcvr = 0.0;
	l3:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	if (((tagBits2 = argOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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 l6;
			}
			arg = null;
			goto l6;
			/* end smallFloatValueOf: */
		}
		if ((tagBits2 == (smallIntegerTag())) && (((shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) argOop ) << shift2) ) ) >> shift2) == argOop))) {
			arg = ((double) (argOop >> 3) );
			goto l6;
		}
	} else {
		if (((longAt(argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(argOop + BaseHeaderSize, result2);
			arg = result2;
			goto l6;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	arg = 0.0;
	l6:
	;
	/* 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;

	result = 0;
	result2 = 0;
	value = 0;
	value2 = 0;
	/* begin primitiveFloatGreaterOrEqual:toArg: */
	rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	argOop = unsignedLongAt(GIV(stackPointer));
	/* begin loadFloatOrIntFrom: */
	if (((tagBits = rcvrOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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 l3;
			}
			rcvr = null;
			goto l3;
			/* end smallFloatValueOf: */
		}
		if ((tagBits == (smallIntegerTag())) && (((shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) rcvrOop ) << shift) ) ) >> shift) == rcvrOop))) {
			rcvr = ((double) (rcvrOop >> 3) );
			goto l3;
		}
	} else {
		if (((longAt(rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(rcvrOop + BaseHeaderSize, result);
			rcvr = result;
			goto l3;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	rcvr = 0.0;
	l3:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	if (((tagBits2 = argOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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 l6;
			}
			arg = null;
			goto l6;
			/* end smallFloatValueOf: */
		}
		if ((tagBits2 == (smallIntegerTag())) && (((shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) argOop ) << shift2) ) ) >> shift2) == argOop))) {
			arg = ((double) (argOop >> 3) );
			goto l6;
		}
	} else {
		if (((longAt(argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(argOop + BaseHeaderSize, result2);
			arg = result2;
			goto l6;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	arg = 0.0;
	l6:
	;
	/* 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;

	result = 0;
	result2 = 0;
	value = 0;
	value2 = 0;
	/* begin primitiveFloatGreater:thanArg: */
	rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	argOop = unsignedLongAt(GIV(stackPointer));
	/* begin loadFloatOrIntFrom: */
	if (((tagBits = rcvrOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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 l3;
			}
			rcvr = null;
			goto l3;
			/* end smallFloatValueOf: */
		}
		if ((tagBits == (smallIntegerTag())) && (((shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) rcvrOop ) << shift) ) ) >> shift) == rcvrOop))) {
			rcvr = ((double) (rcvrOop >> 3) );
			goto l3;
		}
	} else {
		if (((longAt(rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(rcvrOop + BaseHeaderSize, result);
			rcvr = result;
			goto l3;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	rcvr = 0.0;
	l3:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	if (((tagBits2 = argOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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 l6;
			}
			arg = null;
			goto l6;
			/* end smallFloatValueOf: */
		}
		if ((tagBits2 == (smallIntegerTag())) && (((shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) argOop ) << shift2) ) ) >> shift2) == argOop))) {
			arg = ((double) (argOop >> 3) );
			goto l6;
		}
	} else {
		if (((longAt(argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(argOop + BaseHeaderSize, result2);
			arg = result2;
			goto l6;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	arg = 0.0;
	l6:
	;
	/* 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;

	result = 0;
	result2 = 0;
	value = 0;
	value2 = 0;
	/* begin primitiveFloatLessOrEqual:toArg: */
	rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	argOop = unsignedLongAt(GIV(stackPointer));
	/* begin loadFloatOrIntFrom: */
	if (((tagBits = rcvrOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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 l3;
			}
			rcvr = null;
			goto l3;
			/* end smallFloatValueOf: */
		}
		if ((tagBits == (smallIntegerTag())) && (((shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) rcvrOop ) << shift) ) ) >> shift) == rcvrOop))) {
			rcvr = ((double) (rcvrOop >> 3) );
			goto l3;
		}
	} else {
		if (((longAt(rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(rcvrOop + BaseHeaderSize, result);
			rcvr = result;
			goto l3;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	rcvr = 0.0;
	l3:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	if (((tagBits2 = argOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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 l6;
			}
			arg = null;
			goto l6;
			/* end smallFloatValueOf: */
		}
		if ((tagBits2 == (smallIntegerTag())) && (((shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) argOop ) << shift2) ) ) >> shift2) == argOop))) {
			arg = ((double) (argOop >> 3) );
			goto l6;
		}
	} else {
		if (((longAt(argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(argOop + BaseHeaderSize, result2);
			arg = result2;
			goto l6;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	arg = 0.0;
	l6:
	;
	/* 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;

	result = 0;
	result2 = 0;
	value = 0;
	value2 = 0;
	/* begin primitiveFloatLess:thanArg: */
	rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	argOop = unsignedLongAt(GIV(stackPointer));
	/* begin loadFloatOrIntFrom: */
	if (((tagBits = rcvrOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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 l3;
			}
			rcvr = null;
			goto l3;
			/* end smallFloatValueOf: */
		}
		if ((tagBits == (smallIntegerTag())) && (((shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) rcvrOop ) << shift) ) ) >> shift) == rcvrOop))) {
			rcvr = ((double) (rcvrOop >> 3) );
			goto l3;
		}
	} else {
		if (((longAt(rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(rcvrOop + BaseHeaderSize, result);
			rcvr = result;
			goto l3;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	rcvr = 0.0;
	l3:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	if (((tagBits2 = argOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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 l6;
			}
			arg = null;
			goto l6;
			/* end smallFloatValueOf: */
		}
		if ((tagBits2 == (smallIntegerTag())) && (((shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) argOop ) << shift2) ) ) >> shift2) == argOop))) {
			arg = ((double) (argOop >> 3) );
			goto l6;
		}
	} else {
		if (((longAt(argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(argOop + BaseHeaderSize, result2);
			arg = result2;
			goto l6;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	arg = 0.0;
	l6:
	;
	/* 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;

	result = 0;
	result2 = 0;
	value = 0;
	value2 = 0;
	/* begin primitiveFloatMultiply:byArg: */
	rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	argOop = unsignedLongAt(GIV(stackPointer));
	/* begin loadFloatOrIntFrom: */
	if (((tagBits = rcvrOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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 l3;
			}
			rcvr = null;
			goto l3;
			/* end smallFloatValueOf: */
		}
		if ((tagBits == (smallIntegerTag())) && (((shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) rcvrOop ) << shift) ) ) >> shift) == rcvrOop))) {
			rcvr = ((double) (rcvrOop >> 3) );
			goto l3;
		}
	} else {
		if (((longAt(rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(rcvrOop + BaseHeaderSize, result);
			rcvr = result;
			goto l3;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	rcvr = 0.0;
	l3:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	if (((tagBits2 = argOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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 l6;
			}
			arg = null;
			goto l6;
			/* end smallFloatValueOf: */
		}
		if ((tagBits2 == (smallIntegerTag())) && (((shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) argOop ) << shift2) ) ) >> shift2) == argOop))) {
			arg = ((double) (argOop >> 3) );
			goto l6;
		}
	} else {
		if (((longAt(argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(argOop + BaseHeaderSize, result2);
			arg = result2;
			goto l6;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	arg = 0.0;
	l6:
	;
	/* 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;

	result = 0;
	result2 = 0;
	value = 0;
	value2 = 0;
	/* begin primitiveFloatEqual:toArg: */
	rcvrOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	argOop = unsignedLongAt(GIV(stackPointer));
	/* begin loadFloatOrIntFrom: */
	if (((tagBits = rcvrOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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 l3;
			}
			rcvr = null;
			goto l3;
			/* end smallFloatValueOf: */
		}
		if ((tagBits == (smallIntegerTag())) && (((shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) rcvrOop ) << shift) ) ) >> shift) == rcvrOop))) {
			rcvr = ((double) (rcvrOop >> 3) );
			goto l3;
		}
	} else {
		if (((longAt(rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(rcvrOop + BaseHeaderSize, result);
			rcvr = result;
			goto l3;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	rcvr = 0.0;
	l3:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	if (((tagBits2 = argOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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 l6;
			}
			arg = null;
			goto l6;
			/* end smallFloatValueOf: */
		}
		if ((tagBits2 == (smallIntegerTag())) && (((shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) argOop ) << shift2) ) ) >> shift2) == argOop))) {
			arg = ((double) (argOop >> 3) );
			goto l6;
		}
	} else {
		if (((longAt(argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(argOop + BaseHeaderSize, result2);
			arg = result2;
			goto l6;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	arg = 0.0;
	l6:
	;
	/* 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) {
			int t1;
			int t2;

			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 l3;
				}
				rcvr = null;
				goto l3;
				/* end smallFloatValueOf: */
			}
			if ((tagBits == (smallIntegerTag())) && (((shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) rcvrOop ) << shift) ) ) >> shift) == rcvrOop))) {
				rcvr = ((double) (rcvrOop >> 3) );
				goto l3;
			}
		} else {
			if (((longAt(rcvrOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
				fetchFloatAtinto(rcvrOop + BaseHeaderSize, result);
				rcvr = result;
				goto l3;
			}
		}
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		rcvr = 0.0;
		l3:
		;
		/* end loadFloatOrIntFrom: */
		/* begin loadFloatOrIntFrom: */
		if (((tagBits2 = argOop & (tagMask()))) != 0) {
			int t1;
			int t2;

			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 l6;
				}
				arg = null;
				goto l6;
				/* end smallFloatValueOf: */
			}
			if ((tagBits2 == (smallIntegerTag())) && (((shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) argOop ) << shift2) ) ) >> shift2) == argOop))) {
				arg = ((double) (argOop >> 3) );
				goto l6;
			}
		} else {
			if (((longAt(argOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
				fetchFloatAtinto(argOop + BaseHeaderSize, result2);
				arg = result2;
				goto l6;
			}
		}
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		arg = 0.0;
		l6:
		;
		/* 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 */
	{
		sqInt i;

		for (i = 1; i <= MethodCacheSize; i += 1) {
			GIV(methodCache)[i] = 0;
		};
		GIV(lastMethodCacheProbeWrite) = 0;
	}
	unlinkAllSends();
	/* 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 address1;
	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 limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	sqInt oop;
	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 l1;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l1:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* end objectAfter:limit: */
	};
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
	/* begin flushMethodCache */
	{
		sqInt i;

		for (i = 1; i <= MethodCacheSize; i += 1) {
			GIV(methodCache)[i] = 0;
		};
		GIV(lastMethodCacheProbeWrite) = 0;
	}
	unlinkAllSends();
	/* end flushMethodCache */
	/* begin flushExternalPrimitiveTable */
	for (i2 = 0; i2 < MaxExternalPrimitiveTableSize; i2 += 1) {
		externalPrimitiveTable[i2] = 0;
	};
	GIV(externalPrimitiveTableFirstFreeIndex) = 0;
	/* end flushExternalPrimitiveTable */
	/* end flushExternalPrimitives */
}
/* InterpreterPrimitives>>#primitiveFormat */
static void
primitiveFormat(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	usqLong format;
	sqLong header;
	sqInt receiver;
	char *sp;

	receiver = unsignedLongAt(GIV(stackPointer));
	if (receiver & (tagMask())) {
		{
			/* begin primitiveFail */
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
			/* end primitiveFail */
			return;
		}
	}
	header = long64At(receiver);
	format = (((unsigned sqLong) header ) >> (formatShift())) & (formatMask());
	/* begin pop:thenPush: */
	unsignedLongAtput((sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((format << 3) | 1));
	GIV(stackPointer) = sp;
	/* end pop:thenPush: */
}
/*	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;

	trunc = 0;
	/* begin stackFloatValue: */
	rcvr = floatValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	/* 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 *cogMethod1;
	sqInt header;
	sqInt i;
	sqInt inInterpreter;
	sqInt inInterpreter1;
	sqInt methodHeader;
	sqInt methodHeader1;
	sqInt methodHeader3;
	sqInt methodHeader4;
	sqInt numArgs;
	sqInt numCopied;
	sqInt numCopied1;
	sqInt numTemps;
	sqInt object;
	sqInt object1;
	sqInt object11;
	sqInt object12;
	sqInt object2;
	sqInt object3;
	sqInt object4;
	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: */
			object3 = ceReturnToInterpreterPC();
			unsignedLongAtput((sp10 = GIV(stackPointer) - BytesPerWord), object3);
			GIV(stackPointer) = sp10;
			/* end push: */
		} else {
			/* begin push: */
			unsignedLongAtput((sp22 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
			GIV(stackPointer) = sp22;
			/* end push: */
		}
		/* end ensurePushedInstructionPointer */
		/* begin push: */
		object11 = ((sqInt) cogMethod ) + (fullBlockEntryOffset());
		unsignedLongAtput((sp32 = GIV(stackPointer) - BytesPerWord), object11);
		GIV(stackPointer) = sp32;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((sp42 = GIV(stackPointer) - BytesPerWord), blockClosure);
		GIV(stackPointer) = sp42;
		/* end push: */
		/* begin callEnilopmart: */
		ceCallCogCodePopReceiverReg();
		/* end callEnilopmart: */
		/* end executeFullCogBlock:closure:mayContextSwitch: */
		goto l9;
	}
	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(unsignedLongAt((closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ))))) {
					/* 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()))));
					cogMethod1 = ((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: */
						object4 = ceReturnToInterpreterPC();
						unsignedLongAtput((sp11 = GIV(stackPointer) - BytesPerWord), object4);
						GIV(stackPointer) = sp11;
						/* end push: */
					} else {
						/* begin push: */
						unsignedLongAtput((sp23 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
						GIV(stackPointer) = sp23;
						/* end push: */
					}
					/* end ensurePushedInstructionPointer */
					/* begin push: */
					object12 = ((sqInt) cogMethod1 ) + (fullBlockEntryOffset());
					unsignedLongAtput((sp33 = GIV(stackPointer) - BytesPerWord), object12);
					GIV(stackPointer) = sp33;
					/* end push: */
					/* begin push: */
					unsignedLongAtput((sp43 = GIV(stackPointer) - BytesPerWord), blockClosure);
					GIV(stackPointer) = sp43;
					/* end push: */
					/* begin callEnilopmart: */
					ceCallCogCodePopReceiverReg();
					/* end callEnilopmart: */
					/* end executeFullCogBlock:closure:mayContextSwitch: */
					goto l9;
				}
				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 (GIV(instructionPointer) == (ceReturnToInterpreterPC())) {
			GIV(instructionPointer) = unsignedLongAt(GIV(framePointer) + FoxIFSavedIP);
		}
	}
	assert(closureMethod == (fetchPointerofObject(FullClosureCompiledBlockIndex, blockClosure)));
	inInterpreter1 = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	numCopied1 = (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: */
	object1 = ((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), object1);
	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);
	}
	object2 = objOop;
	/* end followField:ofObject: */
	unsignedLongAtput((sp9 = GIV(stackPointer) - BytesPerWord), object2);
	GIV(stackPointer) = sp9;
	/* end push: */
	for (i = 0; i < numCopied1; 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));
	header = unsignedLongAt((closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	if (((header & 7) == 1)) {
		methodHeader1 = header;
	} else {
		assert(((usqInt) header ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) header ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		methodHeader1 = ((((CogMethod *) header ))->methodHeader);
	}
	/* end methodHeaderOf: */
	numTemps = (((usqInt) methodHeader1 ) >> MethodHeaderTempCountShift) & 0x3F;
	for (i = (numArgs + numCopied1) + 1; i <= numTemps; i += 1) {
		/* begin push: */
		unsignedLongAtput((sp3 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
		GIV(stackPointer) = sp3;
		/* end push: */
	};
	GIV(instructionPointer) = ((closureMethod + ((LiteralStart + ((assert(((methodHeader1 & 7) == 1)), (methodHeader1 >> 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(inInterpreter1, switched);
	goto l9;
	l9:
	;
	/* 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 *cogMethod1;
	sqInt header;
	sqInt i;
	sqInt inInterpreter;
	sqInt inInterpreter1;
	sqInt methodHeader;
	sqInt methodHeader1;
	sqInt methodHeader3;
	sqInt methodHeader4;
	sqInt numArgs;
	sqInt numCopied;
	sqInt numCopied1;
	sqInt numTemps;
	sqInt object;
	sqInt object1;
	sqInt object11;
	sqInt object12;
	sqInt object2;
	sqInt object3;
	sqInt object4;
	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: */
			object3 = ceReturnToInterpreterPC();
			unsignedLongAtput((sp10 = GIV(stackPointer) - BytesPerWord), object3);
			GIV(stackPointer) = sp10;
			/* end push: */
		} else {
			/* begin push: */
			unsignedLongAtput((sp22 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
			GIV(stackPointer) = sp22;
			/* end push: */
		}
		/* end ensurePushedInstructionPointer */
		/* begin push: */
		object11 = ((sqInt) cogMethod ) + (fullBlockNoContextSwitchEntryOffset());
		unsignedLongAtput((sp32 = GIV(stackPointer) - BytesPerWord), object11);
		GIV(stackPointer) = sp32;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((sp42 = GIV(stackPointer) - BytesPerWord), blockClosure);
		GIV(stackPointer) = sp42;
		/* end push: */
		/* begin callEnilopmart: */
		ceCallCogCodePopReceiverReg();
		/* end callEnilopmart: */
		/* end executeFullCogBlock:closure:mayContextSwitch: */
		goto l9;
	}
	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(unsignedLongAt((closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ))))) {
					/* 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()))));
					cogMethod1 = ((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: */
						object4 = ceReturnToInterpreterPC();
						unsignedLongAtput((sp11 = GIV(stackPointer) - BytesPerWord), object4);
						GIV(stackPointer) = sp11;
						/* end push: */
					} else {
						/* begin push: */
						unsignedLongAtput((sp23 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
						GIV(stackPointer) = sp23;
						/* end push: */
					}
					/* end ensurePushedInstructionPointer */
					/* begin push: */
					object12 = ((sqInt) cogMethod1 ) + (fullBlockNoContextSwitchEntryOffset());
					unsignedLongAtput((sp33 = GIV(stackPointer) - BytesPerWord), object12);
					GIV(stackPointer) = sp33;
					/* end push: */
					/* begin push: */
					unsignedLongAtput((sp43 = GIV(stackPointer) - BytesPerWord), blockClosure);
					GIV(stackPointer) = sp43;
					/* end push: */
					/* begin callEnilopmart: */
					ceCallCogCodePopReceiverReg();
					/* end callEnilopmart: */
					/* end executeFullCogBlock:closure:mayContextSwitch: */
					goto l9;
				}
				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 (GIV(instructionPointer) == (ceReturnToInterpreterPC())) {
			GIV(instructionPointer) = unsignedLongAt(GIV(framePointer) + FoxIFSavedIP);
		}
	}
	assert(closureMethod == (fetchPointerofObject(FullClosureCompiledBlockIndex, blockClosure)));
	inInterpreter1 = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	numCopied1 = (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: */
	object1 = ((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), object1);
	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);
	}
	object2 = objOop;
	/* end followField:ofObject: */
	unsignedLongAtput((sp9 = GIV(stackPointer) - BytesPerWord), object2);
	GIV(stackPointer) = sp9;
	/* end push: */
	for (i = 0; i < numCopied1; 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));
	header = unsignedLongAt((closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	if (((header & 7) == 1)) {
		methodHeader1 = header;
	} else {
		assert(((usqInt) header ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) header ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		methodHeader1 = ((((CogMethod *) header ))->methodHeader);
	}
	/* end methodHeaderOf: */
	numTemps = (((usqInt) methodHeader1 ) >> MethodHeaderTempCountShift) & 0x3F;
	for (i = (numArgs + numCopied1) + 1; i <= numTemps; i += 1) {
		/* begin push: */
		unsignedLongAtput((sp3 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
		GIV(stackPointer) = sp3;
		/* end push: */
	};
	GIV(instructionPointer) = ((closureMethod + ((LiteralStart + ((assert(((methodHeader1 & 7) == 1)), (methodHeader1 >> 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(inInterpreter1, switched);
	goto l9;
	l9:
	;
	/* 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 *cogMethod1;
	sqInt header;
	sqInt i;
	int index;
	sqInt inInterpreter;
	sqInt inInterpreter1;
	sqInt methodHeader;
	sqInt methodHeader1;
	sqInt methodHeader3;
	sqInt methodHeader4;
	sqInt numArgs;
	sqInt numCopied;
	sqInt numCopied1;
	usqInt numSlots;
	sqInt numTemps;
	sqInt object;
	sqInt object1;
	sqInt object11;
	sqInt object12;
	sqInt object2;
	sqInt object3;
	sqInt object4;
	sqInt object5;
	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: */
			object3 = ceReturnToInterpreterPC();
			unsignedLongAtput((sp10 = GIV(stackPointer) - BytesPerWord), object3);
			GIV(stackPointer) = sp10;
			/* end push: */
		} else {
			/* begin push: */
			unsignedLongAtput((sp22 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
			GIV(stackPointer) = sp22;
			/* end push: */
		}
		/* end ensurePushedInstructionPointer */
		/* begin push: */
		object11 = ((sqInt) cogMethod ) + (fullBlockEntryOffset());
		unsignedLongAtput((sp32 = GIV(stackPointer) - BytesPerWord), object11);
		GIV(stackPointer) = sp32;
		/* end push: */
		/* begin push: */
		unsignedLongAtput((sp42 = GIV(stackPointer) - BytesPerWord), blockClosure);
		GIV(stackPointer) = sp42;
		/* end push: */
		/* begin callEnilopmart: */
		ceCallCogCodePopReceiverReg();
		/* end callEnilopmart: */
		/* 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(unsignedLongAt((closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ))))) {
					/* 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()))));
					cogMethod1 = ((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: */
						object4 = ceReturnToInterpreterPC();
						unsignedLongAtput((sp11 = GIV(stackPointer) - BytesPerWord), object4);
						GIV(stackPointer) = sp11;
						/* end push: */
					} else {
						/* begin push: */
						unsignedLongAtput((sp23 = GIV(stackPointer) - BytesPerWord), GIV(instructionPointer));
						GIV(stackPointer) = sp23;
						/* end push: */
					}
					/* end ensurePushedInstructionPointer */
					/* begin push: */
					object12 = ((sqInt) cogMethod1 ) + (fullBlockEntryOffset());
					unsignedLongAtput((sp33 = GIV(stackPointer) - BytesPerWord), object12);
					GIV(stackPointer) = sp33;
					/* end push: */
					/* begin push: */
					unsignedLongAtput((sp43 = GIV(stackPointer) - BytesPerWord), blockClosure);
					GIV(stackPointer) = sp43;
					/* end push: */
					/* begin callEnilopmart: */
					ceCallCogCodePopReceiverReg();
					/* end callEnilopmart: */
					/* 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 (GIV(instructionPointer) == (ceReturnToInterpreterPC())) {
			GIV(instructionPointer) = unsignedLongAt(GIV(framePointer) + FoxIFSavedIP);
		}
	}
	assert(closureMethod == (fetchPointerofObject(FullClosureCompiledBlockIndex, blockClosure)));
	inInterpreter1 = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	numCopied1 = (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: */
	object1 = ((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), object1);
	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);
	}
	object2 = objOop;
	/* end followField:ofObject: */
	unsignedLongAtput((sp9 = GIV(stackPointer) - BytesPerWord), object2);
	GIV(stackPointer) = sp9;
	/* end push: */
	for (i = 0; i < numCopied1; i += 1) {
		/* begin push: */
		object5 = unsignedLongAt((blockClosure + BaseHeaderSize) + ((sqInt) (((usqInt) (i + FullClosureFirstCopiedValueIndex) ) << (shiftForWord())) ));
		unsignedLongAtput((sp2 = GIV(stackPointer) - BytesPerWord), object5);
		GIV(stackPointer) = sp2;
		/* end push: */
	};
	assert(frameIsBlockActivation(GIV(framePointer)));
	assert(!(frameHasContext(GIV(framePointer))));
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(closureMethod));
	header = unsignedLongAt((closureMethod + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	if (((header & 7) == 1)) {
		methodHeader1 = header;
	} else {
		assert(((usqInt) header ) < ((GIV(memoryMap)->newSpaceStart)));
		assert((((((CogMethod *) header ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
		methodHeader1 = ((((CogMethod *) header ))->methodHeader);
	}
	/* end methodHeaderOf: */
	numTemps = (((usqInt) methodHeader1 ) >> MethodHeaderTempCountShift) & 0x3F;
	for (i = (numArgs + numCopied1) + 1; i <= numTemps; i += 1) {
		/* begin push: */
		unsignedLongAtput((sp3 = GIV(stackPointer) - BytesPerWord), GIV(nilObj));
		GIV(stackPointer) = sp3;
		/* end push: */
	};
	GIV(instructionPointer) = ((closureMethod + ((LiteralStart + ((assert(((methodHeader1 & 7) == 1)), (methodHeader1 >> 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(inInterpreter1, switched);
	goto l11;
	l11:
	;
	/* 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 attr;
	sqInt classObj;
	sqInt integerPointer;
	sqInt s;
	char *sp;
	sqInt sz;

	sz = 0;
	/* begin stackIntegerValue: */
	integerPointer = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((integerPointer & 7) == 1)) {
		attr = integerPointer >> 3;
		goto l1;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		attr = 0;
		goto l1;
	}
	/* end checkedIntegerValueOf: */
	l1:
	;
	/* end stackIntegerValue: */
	if (!GIV(primFailCode)) {
		sz = attributeSize(attr);
	}
	if (!GIV(primFailCode)) {
		/* begin instantiateClass:indexableSize: */
		classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteString ) << (shiftForWord())) ));
		s = instantiateClassindexableSizeisPinnedisOldSpace(classObj, sz, 0, 0);
		/* end instantiateClass:indexableSize: */
		getAttributeIntoLength(attr, 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 *//*	Primitive. Answer the VM's current log directory */
/* InterpreterPrimitives>>#primitiveGetLogDirectory */
EXPORT(sqInt)
primitiveGetLogDirectory(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt classObj;
	sqInt i;
	char *ptr;
	char *sp;
	sqInt stringOop;
	sqInt sz;

	ptr = ioGetLogDirectory();
	if (ptr == null) {
		/* begin success: */
		{
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
		}
		return null;
		/* end success: */
	}
	sz = strlen(ptr);
	/* begin instantiateClass:indexableSize: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteString ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	stringOop = instantiateClassindexableSizeisPinnedisOldSpace(classObj, sz, 0, 0);
	/* end instantiateClass:indexableSize: */
	for (i = 0; i < sz; i += 1) {
		byteAtput((stringOop + BaseHeaderSize) + i, ptr[i]);
	};
	/* begin pop:thenPush: */
	unsignedLongAtput((sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), stringOop);
	GIV(stackPointer) = sp;
	/* end pop:thenPush: */
	return 0;
}
/*	Primitive. Answer the OS window's label */
/* InterpreterPrimitives>>#primitiveGetWindowLabel */
EXPORT(sqInt)
primitiveGetWindowLabel(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt classObj;
	sqInt i;
	sqInt labelOop;
	char *ptr;
	char *sp;
	sqInt sz;

	ptr = ioGetWindowLabel();
	if (ptr == null) {
		/* begin success: */
		{
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
		}
		return null;
		/* end success: */
	}
	sz = strlen(ptr);
	/* begin instantiateClass:indexableSize: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	classObj = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteString ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	labelOop = instantiateClassindexableSizeisPinnedisOldSpace(classObj, sz, 0, 0);
	/* end instantiateClass:indexableSize: */
	for (i = 0; i < sz; i += 1) {
		byteAtput((labelOop + BaseHeaderSize) + i, ptr[i]);
	};
	/* begin pop:thenPush: */
	unsignedLongAtput((sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), labelOop);
	GIV(stackPointer) = sp;
	/* end pop:thenPush: */
	return 0;
}
/*	Primitive. Answer the OS window's size (extent) */
/* InterpreterPrimitives>>#primitiveGetWindowSize */
EXPORT(sqInt)
primitiveGetWindowSize(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt classFormat;
	sqInt classIndex;
	sqInt classObj;
	sqInt h;
	usqInt newObj;
	usqInt numBytes;
	sqInt numSlots;
	sqInt object;
	sqInt objFormat;
	usqInt pointResult;
	char *sp;
	sqInt w;

	w = ioGetWindowWidth();
	h = ioGetWindowHeight();
	/* begin pop: */
	GIV(stackPointer) += (GIV(argumentCount) + 1) * BytesPerWord;
	/* end pop: */
	/* begin push: */
	/* begin makePointwithxValue:yValue: */
	/* 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 l3;
		}
	}
	long64Atput(newObj, ((((usqLong) numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) objFormat ) << (formatShift())) )) + classIndex);
	GIV(freeStart) += numBytes;
	pointResult = newObj;
	/* end allocateSmallNewSpaceSlots:format:classIndex: */
	/* end eeInstantiateSmallClassIndex:format:numSlots: */
	l3:
	;
	/* end eeInstantiateSmallClass:numSlots: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	assert(!(isOopForwarded(pointResult)));
	longAtput((pointResult + BaseHeaderSize) + ((sqInt) (((usqInt) XIndex ) << (shiftForWord())) ), ((((usqInt) w ) << 3) | 1));
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	assert(!(isOopForwarded(pointResult)));
	longAtput((pointResult + BaseHeaderSize) + ((sqInt) (((usqInt) YIndex ) << (shiftForWord())) ), ((((usqInt) h ) << 3) | 1));
	/* end storePointerUnchecked:ofObject:withValue: */
	object = pointResult;
	/* end makePointwithxValue:yValue: */
	unsignedLongAtput((sp = GIV(stackPointer) - BytesPerWord), object);
	GIV(stackPointer) = sp;
	/* end push: */
	return 0;
}
/* 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 l3;
		}
		/* begin isClassOfNonImm:equalTo:compactClassIndex: */
		assert(!(isImmediate(value)));
		/* begin classIndexOf: */
		ccIndex = (longAt(value)) & (classIndexMask());
		/* end classIndexOf: */
		{
			ok = ClassLargePositiveIntegerCompactIndex == ccIndex;
			goto l3;
		}
		/* end isClassOfNonImm:equalTo:compactClassIndex: */
		l3:
		;
		/* 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 l1;
	}
	l1:
	;
	/* 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 l1;
	}
	l1:
	;
	/* 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 oop2;
	sqInt oop3;
	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: */
				oop2 = unsignedLongAt((rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) index ) << (shiftForWord())) ));
				/* begin pop:thenPush: */
				unsignedLongAtput((sp3 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), oop2);
				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: */
			oop3 = unsignedLongAt((rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (index + numFixed) ) << (shiftForWord())) ));
			/* begin pop:thenPush: */
			unsignedLongAtput((sp4 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), oop3);
			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)))) {
					int t0;
					int t1;

					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 l22;
				}
				if (valueOop & (tagMask())) {
					goto l22;
				}
				if (!(rcvr >= 0x20000000000LL)) {
					goto l22;
				}
				if (valueOop >= 0x20000000000LL) {
					goto l22;
				}
				if ((valueOop >= GIV(nilObj)) && (valueOop <= GIV(trueObj))) {
					goto l22;
				}
				if (!(valueOop >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l22;
				}
				remember(getFromPermToNewSpaceRememberedSet(), rcvr);
				l22:
				;
				/* 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)))) {
				int t0;
				int t1;

				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 l25;
			}
			if (valueOop & (tagMask())) {
				goto l25;
			}
			if (!(rcvr >= 0x20000000000LL)) {
				goto l25;
			}
			if (valueOop >= 0x20000000000LL) {
				goto l25;
			}
			if ((valueOop >= GIV(nilObj)) && (valueOop <= GIV(trueObj))) {
				goto l25;
			}
			if (!(valueOop >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l25;
			}
			remember(getFromPermToNewSpaceRememberedSet(), rcvr);
			l25:
			;
			/* 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;

	nArgs = 0;
	savedFramePointer = ((char *) 0 );
	savedStackPointer = ((char *) 0 );
	/* begin eeInstantiateClassIndex:format:numSlots: */
	assert((GIV(argumentCount) >= 0) && ((knownClassAtIndex(ClassArrayCompactIndex)) != GIV(nilObj)));
	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) {
		int t18;

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

			executeQuickPrimitive();
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), inInterpreter);
			/* end returnToExecutive: */
			goto l9;
		}
		/* 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) {
			int t0;
			int t1;

			if (((freeStart()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart())) != (freeStart()))) {
				/* 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 l10;
		l10:
		;
		/* end slowPrimitiveResponse */
		if (succeeded) {
			sqInt t1;

			/* begin returnToExecutive: */
			returntoExecutive(popStack(), inInterpreter);
			/* end returnToExecutive: */
			goto l9;
		}
	}
	{
		{
			/* 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();
	}
	l9:
	;
	/* 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: */
}
/*	Primitive. Answer whether the OS window is currently partially or fully 
	obscured.  */
/* InterpreterPrimitives>>#primitiveIsWindowObscured */
EXPORT(sqInt)
primitiveIsWindowObscured(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt object;
	char *sp;
	sqInt trueOrFalse;

	/* begin pop: */
	GIV(stackPointer) += (GIV(argumentCount) + 1) * BytesPerWord;
	/* end pop: */
	/* begin pushBool: */
	trueOrFalse = ioIsWindowObscured();
	/* begin push: */
	object = ((trueOrFalse)
		 ? GIV(trueObj)
		 : GIV(falseObj));
	unsignedLongAtput((sp = GIV(stackPointer) - BytesPerWord), object);
	GIV(stackPointer) = sp;
	/* end push: */
	/* end pushBool: */
	return 0;
}
/* 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 l2;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		index = 0;
		goto l2;
	}
	/* end checkedIntegerValueOf: */
	l2:
	;
	/* 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 l2;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		index = 0;
		goto l2;
	}
	/* end checkedIntegerValueOf: */
	l2:
	;
	/* 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)))) {
			int t0;
			int t1;

			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 l4;
		}
		if (arg & (tagMask())) {
			goto l4;
		}
		if (!(GIV(specialObjectsOop) >= 0x20000000000LL)) {
			goto l4;
		}
		if (arg >= 0x20000000000LL) {
			goto l4;
		}
		if ((arg >= GIV(nilObj)) && (arg <= GIV(trueObj))) {
			goto l4;
		}
		if (!(arg >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l4;
		}
		remember(getFromPermToNewSpaceRememberedSet(), GIV(specialObjectsOop));
		l4:
		;
		/* 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 l2;
		}
	}
	long64Atput(newObj, ((((usqLong) numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) objFormat ) << (formatShift())) )) + classIndex);
	GIV(freeStart) += numBytes;
	pt = newObj;
	/* end allocateSmallNewSpaceSlots:format:classIndex: */
	/* end eeInstantiateSmallClassIndex:format:numSlots: */
	l2:
	;
	/* 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 l1;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerRcvr = 0;
		goto l1;
	}
	/* end checkedIntegerValueOf: */
	l1:
	;
	/* end stackIntegerValue: */
	/* begin stackIntegerValue: */
	integerPointer2 = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((integerPointer2 & 7) == 1)) {
		integerArg = integerPointer2 >> 3;
		goto l2;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerArg = 0;
		goto l2;
	}
	/* end checkedIntegerValueOf: */
	l2:
	;
	/* 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;
	sqInt reasonCode;
	char *sp;

	{
		/* begin instantiateClass: */
		classObj = unsignedLongAt(GIV(stackPointer));
		obj = instantiateClassisPinnedisOldSpace(classObj, 0, 0);
		/* end instantiateClass: */
		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: */
		}
	}
}
/* 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 l9;
	}
	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 l9;
	}
	if (numSlots > (((GIV(maxSlotsForNewSpaceAlloc) == 0)
		 ? (/* begin fixedFieldsOfClassFormatMask */ (1U << (fixedFieldsFieldWidth())) - 1 /* end fixedFieldsOfClassFormatMask */)
		 : GIV(maxSlotsForNewSpaceAlloc)))) {
		if (numSlots > 0x10000000000LL) {
			theMethod = null;
			goto l9;
		}
		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 l7;
			}
			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 l7;
			}
		}
		newObj2 = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(GIV(freeStart), numSlots, instSpec, classIndex, 0);
		assert((numBytes % (allocationUnit())) == 0);
		assert((newObj2 % (allocationUnit())) == 0);
		GIV(freeStart) += numBytes;
		newObj = newObj2;
		l7:
		;
		/* 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;
	l9:
	;
	/* 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)))) {
			int t0;
			int t1;

			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 l3;
		}
		if (GIV(nilObj) & (tagMask())) {
			goto l3;
		}
		if (!(theMethod >= 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(), theMethod);
		l3:
		;
		/* 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 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 l4;
	}
	l4:
	;
	/* 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: */
	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 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>>#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 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 l4;
	}
	l4:
	;
	/* 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: */
	{
		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 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 l4;
	}
	l4:
	;
	/* 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: */
	{
		/* 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 l2;
				}
				flag("endianness");
				followingWord = unsignedLongAt(followingWordAddress);
				actualObj = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
					 ? followingWordAddress + BaseHeaderSize
					 : followingWordAddress);
				l2:
				;
				/* end objectAfter:limit: */
				if (!(oopisLessThan(actualObj, GIV(freeStart)))) 
					break;
				if (classIndex == ((longAt(actualObj)) & (classIndexMask()))) {
					subsequentObject = actualObj;
					goto l6;
				}
			};
			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 l4;
				}
				flag("endianness");
				followingWord2 = unsignedLongAt(followingWordAddress2);
				actualObj = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
					 ? followingWordAddress2 + BaseHeaderSize
					 : followingWordAddress2);
				l4:
				;
				/* end objectAfter:limit: */
				if (!(oopisLessThan(actualObj, GIV(pastSpaceStart)))) 
					break;
				if (classIndex == ((longAt(actualObj)) & (classIndexMask()))) {
					subsequentObject = actualObj;
					goto l6;
				}
			};
			actualObj = GIV(nilObj);
		}
		while (1) {
			/* begin objectAfter:limit: */
			limit = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			followingWordAddress3 = addressAfter(actualObj);
			if (oopisGreaterThanOrEqualTo(followingWordAddress3, limit)) {
				actualObj = limit;
				goto l5;
			}
			flag("endianness");
			followingWord3 = unsignedLongAt(followingWordAddress3);
			actualObj = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress3 + BaseHeaderSize
				 : followingWordAddress3);
			l5:
			;
			/* end objectAfter:limit: */
			if (!(oopisLessThan(actualObj, (GIV(memoryMap)->oldSpaceEnd)))) 
				break;
			if (classIndex == ((longAt(actualObj)) & (classIndexMask()))) {
				subsequentObject = actualObj;
				goto l6;
			}
		};
		subsequentObject = null;
		l6:
		;
		/* 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: */
}
/*	primitivePathTo: anObject using: stack <Array> followWeak: boolean 
	Answer a path to anObject from the root that does not pass through 
	the current context */
/* InterpreterPrimitives>>#primitivePathToUsing */
EXPORT(sqInt)
primitivePathToUsing(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt current;
	sqInt err;
	sqInt fmt;
	sqInt fmt1;
	sqInt fmt2;
	sqInt followWeak;
	usqInt freeStartAtStart;
	sqInt goal;
	sqInt i;
	sqInt i2;
	sqInt iLimiT;
	sqInt iLimiT1;
	sqInt index;
	sqInt methodField;
	sqInt next;
	usqInt numSlots;
	usqInt numSlots2;
	usqInt numSlots22;
	usqInt numSlots23;
	usqInt numSlots3;
	usqInt numSlots4;
	sqInt path;
	char *sp;
	sqInt stack;
	int stackp;
	sqInt stackSize;
	char *theSP;

	err = 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 (!(GIV(argumentCount) >= 2)) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadNumArgs);
		/* end primitiveFailFor: */
	}
	if (!(((unsignedLongAt(GIV(stackPointer))) == GIV(trueObj)) || ((unsignedLongAt(GIV(stackPointer))) == GIV(falseObj)))) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadArgument);
		/* end primitiveFailFor: */
	}
	/* begin pathTo:using:followWeak: */
	goal = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	stack = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	followWeak = (unsignedLongAt(GIV(stackPointer))) == GIV(trueObj);
	if (!(((stack & (tagMask())) == 0) && (((((usqInt) (longAt(stack)) ) >> (formatShift())) & (formatMask())) == 2))) {
		err = PrimErrBadArgument;
		goto l9;
	}
	assert(allObjectsUnmarked());
	freeStartAtStart = freeStart();
	beRootIfOld(stack);
	/* begin lengthOf:format: */
	fmt1 = (((usqInt) (longAt(stack)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOfAny: */
	numSlots22 = byteAt(stack + 7);
	numSlots3 = ((numSlots22 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(stack - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : numSlots22);
	/* end numSlotsOfAny: */
	if (fmt1 <= 5) {
		stackSize = numSlots3;
		goto l6;
	}
	if (fmt1 >= (firstByteFormat())) {
		stackSize = (numSlots3 << (shiftForWord())) - (fmt1 & 7);
		goto l6;
	}
	if (fmt1 >= (firstShortFormat())) {
		stackSize = (numSlots3 << ((shiftForWord()) - 1)) - (fmt1 & 3);
		goto l6;
	}
	if (fmt1 >= (firstLongFormat())) {
		stackSize = (numSlots3 << ((shiftForWord()) - 2)) - (fmt1 & 1);
		goto l6;
	}
	if (fmt1 == (sixtyFourBitIndexableFormat())) {
		stackSize = numSlots3;
		goto l6;
	}
	stackSize = 0;
	l6:
	;
	/* end lengthOf:format: */
	/* begin mark: */
	/* begin setIsMarkedOf:to: */
	assert(!(isFreeObject(stack)));
	unsignedLongAtput(stack, (unsignedLongAt(stack)) | (1ULL << (markedBitFullShift())));
	/* end setIsMarkedOf:to: */
	/* end mark: */
	current = GIV(specialObjectsOop);
	/* begin mark: */
	/* begin setIsMarkedOf:to: */
	assert(!(isFreeObject(current)));
	unsignedLongAtput(current, (unsignedLongAt(current)) | (1ULL << (markedBitFullShift())));
	/* end setIsMarkedOf:to: */
	/* end mark: */
	/* begin lengthOf:format: */
	fmt2 = (((usqInt) (longAt(current)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOfAny: */
	numSlots23 = byteAt(current + 7);
	numSlots4 = ((numSlots23 == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(current - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : numSlots23);
	/* end numSlotsOfAny: */
	if (fmt2 <= 5) {
		index = numSlots4;
		goto l8;
	}
	if (fmt2 >= (firstByteFormat())) {
		index = (numSlots4 << (shiftForWord())) - (fmt2 & 7);
		goto l8;
	}
	if (fmt2 >= (firstShortFormat())) {
		index = (numSlots4 << ((shiftForWord()) - 1)) - (fmt2 & 3);
		goto l8;
	}
	if (fmt2 >= (firstLongFormat())) {
		index = (numSlots4 << ((shiftForWord()) - 2)) - (fmt2 & 1);
		goto l8;
	}
	if (fmt2 == (sixtyFourBitIndexableFormat())) {
		index = numSlots4;
		goto l8;
	}
	index = 0;
	l8:
	;
	/* end lengthOf:format: */
	stackp = 0;
	while (1) {
		while (((index -= 1)) >= -1) {
			if (((((usqInt) current ) & (BytesPerWord - 1)) == 0) && ((((usqInt) current ) >= ((usqInt) (GIV(stackBasePlus1) - 1) )) && (((usqInt) current ) <= ((usqInt) GIV(pages) )))) {
				if (index >= 0) {
					next = fieldofFrame(index, ((char *) current ));
				} else {
					next = GIV(nilObj);
				}
			} else {
				if (index >= 0) {
					if (((longAt(current)) & (classIndexMask())) == ClassMethodContextCompactIndex) {
						next = fieldOrSenderFPofContext(index, current);
					} else {
						next = unsignedLongAt((current + BaseHeaderSize) + ((sqInt) (((usqInt) index ) << (shiftForWord())) ));
					}
				} else {
					next = fetchClassOfNonImm(current);
				}
			}
			if (((((usqInt) next ) & (BytesPerWord - 1)) == 0) && ((((usqInt) next ) >= ((usqInt) (GIV(stackBasePlus1) - 1) )) && (((usqInt) next ) <= ((usqInt) GIV(pages) )))) {
				assert(isFrameonPage(((char *) next ), stackPageFor(((char *) next ))));
			} else {
				if (next >= (startOfObjectMemory(getMemoryMap()))) {
					assert(checkOkayOop(next));
				}
			}
			if (next == goal) {
				assert(freeStartAtStart == (freeStart()));
				unmarkAfterPathTo();
				/* begin storePointer:ofObject:withValue: */
				assert(!(isForwarded(stack)));
				if (((stack & (tagMask())) == 0) && ((stack & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
					int t0;
					int t1;

					if (((current & (tagMask())) == 0) && (((current & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (current >= ((GIV(memoryMap)->newSpaceStart))))) {
						/* begin possibleOldObjectStoreInto: */
						if (!(((((usqInt) (long64At(stack)) ) >> (rememberedBitShift())) & 1) != 0)) {
							remember(GIV(fromOldSpaceRememberedSet), stack);
						}
						/* end possibleOldObjectStoreInto: */
					}
				}
				/* begin possiblePermObjectStoreInto:value: */
				if (((((usqInt) (long64At(stack)) ) >> (rememberedBitShift())) & 1) != 0) {
					goto l1;
				}
				if (current & (tagMask())) {
					goto l1;
				}
				if (!(stack >= 0x20000000000LL)) {
					goto l1;
				}
				if (current >= 0x20000000000LL) {
					goto l1;
				}
				if ((current >= GIV(nilObj)) && (current <= GIV(trueObj))) {
					goto l1;
				}
				if (!(current >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l1;
				}
				remember(getFromPermToNewSpaceRememberedSet(), stack);
				l1:
				;
				/* end possiblePermObjectStoreInto:value: */
				unsignedLongAtput((stack + BaseHeaderSize) + ((sqInt) (((usqInt) stackp ) << (shiftForWord())) ), current);
				/* end storePointer:ofObject:withValue: */
				pruneStackstackp(stack, stackp);
				err = 0;
				goto l9;
			}
			if (((next & (smallIntegerTag())) == 0) && (((((((usqInt) next ) & (BytesPerWord - 1)) == 0) && ((((usqInt) next ) >= ((usqInt) (GIV(stackBasePlus1) - 1) )) && (((usqInt) next ) <= ((usqInt) GIV(pages) ))))
				 ? !(frameIsMarked(next))
				 : (next >= (startOfObjectMemory(getMemoryMap()))) && ((!(((((usqInt) (longAt(next)) ) >> (markedBitFullShift())) & 1) != 0)) && (((((next & (tagMask())) == 0) && (((((usqInt) (longAt(next)) ) >> (formatShift())) & (formatMask())) <= 5)) || (((((usqInt) (longAt(next)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat()))) && (followWeak || (!(isWeakFormat((((usqInt) (longAt(next)) ) >> (formatShift())) & (formatMask())))))))))) {
				if ((stackp + 2) > stackSize) {
					assert(freeStartAtStart == (freeStart()));
					unmarkAfterPathTo();
					/* begin nilFieldsOf: */
					for (i = 0, iLimiT = (numSlotsOf(stack)) - 1; i <= iLimiT; i += 1) {
						assert(!(isOopForwarded(stack)));
						longAtput((stack + BaseHeaderSize) + ((sqInt) (((usqInt) i ) << (shiftForWord())) ), GIV(nilObj));
					};
					/* end nilFieldsOf: */
					err = PrimErrBadIndex;
					goto l9;
				}
				{
					{
						assert(!(isOopForwarded(stack)));
						longAtput((stack + BaseHeaderSize) + ((sqInt) (((usqInt) stackp ) << (shiftForWord())) ), current);
					}
					assert(!(isOopForwarded(stack)));
					longAtput((stack + BaseHeaderSize) + ((sqInt) (((usqInt) (stackp + 1) ) << (shiftForWord())) ), ((((usqInt) index ) << 3) | 1));
				}
				stackp += 2;
				if (((((usqInt) ((char *) next ) ) & (BytesPerWord - 1)) == 0) && ((((usqInt) ((char *) next ) ) >= ((usqInt) (GIV(stackBasePlus1) - 1) )) && (((usqInt) ((char *) next ) ) <= ((usqInt) GIV(pages) )))) {
					/* begin markFrame: */
					methodField = unsignedLongAt(next + FoxMethod);
					if (((usqInt) methodField ) < (startOfObjectMemory(getMemoryMap()))) {
						unsignedLongAtput(next + FoxMethod, methodField | 4);
					} else {
						unsignedLongAtput(next + FoxIFrameFlags, (longAt(next + FoxIFrameFlags)) | 2);
					}
					/* end markFrame: */
					index = CtxtTempFrameStart + (stackPointerIndexForFrame(((char *) next )));
				} else {
					/* begin mark: */
					/* begin setIsMarkedOf:to: */
					assert(!(isFreeObject(next)));
					unsignedLongAtput(next, (unsignedLongAt(next)) | (1ULL << (markedBitFullShift())));
					/* end setIsMarkedOf:to: */
					/* end mark: */
					if (((((usqInt) (longAt(next)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())) {
						index = (literalCountOfMethodHeader(methodHeaderOf(next))) + LiteralStart;
					} else {
						/* begin lengthOf:format: */
						fmt = (((usqInt) (longAt(next)) ) >> (formatShift())) & (formatMask());
						/* begin numSlotsOfAny: */
						numSlots2 = byteAt(next + 7);
						numSlots = ((numSlots2 == (numSlotsMask()))
							 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(next - BaseHeaderSize)) ) << 8) ) ) ) >> 8
							 : numSlots2);
						/* end numSlotsOfAny: */
						if (fmt <= 5) {
							index = numSlots;
							goto l4;
						}
						if (fmt >= (firstByteFormat())) {
							index = (numSlots << (shiftForWord())) - (fmt & 7);
							goto l4;
						}
						if (fmt >= (firstShortFormat())) {
							index = (numSlots << ((shiftForWord()) - 1)) - (fmt & 3);
							goto l4;
						}
						if (fmt >= (firstLongFormat())) {
							index = (numSlots << ((shiftForWord()) - 2)) - (fmt & 1);
							goto l4;
						}
						if (fmt == (sixtyFourBitIndexableFormat())) {
							index = numSlots;
							goto l4;
						}
						index = 0;
						l4:
						;
						/* end lengthOf:format: */
					}
				}
				current = next;
			}
		};
		if (current == GIV(specialObjectsOop)) {
			assert(freeStartAtStart == (freeStart()));
			unmarkAfterPathTo();
			/* begin nilFieldsOf: */
			for (i2 = 0, iLimiT1 = (numSlotsOf(stack)) - 1; i2 <= iLimiT1; i2 += 1) {
				assert(!(isOopForwarded(stack)));
				longAtput((stack + BaseHeaderSize) + ((sqInt) (((usqInt) i2 ) << (shiftForWord())) ), GIV(nilObj));
			};
			/* end nilFieldsOf: */
			err = PrimErrNotFound;
			goto l9;
		}
		index = (unsignedLongAt((stack + BaseHeaderSize) + ((sqInt) (((usqInt) (stackp - 1) ) << (shiftForWord())) ))) >> 3;
		current = unsignedLongAt((stack + BaseHeaderSize) + ((sqInt) (((usqInt) (stackp - 2) ) << (shiftForWord())) ));
		stackp -= 2;
	};
	l9:
	;
	/* end pathTo:using:followWeak: */
	if (err != 0) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = err);
		/* end primitiveFailFor: */
	}
	path = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* begin pop:thenPush: */
	unsignedLongAtput((sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), path);
	GIV(stackPointer) = sp;
	/* end pop:thenPush: */
	return 0;
}
/* 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 selector1;
	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 l17;
		/* 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 l17;
		/* 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: */
	selector1 = GIV(messageSelector);
	sendBreakpointreceiver(firstFixedFieldOfMaybeImmediate(selector1), lengthOfMaybeImmediate(selector1), 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 l17;
		/* 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) {
		int t18;

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

			executeQuickPrimitive();
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), inInterpreter);
			/* end returnToExecutive: */
			goto l10;
		}
		/* 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) {
			int t0;
			int t1;

			if (((freeStart()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart())) != (freeStart()))) {
				/* 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) {
			sqInt t1;

			/* begin returnToExecutive: */
			returntoExecutive(popStack(), inInterpreter);
			/* end returnToExecutive: */
			goto l10;
		}
	}
	{
		{
			/* 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();
	}
	l10:
	;
	/* end executePrimitiveFromInterpreter:ifFail: */
	/* end executeNewMethod: */
	/* end executeNewMethod */
	/* begin initPrimCall */
	GIV(primFailCode) = 0;
	/* end initPrimCall */
	l17:
	;
	/* 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 selector1;
	char *sp;
	char *sp2;
	char *sp3;
	sqInt succeeded;
	sqInt tagBits;
	sqInt tagBits2;
	sqInt top;

	nArgs = 0;
	savedFramePointer = ((char *) 0 );
	savedStackPointer = ((char *) 0 );
	/* begin primitiveObject:perform:withArguments:lookedUpIn: */
	actualReceiver = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	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 l13;
		/* 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 l13;
		/* 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: */
	selector1 = GIV(messageSelector);
	sendBreakpointreceiver(firstFixedFieldOfMaybeImmediate(selector1), lengthOfMaybeImmediate(selector1), 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 l13;
		/* 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) {
		int t18;

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

			executeQuickPrimitive();
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), inInterpreter);
			/* end returnToExecutive: */
			goto l10;
		}
		/* 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) {
			int t0;
			int t1;

			if (((freeStart()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart())) != (freeStart()))) {
				/* 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) {
			sqInt t1;

			/* begin returnToExecutive: */
			returntoExecutive(popStack(), inInterpreter);
			/* end returnToExecutive: */
			goto l10;
		}
	}
	{
		{
			/* 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();
	}
	l10:
	;
	/* end executePrimitiveFromInterpreter:ifFail: */
	/* end executeNewMethod: */
	/* end executeNewMethod */
	/* begin initPrimCall */
	GIV(primFailCode) = 0;
	/* end initPrimCall */
	l13:
	;
	/* 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 l2;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		deltaTicks = 0;
		goto l2;
	}
	/* end checkedIntegerValueOf: */
	l2:
	;
	/* 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;

	integerResult = 0;
	/* begin stackIntegerValue: */
	integerPointer = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((integerPointer & 7) == 1)) {
		integerRcvr = integerPointer >> 3;
		goto l1;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerRcvr = 0;
		goto l1;
	}
	/* end checkedIntegerValueOf: */
	l1:
	;
	/* end stackIntegerValue: */
	/* begin stackIntegerValue: */
	integerPointer2 = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((integerPointer2 & 7) == 1)) {
		integerArg = integerPointer2 >> 3;
		goto l2;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		integerArg = 0;
		goto l2;
	}
	/* end checkedIntegerValueOf: */
	l2:
	;
	/* 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 l2;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		microSecs = 0;
		goto l2;
	}
	/* end checkedIntegerValueOf: */
	l2:
	;
	/* 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 a SmallInteger indicating the current depth of the OS screen. 
	Negative values are used to imply LSB type pixel format an there is some 
	support in the VM for handling either MSB or LSB */
/* InterpreterPrimitives>>#primitiveScreenDepth */
EXPORT(sqInt)
primitiveScreenDepth(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt depth;
	char *sp;

	depth = ioScreenDepth();
	if (GIV(primFailCode)) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	/* begin pop:thenPushInteger: */
	unsignedLongAtput((sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), ((((usqInt) depth ) << 3) | 1));
	GIV(stackPointer) = sp;
	/* end pop:thenPushInteger: */
	return 0;
}
/*	Answer a float indicating the current scale factor for pixels of the 
	Smalltalk window. */
/* InterpreterPrimitives>>#primitiveScreenScaleFactor */
EXPORT(sqInt)
primitiveScreenScaleFactor(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	double factor;
	sqInt object;
	char *sp;

	factor = ioScreenScaleFactor();
	if (GIV(primFailCode)) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		return null;
		/* end primitiveFail */
	}
	{
		/* begin pop: */
		GIV(stackPointer) += 1 * BytesPerWord;
		/* end pop: */
		/* begin pushFloat: */
		/* begin push: */
		object = floatObjectOf(factor);
		unsignedLongAtput((sp = GIV(stackPointer) - BytesPerWord), object);
		GIV(stackPointer) = sp;
		/* end push: */
		/* end pushFloat: */
	}
	return 0;
}
/*	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 l1;
	}
	l1:
	;
	/* 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 *//*	Primitive. Set the VM's log directory */
/* InterpreterPrimitives>>#primitiveSetLogDirectory */
EXPORT(sqInt)
primitiveSetLogDirectory(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt fmt;
	usqInt numBytes;
	usqInt numSlots;
	sqInt stringOop;
	sqInt sz;

	stringOop = unsignedLongAt(GIV(stackPointer));
	if (!(((stringOop & (tagMask())) == 0) && (((((usqInt) (longAt(stringOop)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())))) {
		/* begin success: */
		{
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
		}
		return null;
		/* end success: */
	}
	/* begin byteSizeOf: */
	if (stringOop & (tagMask())) {
		sz = 0;
		goto l3;
	}
	/* begin numBytesOf: */
	fmt = (((usqInt) (longAt(stringOop)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(stringOop)) > (isForwardedObjectClassIndexPun()));
	numSlots = byteAt(stringOop + 7);
	numBytes = ((numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(stringOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : numSlots);
	/* end numSlotsOf: */
	numBytes = numBytes << (shiftForWord());
	if (fmt >= (firstByteFormat())) {
		sz = numBytes - (fmt & 7);
		goto l3;
	}
	if (fmt <= (sixtyFourBitIndexableFormat())) {
		sz = numBytes;
		goto l3;
	}
	if (fmt >= (firstShortFormat())) {
		sz = numBytes - ((sqInt) (((usqInt) (fmt & 3) ) << 1) );
		goto l3;
	}
	sz = numBytes - ((sqInt) (((usqInt) (fmt & 1) ) << 2) );
	/* end numBytesOf: */
	l3:
	;
	/* end byteSizeOf: */
	ioSetLogDirectoryOfSize(firstIndexableField(stringOop), sz);
	if (!GIV(primFailCode)) {
		/* begin pop: */
		GIV(stackPointer) += GIV(argumentCount) * BytesPerWord;
		/* end pop: */
	}
	return 0;
}
/* 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 l2;
		}
		if (obj == GIV(falseObj)) {
			isReceiverAClass = 0;
			goto l2;
		}
		/* begin success: */
		{
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
		}
		/* end success: */
		isReceiverAClass = null;
		l2:
		;
		/* 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 l4;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		hash = 0;
		goto l4;
	}
	/* end checkedIntegerValueOf: */
	l4:
	;
	/* 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 l3;
	}
	thisReceiver = oop;
	l3:
	;
	/* 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: */
	}
}
/*	Primitive. Set the OS window's label */
/* InterpreterPrimitives>>#primitiveSetWindowLabel */
EXPORT(sqInt)
primitiveSetWindowLabel(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt fmt;
	sqInt labelOop;
	usqInt numBytes;
	usqInt numSlots;
	sqInt sz;

	labelOop = unsignedLongAt(GIV(stackPointer));
	if (!(((labelOop & (tagMask())) == 0) && (((((usqInt) (longAt(labelOop)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat())))) {
		/* begin success: */
		{
			if (!GIV(primFailCode)) {
				GIV(primFailCode) = 1;
			}
		}
		return null;
		/* end success: */
	}
	/* begin byteSizeOf: */
	if (labelOop & (tagMask())) {
		sz = 0;
		goto l3;
	}
	/* begin numBytesOf: */
	fmt = (((usqInt) (longAt(labelOop)) ) >> (formatShift())) & (formatMask());
	/* begin numSlotsOf: */
	assert((classIndexOf(labelOop)) > (isForwardedObjectClassIndexPun()));
	numSlots = byteAt(labelOop + 7);
	numBytes = ((numSlots == (numSlotsMask()))
		 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(labelOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
		 : numSlots);
	/* end numSlotsOf: */
	numBytes = numBytes << (shiftForWord());
	if (fmt >= (firstByteFormat())) {
		sz = numBytes - (fmt & 7);
		goto l3;
	}
	if (fmt <= (sixtyFourBitIndexableFormat())) {
		sz = numBytes;
		goto l3;
	}
	if (fmt >= (firstShortFormat())) {
		sz = numBytes - ((sqInt) (((usqInt) (fmt & 3) ) << 1) );
		goto l3;
	}
	sz = numBytes - ((sqInt) (((usqInt) (fmt & 1) ) << 2) );
	/* end numBytesOf: */
	l3:
	;
	/* end byteSizeOf: */
	ioSetWindowLabelOfSize(firstIndexableField(labelOop), sz);
	if (!GIV(primFailCode)) {
		/* begin pop: */
		GIV(stackPointer) += GIV(argumentCount) * BytesPerWord;
		/* end pop: */
	}
	return 0;
}
/*	Primitive. Answer the OS window's size (extent) */
/* InterpreterPrimitives>>#primitiveSetWindowSize */
EXPORT(sqInt)
primitiveSetWindowSize(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt h;
	sqInt integerPointer;
	sqInt integerPointer2;
	sqInt w;

	/* begin stackIntegerValue: */
	integerPointer = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((integerPointer & 7) == 1)) {
		h = integerPointer >> 3;
		goto l2;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		h = 0;
		goto l2;
	}
	/* end checkedIntegerValueOf: */
	l2:
	;
	/* end stackIntegerValue: */
	/* begin stackIntegerValue: */
	integerPointer2 = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((integerPointer2 & 7) == 1)) {
		w = integerPointer2 >> 3;
		goto l3;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		w = 0;
		goto l3;
	}
	/* end checkedIntegerValueOf: */
	l3:
	;
	/* end stackIntegerValue: */
	if (!GIV(primFailCode)) {
		ioSetWindowWidthHeight(w, h);
		/* begin pop: */
		GIV(stackPointer) += GIV(argumentCount) * BytesPerWord;
		/* end pop: */
	}
	return 0;
}
/*	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 l3;
	}
	if (fmt >= (firstByteFormat())) {
		totalLength = (numSlots << (shiftForWord())) - (fmt & 7);
		goto l3;
	}
	if (fmt >= (firstShortFormat())) {
		totalLength = (numSlots << ((shiftForWord()) - 1)) - (fmt & 3);
		goto l3;
	}
	if (fmt >= (firstLongFormat())) {
		totalLength = (numSlots << ((shiftForWord()) - 2)) - (fmt & 1);
		goto l3;
	}
	if (fmt == (sixtyFourBitIndexableFormat())) {
		totalLength = numSlots;
		goto l3;
	}
	totalLength = 0;
	l3:
	;
	/* end lengthOf:format: */
	/* begin fixedFieldsOf:format:length: */
	if ((fmt >= (sixtyFourBitIndexableFormat())) || (fmt == 2)) {
		fixedFields = 0;
		goto l4;
	}
	if (fmt < 2) {
		fixedFields = totalLength;
		goto l4;
	}
	class = fetchClassOfNonImm(rcvr);
	/* begin fixedFieldsOfClassFormat: */
	classFormat = (unsignedLongAt((class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	fixedFields = classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	/* end fixedFieldsOfClassFormat: */
	l4:
	;
	/* 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 oop1;
	char *sp;

	/* begin totalByteSizeOf: */
	oop1 = unsignedLongAt(GIV(stackPointer));
	byteSize = ((oop1 & (tagMask()))
		 ? 0
		 : bytesInObject(oop1));
	/* 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 classObj1;
	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 l5;
			}
		}
		if (numSlots >= (((usqInt) 1 ) << ((BytesPerOop * 8) - 3))) {
			code = ((nElements < 0)
				 ? PrimErrBadArgument
				 : PrimErrLimitExceeded);
			{
				byteSize = (err = code);
			}
			goto l5;
		}
		byteSize = ((numSlots == 0)
			 ? 8 + BaseHeaderSize
			 : (numSlots << (shiftForWord())) + (((numSlots >= (numSlotsMask()))
				 ? BaseHeaderSize + BaseHeaderSize
				 : BaseHeaderSize)));
		l5:
		;
		/* 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: */
	classObj1 = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	classFormat2 = (unsignedLongAt((classObj1 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	instSpec2 = (((usqInt) classFormat2 ) >> (fixedFieldsFieldWidth())) & (formatMask());
	if (!((instSpec2 <= 1) || (instSpec2 == 5))) {
		{
			byteSize = (err = PrimErrBadReceiver);
		}
		goto l6;
	}
	numSlots2 = classFormat2 & ((1U << (fixedFieldsFieldWidth())) - 1);
	byteSize = ((numSlots2 == 0)
		 ? 8 + BaseHeaderSize
		 : ((sqInt) (((usqInt) numSlots2 ) << (shiftForWord())) ) + (((numSlots2 >= (numSlotsMask()))
			 ? BaseHeaderSize + BaseHeaderSize
			 : BaseHeaderSize)));
	l6:
	;
	/* 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 floatOrIntOop1;
	double rcvr;
	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 loadFloatOrIntFrom: */
	floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (((tagBits = floatOrIntOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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: */
	floatOrIntOop1 = unsignedLongAt(GIV(stackPointer));
	if (((tagBits2 = floatOrIntOop1 & (tagMask()))) != 0) {
		int t1;
		int t2;

		if (tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(floatOrIntOop1));
			rot2 = ((usqInt) ((usqInt) floatOrIntOop1 ) ) >> (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) floatOrIntOop1 ) << shift2) ) ) >> shift2) == floatOrIntOop1))) {
			arg = ((double) (floatOrIntOop1 >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(floatOrIntOop1)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(floatOrIntOop1 + 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: */
	} 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;

	value = 0;
	/* begin smallFloatValueOf: */
	oop = unsignedLongAt(GIV(stackPointer));
	/* 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: */
	/* 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 floatOrIntOop1;
	double rcvr;
	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 loadFloatOrIntFrom: */
	floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (((tagBits = floatOrIntOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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: */
	floatOrIntOop1 = unsignedLongAt(GIV(stackPointer));
	if (((tagBits2 = floatOrIntOop1 & (tagMask()))) != 0) {
		int t1;
		int t2;

		if (tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(floatOrIntOop1));
			rot2 = ((usqInt) ((usqInt) floatOrIntOop1 ) ) >> (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) floatOrIntOop1 ) << shift2) ) ) >> shift2) == floatOrIntOop1))) {
			arg = ((double) (floatOrIntOop1 >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(floatOrIntOop1)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(floatOrIntOop1 + BaseHeaderSize, result2);
			arg = result2;
			goto l7;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	arg = 0.0;
	l7:
	;
	/* 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 floatOrIntOop1;
	double rcvr;
	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 loadFloatOrIntFrom: */
	floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (((tagBits = floatOrIntOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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: */
	floatOrIntOop1 = unsignedLongAt(GIV(stackPointer));
	if (((tagBits2 = floatOrIntOop1 & (tagMask()))) != 0) {
		int t1;
		int t2;

		if (tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(floatOrIntOop1));
			rot2 = ((usqInt) ((usqInt) floatOrIntOop1 ) ) >> (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) floatOrIntOop1 ) << shift2) ) ) >> shift2) == floatOrIntOop1))) {
			arg = ((double) (floatOrIntOop1 >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(floatOrIntOop1)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(floatOrIntOop1 + 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: */
	} 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;

	trunc = 0;
	value = 0;
	/* begin smallFloatValueOf: */
	oop = unsignedLongAt(GIV(stackPointer));
	/* 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: */
	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 floatOrIntOop1;
	double rcvr;
	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 loadFloatOrIntFrom: */
	floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (((tagBits = floatOrIntOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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: */
	floatOrIntOop1 = unsignedLongAt(GIV(stackPointer));
	if (((tagBits2 = floatOrIntOop1 & (tagMask()))) != 0) {
		int t1;
		int t2;

		if (tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(floatOrIntOop1));
			rot2 = ((usqInt) ((usqInt) floatOrIntOop1 ) ) >> (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) floatOrIntOop1 ) << shift2) ) ) >> shift2) == floatOrIntOop1))) {
			arg = ((double) (floatOrIntOop1 >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(floatOrIntOop1)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(floatOrIntOop1 + 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: */
	} 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 floatOrIntOop1;
	double rcvr;
	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 loadFloatOrIntFrom: */
	floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (((tagBits = floatOrIntOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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: */
	floatOrIntOop1 = unsignedLongAt(GIV(stackPointer));
	if (((tagBits2 = floatOrIntOop1 & (tagMask()))) != 0) {
		int t1;
		int t2;

		if (tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(floatOrIntOop1));
			rot2 = ((usqInt) ((usqInt) floatOrIntOop1 ) ) >> (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) floatOrIntOop1 ) << shift2) ) ) >> shift2) == floatOrIntOop1))) {
			arg = ((double) (floatOrIntOop1 >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(floatOrIntOop1)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(floatOrIntOop1 + 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: */
	} 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 floatOrIntOop1;
	double rcvr;
	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 loadFloatOrIntFrom: */
	floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (((tagBits = floatOrIntOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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: */
	floatOrIntOop1 = unsignedLongAt(GIV(stackPointer));
	if (((tagBits2 = floatOrIntOop1 & (tagMask()))) != 0) {
		int t1;
		int t2;

		if (tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(floatOrIntOop1));
			rot2 = ((usqInt) ((usqInt) floatOrIntOop1 ) ) >> (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) floatOrIntOop1 ) << shift2) ) ) >> shift2) == floatOrIntOop1))) {
			arg = ((double) (floatOrIntOop1 >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(floatOrIntOop1)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(floatOrIntOop1 + 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: */
	} 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 floatOrIntOop1;
	double rcvr;
	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 loadFloatOrIntFrom: */
	floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (((tagBits = floatOrIntOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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 l3;
			}
			rcvr = null;
			goto l3;
			/* end smallFloatValueOf: */
		}
		if ((tagBits == (smallIntegerTag())) && (((shift = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) floatOrIntOop ) << shift) ) ) >> shift) == floatOrIntOop))) {
			rcvr = ((double) (floatOrIntOop >> 3) );
			goto l3;
		}
	} else {
		if (((longAt(floatOrIntOop)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(floatOrIntOop + BaseHeaderSize, result);
			rcvr = result;
			goto l3;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	rcvr = 0.0;
	l3:
	;
	/* end loadFloatOrIntFrom: */
	/* begin loadFloatOrIntFrom: */
	floatOrIntOop1 = unsignedLongAt(GIV(stackPointer));
	if (((tagBits2 = floatOrIntOop1 & (tagMask()))) != 0) {
		int t1;
		int t2;

		if (tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(floatOrIntOop1));
			rot2 = ((usqInt) ((usqInt) floatOrIntOop1 ) ) >> (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 l6;
			}
			arg = null;
			goto l6;
			/* end smallFloatValueOf: */
		}
		if ((tagBits2 == (smallIntegerTag())) && (((shift2 = (64 - (numTagBits())) - (smallFloatMantissaBits())), (((sqInt) ((sqInt) (((usqInt) floatOrIntOop1 ) << shift2) ) ) >> shift2) == floatOrIntOop1))) {
			arg = ((double) (floatOrIntOop1 >> 3) );
			goto l6;
		}
	} else {
		if (((longAt(floatOrIntOop1)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(floatOrIntOop1 + BaseHeaderSize, result2);
			arg = result2;
			goto l6;
		}
	}
	/* begin primitiveFail */
	if (!GIV(primFailCode)) {
		GIV(primFailCode) = 1;
	}
	/* end primitiveFail */
	arg = 0.0;
	l6:
	;
	/* 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;

	value = 0;
	/* begin smallFloatValueOf: */
	oop = unsignedLongAt(GIV(stackPointer));
	/* 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: */
	/* 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 floatOrIntOop1;
	double rcvr;
	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 loadFloatOrIntFrom: */
	floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (((tagBits = floatOrIntOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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: */
	floatOrIntOop1 = unsignedLongAt(GIV(stackPointer));
	if (((tagBits2 = floatOrIntOop1 & (tagMask()))) != 0) {
		int t1;
		int t2;

		if (tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(floatOrIntOop1));
			rot2 = ((usqInt) ((usqInt) floatOrIntOop1 ) ) >> (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) floatOrIntOop1 ) << shift2) ) ) >> shift2) == floatOrIntOop1))) {
			arg = ((double) (floatOrIntOop1 >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(floatOrIntOop1)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(floatOrIntOop1 + 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: */
	} 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 floatOrIntOop1;
	double rcvr;
	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 loadFloatOrIntFrom: */
	floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (((tagBits = floatOrIntOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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: */
	floatOrIntOop1 = unsignedLongAt(GIV(stackPointer));
	if (((tagBits2 = floatOrIntOop1 & (tagMask()))) != 0) {
		int t1;
		int t2;

		if (tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(floatOrIntOop1));
			rot2 = ((usqInt) ((usqInt) floatOrIntOop1 ) ) >> (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) floatOrIntOop1 ) << shift2) ) ) >> shift2) == floatOrIntOop1))) {
			arg = ((double) (floatOrIntOop1 >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(floatOrIntOop1)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(floatOrIntOop1 + 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: */
	} 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;

	value = 0;
	/* begin smallFloatValueOf: */
	oop = unsignedLongAt(GIV(stackPointer));
	/* 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: */
	/* 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;

	value = 0;
	/* begin smallFloatValueOf: */
	oop = unsignedLongAt(GIV(stackPointer));
	/* 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: */
	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 floatOrIntOop1;
	double rcvr;
	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 loadFloatOrIntFrom: */
	floatOrIntOop = unsignedLongAt(GIV(stackPointer) + (1 * BytesPerWord));
	if (((tagBits = floatOrIntOop & (tagMask()))) != 0) {
		int t1;
		int t2;

		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: */
	floatOrIntOop1 = unsignedLongAt(GIV(stackPointer));
	if (((tagBits2 = floatOrIntOop1 & (tagMask()))) != 0) {
		int t1;
		int t2;

		if (tagBits2 == (smallFloatTag())) {
			/* begin smallFloatValueOf: */
			/* begin smallFloatBitsOf: */
			assert(isImmediateFloat(floatOrIntOop1));
			rot2 = ((usqInt) ((usqInt) floatOrIntOop1 ) ) >> (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) floatOrIntOop1 ) << shift2) ) ) >> shift2) == floatOrIntOop1))) {
			arg = ((double) (floatOrIntOop1 >> 3) );
			goto l7;
		}
	} else {
		if (((longAt(floatOrIntOop1)) & (classIndexMask())) == ClassFloatCompactIndex) {
			fetchFloatAtinto(floatOrIntOop1 + 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: */
	} 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;

	trunc = 0;
	value = 0;
	/* begin smallFloatValueOf: */
	oop = unsignedLongAt(GIV(stackPointer));
	/* 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 l3;
	l3:
	;
	/* 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;
	usqLong fmt;
	sqLong hdr;
	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: */
	/* 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 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())) && ((hdr & (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;
	usqLong fmt;
	sqLong hdr;
	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 l28;
		/* end primitiveFailFor: */
	}
	if (((index & (smallIntegerTag())) == 0) || ((GIV(argumentCount) > 2) && (((long64At(rcvr)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0))) {
		/* begin primitiveFailFor: */
		GIV(primFailCode) = PrimErrBadArgument;
		goto l28;
		/* 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 l28;
		/* end primitiveFailFor: */
	}
	index = index >> 3;
	{
		if (value & (characterTag())) {
			charToPut = value - ((characterTag()) - (smallIntegerTag()));
			/* begin stObject:at:put: */
			/* begin baseHeader: */
			hdr = long64At(rcvr);
			/* end baseHeader: */
			if ((hdr & (classIndexMask())) == ClassMethodContextCompactIndex) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadReceiver;
				goto l14;
				/* end primitiveFailFor: */
			}
			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 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)))) {
						int t0;
						int t1;

						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 l9;
					}
					if (charToPut & (tagMask())) {
						goto l9;
					}
					if (!(rcvr >= 0x20000000000LL)) {
						goto l9;
					}
					if (charToPut >= 0x20000000000LL) {
						goto l9;
					}
					if ((charToPut >= GIV(nilObj)) && (charToPut <= GIV(trueObj))) {
						goto l9;
					}
					if (!(charToPut >= (startOfObjectMemory(GIV(memoryMap))))) {
						goto l9;
					}
					remember(getFromPermToNewSpaceRememberedSet(), rcvr);
					l9:
					;
					/* 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 l28;
			/* end primitiveFailFor: */
		}
	}
	if (!GIV(primFailCode)) {
		/* begin pop:thenPush: */
		unsignedLongAtput((sp = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), value);
		GIV(stackPointer) = sp;
		/* end pop:thenPush: */
	}
	l28:
	;
	/* 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 index;
	sqInt min;
	sqInt min2;
	sqInt order;
	sqInt result;
	char *sp;
	sqInt str;
	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 l4;
			}
		};
		result = strLength1 - strLength2;
		l4:
		;
		/* 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 l6;
			}
		};
		result = strLength1 - strLength2;
		l6:
		;
		/* 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 classFormat1;
	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 l16;
	}
	if (arrayFmt >= (firstByteFormat())) {
		arrayLength = (numSlots << (shiftForWord())) - (arrayFmt & 7);
		goto l16;
	}
	if (arrayFmt >= (firstShortFormat())) {
		arrayLength = (numSlots << ((shiftForWord()) - 1)) - (arrayFmt & 3);
		goto l16;
	}
	if (arrayFmt >= (firstLongFormat())) {
		arrayLength = (numSlots << ((shiftForWord()) - 2)) - (arrayFmt & 1);
		goto l16;
	}
	if (arrayFmt == (sixtyFourBitIndexableFormat())) {
		arrayLength = numSlots;
		goto l16;
	}
	arrayLength = 0;
	l16:
	;
	/* end lengthOf:format: */
	/* begin classFormatFromInstFormat: */
	if (arrayFmt >= (firstByteFormat())) {
		arrayFmt = arrayFmt & -8;
		goto l17;
	}
	if (arrayFmt <= (sixtyFourBitIndexableFormat())) {
		goto l17;
	}
	if (arrayFmt < (firstShortFormat())) {
		arrayFmt = arrayFmt & -2;
		goto l17;
	}
	arrayFmt = arrayFmt & -4;
	l17:
	;
	/* 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 l19;
	}
	if (replFmt >= (firstByteFormat())) {
		replLength = (numSlots3 << (shiftForWord())) - (replFmt & 7);
		goto l19;
	}
	if (replFmt >= (firstShortFormat())) {
		replLength = (numSlots3 << ((shiftForWord()) - 1)) - (replFmt & 3);
		goto l19;
	}
	if (replFmt >= (firstLongFormat())) {
		replLength = (numSlots3 << ((shiftForWord()) - 2)) - (replFmt & 1);
		goto l19;
	}
	if (replFmt == (sixtyFourBitIndexableFormat())) {
		replLength = numSlots3;
		goto l19;
	}
	replLength = 0;
	l19:
	;
	/* end lengthOf:format: */
	/* begin classFormatFromInstFormat: */
	if (replFmt >= (firstByteFormat())) {
		replFmt = replFmt & -8;
		goto l20;
	}
	if (replFmt <= (sixtyFourBitIndexableFormat())) {
		goto l20;
	}
	if (replFmt < (firstShortFormat())) {
		replFmt = replFmt & -2;
		goto l20;
	}
	replFmt = replFmt & -4;
	l20:
	;
	/* 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 l13;
		}
		if (arrayFmt < 2) {
			arrayInstSize = arrayLength;
			goto l13;
		}
		class = fetchClassOfNonImm(array);
		/* begin fixedFieldsOfClassFormat: */
		classFormat = (unsignedLongAt((class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
		arrayInstSize = classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
		/* end fixedFieldsOfClassFormat: */
		l13:
		;
		/* end fixedFieldsOf:format:length: */
		/* begin fixedFieldsOf:format:length: */
		if ((replFmt >= (sixtyFourBitIndexableFormat())) || (replFmt == 2)) {
			replInstSize = 0;
			goto l14;
		}
		if (replFmt < 2) {
			replInstSize = replLength;
			goto l14;
		}
		class2 = fetchClassOfNonImm(repl);
		/* begin fixedFieldsOfClassFormat: */
		classFormat1 = (unsignedLongAt((class2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
		replInstSize = classFormat1 & ((1U << (fixedFieldsFieldWidth())) - 1);
		/* end fixedFieldsOfClassFormat: */
		l14:
		;
		/* 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 objOop1;
	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: */
		objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		objOop = unsignedLongAt((objOop1 + 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)))) {
			int t0;
			int t1;

			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 l3;
		}
		if (activeProc & (tagMask())) {
			goto l3;
		}
		if (!(criticalSection >= 0x20000000000LL)) {
			goto l3;
		}
		if (activeProc >= 0x20000000000LL) {
			goto l3;
		}
		if ((activeProc >= GIV(nilObj)) && (activeProc <= GIV(trueObj))) {
			goto l3;
		}
		if (!(activeProc >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l3;
		}
		remember(getFromPermToNewSpaceRememberedSet(), criticalSection);
		l3:
		;
		/* 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;

	trunc = 0;
	/* begin stackFloatValue: */
	rcvr = floatValueOf(unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord)));
	/* 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 address1;
	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 limit1;
	sqInt moduleName;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	sqInt oop;
	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 l7;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* end objectAfter:limit: */
	};
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
	/* begin flushMethodCache */
	{
		sqInt i;

		for (i = 1; i <= MethodCacheSize; i += 1) {
			GIV(methodCache)[i] = 0;
		};
		GIV(lastMethodCacheProbeWrite) = 0;
	}
	unlinkAllSends();
	/* 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 valuePointer1;

	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: */
		valuePointer1 = positive64BitIntegerFor(ioUTCMicroseconds());
		assert(!(isForwarded(resultArray)));
		if (((resultArray & (tagMask())) == 0) && ((resultArray & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			int t0;
			int t1;

			if (((valuePointer1 & (tagMask())) == 0) && (((valuePointer1 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (valuePointer1 >= ((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 l4;
		}
		if (valuePointer1 & (tagMask())) {
			goto l4;
		}
		if (!(resultArray >= 0x20000000000LL)) {
			goto l4;
		}
		if (valuePointer1 >= 0x20000000000LL) {
			goto l4;
		}
		if ((valuePointer1 >= GIV(nilObj)) && (valuePointer1 <= GIV(trueObj))) {
			goto l4;
		}
		if (!(valuePointer1 >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l4;
		}
		remember(getFromPermToNewSpaceRememberedSet(), resultArray);
		l4:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((resultArray + BaseHeaderSize) + (0U << (shiftForWord())), valuePointer1);
		/* 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 valuePointer1;

	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: */
		valuePointer1 = positive64BitIntegerFor((ioUTCMicroseconds()) - epochDelta);
		assert(!(isForwarded(resultArray)));
		if (((resultArray & (tagMask())) == 0) && ((resultArray & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			int t0;
			int t1;

			if (((valuePointer1 & (tagMask())) == 0) && (((valuePointer1 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (valuePointer1 >= ((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 l2;
		}
		if (valuePointer1 & (tagMask())) {
			goto l2;
		}
		if (!(resultArray >= 0x20000000000LL)) {
			goto l2;
		}
		if (valuePointer1 >= 0x20000000000LL) {
			goto l2;
		}
		if ((valuePointer1 >= GIV(nilObj)) && (valuePointer1 <= GIV(trueObj))) {
			goto l2;
		}
		if (!(valuePointer1 >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l2;
		}
		remember(getFromPermToNewSpaceRememberedSet(), resultArray);
		l2:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((resultArray + BaseHeaderSize) + (0U << (shiftForWord())), valuePointer1);
		/* 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: */
}
/*	Primitive. 
	0 args: Answer whether the VM Profiler is running or not. 
	1 arg:	Copy the sample data into the supplied argument, which must be a 
	Bitmap of suitable size. Answer the number of samples copied into the 
	buffer.  */
/* InterpreterPrimitives>>#primitiveVMProfileSamplesInto */
static void
primitiveVMProfileSamplesInto(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	long bufferSize;
	sqInt numSamples;
	sqInt running;
	sqInt sampleBuffer;
	char *sp;
	char *sp2;
	sqInt v;

	bufferSize = 0;
	running = 0;
	v = 0;
	ioNewProfileStatus(&running, &bufferSize);
	if (GIV(argumentCount) == 0) {
		{
			/* begin pop:thenPushBool: */
			unsignedLongAtput((sp = GIV(stackPointer) + ((1 - 1) * BytesPerWord)), ((running)
				 ? GIV(trueObj)
				 : GIV(falseObj)));
			GIV(stackPointer) = sp;
			/* end pop:thenPushBool: */
			return;
		}
	}
	if (!(GIV(argumentCount) == 1)) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadNumArgs;
			/* end primitiveFailFor: */
			return;
		}
	}
	sampleBuffer = unsignedLongAt(GIV(stackPointer) + (0 * BytesPerWord));
	if (!(((sampleBuffer & (tagMask())) == 0) && ((isPureBitsFormat((((usqInt) (longAt(sampleBuffer)) ) >> (formatShift())) & (formatMask()))) && ((numBytesOf(sampleBuffer)) >= (bufferSize * BytesPerWord))))) {
		{
			/* begin primitiveFailFor: */
			GIV(primFailCode) = PrimErrBadArgument;
			/* end primitiveFailFor: */
			return;
		}
	}
	numSamples = ioNewProfileSamplesInto(firstFixedField(sampleBuffer));
	/* begin pop:thenPushInteger: */
	unsignedLongAtput((sp2 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), ((((usqInt) numSamples ) << 3) | 1));
	GIV(stackPointer) = sp2;
	/* end pop:thenPushInteger: */
}
/* InterpreterPrimitives>>#primitiveWait */
static void
primitiveWait(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt activeProc;
	sqInt excessSignals;
	sqInt inInterpreter;
	sqInt objOop;
	sqInt objOop1;
	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: */
		objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		objOop = unsignedLongAt((objOop1 + 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 classOop1;
	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: */
	classOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(oop)));
	/* begin classIndexOf: */
	ccIndex2 = (longAt(oop)) & (classIndexMask());
	/* end classIndexOf: */
	{
		ok = ClassLargePositiveIntegerCompactIndex == ccIndex2;
		goto l4;
	}
	l4:
	;
	/* 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 l2;
		}
		l2:
		;
		/* 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 classOop1;
	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: */
	classOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassLargePositiveInteger ) << (shiftForWord())) ));
	assert(!(isImmediate(oop)));
	/* begin classIndexOf: */
	ccIndex2 = (longAt(oop)) & (classIndexMask());
	/* end classIndexOf: */
	{
		ok = ClassLargePositiveIntegerCompactIndex == ccIndex2;
		goto l4;
	}
	l4:
	;
	/* 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 l2;
		}
		l2:
		;
		/* 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 l6;
	}
	if (fmt <= (sixtyFourBitIndexableFormat())) {
		bs = numBytes;
		goto l6;
	}
	if (fmt >= (firstShortFormat())) {
		bs = numBytes - ((sqInt) (((usqInt) (fmt & 3) ) << 1) );
		goto l6;
	}
	bs = numBytes - ((sqInt) (((usqInt) (fmt & 1) ) << 2) );
	l6:
	;
	/* 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 address1;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	sqInt oop;
	sqInt prevObj;
	sqInt prevObj2;
	sqInt prevPrevObj;
	sqInt prevPrevObj2;

	{
		sqInt oop;

		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 l1;
			}
			flag("endianness");
			followingWord = unsignedLongAt(followingWordAddress);
			objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress + BaseHeaderSize
				 : followingWordAddress);
			l1:
			;
			/* end objectAfter:limit: */
		};
		/* begin objectStartingAt: */
		address1 = ((eden()).start);
		numSlots2 = byteAt(address1 + 7);
		objOop2 = ((numSlots2 == (numSlotsMask()))
			 ? address1 + BaseHeaderSize
			 : address1);
		/* 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 l2;
			}
			flag("endianness");
			followingWord2 = unsignedLongAt(followingWordAddress2);
			objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress2 + BaseHeaderSize
				 : followingWordAddress2);
			l2:
			;
			/* 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: */
			limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			followingWordAddress4 = addressAfter(objOop22);
			if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
				objOop22 = limit1;
				goto l6;
			}
			flag("endianness");
			followingWord4 = unsignedLongAt(followingWordAddress4);
			objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress4 + BaseHeaderSize
				 : followingWordAddress4);
			l6:
			;
			/* 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 l5;
			}
			flag("endianness");
			followingWord3 = unsignedLongAt(followingWordAddress3);
			currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress3 + BaseHeaderSize
				 : followingWordAddress3);
			l5:
			;
			/* 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 classTablePage;
	sqInt entry;
	sqInt fieldIndex;
	sqInt fieldIndex1;

	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: */
	fieldIndex1 = maybeClassIndex & ((1U << (classTableMajorIndexShift())) - 1);
	entry = unsignedLongAt((classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (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));
	header = unsignedLongAt((methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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))) {
		int t5;
		int t6;

		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));
}
/*	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. */
/* Spur64BitMemoryManager>>#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 l4;
		}
		if (fmt <= (sixtyFourBitIndexableFormat())) {
			instBytes = numBytes;
			goto l4;
		}
		if (fmt >= (firstShortFormat())) {
			instBytes = numBytes - ((sqInt) (((usqInt) (fmt & 3) ) << 1) );
			goto l4;
		}
		instBytes = numBytes - ((sqInt) (((usqInt) (fmt & 1) ) << 2) );
		l4:
		;
		/* end numBytesOf: */
		switch (classFormat) {
			case sixtyFourBitIndexableFormat():
			{
				if (instBytes & 7) {
					return PrimErrBadReceiver;
				}
				newFormat = classFormat;
			}
			break;
			case firstLongFormat():
			{
				if (instBytes & 3) {
					return PrimErrBadReceiver;
				}
				newFormat = classFormat + ((2 - (((usqInt) instBytes ) >> 2)) & 1);
			}
			break;
			case firstShortFormat():
			{
				if (instBytes & 1) {
					return PrimErrBadReceiver;
				}
				newFormat = classFormat + ((4 - (((usqInt) instBytes ) >> 1)) & 3);
			}
			break;
			case firstByteFormat():
			{
				newFormat = classFormat + ((8 - instBytes) & 7);
			}
			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;
}
/*	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 classIndex;
	sqInt err;
	sqInt fillValue;
	sqInt hash;
	int hasToScheduleScavenge;
	sqInt instSpec;
	sqInt newObj;
	sqInt newObj2;
	usqInt numBytes;
	usqInt numSlots;
	usqInt p;

	classFormat = (unsignedLongAt((classObj + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	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)) {
				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 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 */
				}
			}
			{
				newObj = allocateSlotsInOldSpacebytesformatclassIndex(numSlots, numBytes, instSpec, classIndex);
				goto l6;
			}
		}
		newObj2 = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(GIV(freeStart), numSlots, instSpec, classIndex, 0);
		assert((numBytes % (allocationUnit())) == 0);
		assert((newObj2 % (allocationUnit())) == 0);
		GIV(freeStart) += numBytes;
		newObj = newObj2;
		l6:
		;
		/* 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, 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 classIndex1;
	sqInt classIndex2;
	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());
		classIndex2 = (longAt(objOop)) & (classIndexMask());
		/* begin allocateSlots:format:classIndex:isPinned:isOldSpace: */
		if (numSlots >= (numSlotsMask())) {
			if ((((usqInt) numSlots ) >> 56) > 0) {
				copy = null;
				goto l5;
			}
			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, classIndex2);
				goto l5;
			}
		}
		newObj = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(GIV(freeStart), numSlots, formatField, classIndex2, 0);
		assert((numBytes % (allocationUnit())) == 0);
		assert((newObj % (allocationUnit())) == 0);
		GIV(freeStart) += numBytes;
		copy = newObj;
		/* end allocateSlots:format:classIndex:isPinned:isOldSpace: */
		l5:
		;
		/* 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: */
		classIndex1 = isForwardedObjectClassIndexPun();
		assert((classIndex1 >= 0) && (classIndex1 <= (classIndexMask())));
		assert((7 >= 0) && (7 <= (formatMask())));
		longAtput(objOop, ((longAt(objOop)) & (~((usqIntptr_t) (((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) + (classIndexMask())) ))) + (classIndex1 + (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 l4;
		}
		if (copy & (tagMask())) {
			goto l4;
		}
		if (!(objOop >= 0x20000000000LL)) {
			goto l4;
		}
		if (copy >= 0x20000000000LL) {
			goto l4;
		}
		if ((copy >= GIV(nilObj)) && (copy <= GIV(trueObj))) {
			goto l4;
		}
		if (!(copy >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l4;
		}
		remember(getFromPermToNewSpaceRememberedSet(), objOop);
		l4:
		;
		/* 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;

	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));
		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 address1;
	sqInt followingWord;
	sqInt followingWord2;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt limit;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	sqInt objOop;
	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 l1;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l1:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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;
	sqInt prevObj;
	sqInt prevPrevObj;
	sqInt survivor;

	/* begin allFutureSpaceEntitiesDo: */
	prevPrevObj = (prevObj = null);
	/* 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;
				}
			}
		}
		prevPrevObj = prevObj;
		prevObj = objOop;
		/* begin objectAfter:limit: */
		followingWordAddress = addressAfter(objOop);
		if (oopisGreaterThanOrEqualTo(followingWordAddress, limit)) {
			objOop = limit;
			goto l1;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l1:
		;
		/* 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;
	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;
	VMRememberedSet * self_in_referenceCountRememberedReferentsmaxRefCount;

	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;
	sqInt aReferrer;
	sqInt aValue;
	sqInt classFormat;
	sqInt contextSize;
	int destIndex;
	sqInt fmt;
	sqInt foundNewReferentOrIsWeakling;
	sqInt foundNewReferentOrIsWeakling2;
	sqInt header;
	sqInt header2;
	sqInt i;
	VMMemoryMap *map;
	sqInt newLocation;
	sqInt numLiterals;
	sqInt numSlots;
	usqInt numSlots2;
	usqInt numSlots3;
	sqInt objOop1;
	sqInt permSpaceMinAddress;
	sqInt referent;
	sqInt referent2;
	sqInt referent3;
	sqInt referrer;
	int refersOldSpace;
	sqInt result;
	sqInt returnValue;
	VMRememberedSet * self_in_saveat;
	VMRememberedSet * self_in_setRememberedSetSize;
	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 */
		map = GIV(memoryMap);
		/* 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 l8;
			}
			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 l6;
					}
					assert((ReceiverIndex + (sp >> 3)) < (lengthOf(referrer)));
					contextSize = sp >> 3;
					l6:
					;
					/* end fetchStackPointerOf: */
					numSlots = CtxtTempFrameStart + contextSize;
					goto l8;
				}
				numSlots = numSlots3;
				goto l8;
			}
			if (fmt == (weakArrayFormat())) {
				/* begin fixedFieldsOfClass: */
				objOop1 = fetchClassOfNonImm(referrer);
				/* begin fixedFieldsOfClassFormat: */
				classFormat = (unsignedLongAt((objOop1 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
				numSlots = classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
				goto l8;
				/* end fixedFieldsOfClassFormat: */
				/* end fixedFieldsOfClass: */
			}
			assert(fmt == (ephemeronFormat()));
			numSlots = ((isScavengeSurvivor(keyOfEphemeron(referrer)))
				 ? numSlots3
				 : 0);
			goto l8;
		}
		if (fmt == 7) {
			numSlots = 1;
			goto l8;
		}
		if (fmt < (firstCompiledMethodFormat())) {
			numSlots = 0;
			goto l8;
		}
		/* begin methodHeaderOf: */
		assert(isCompiledMethod(referrer));
		header2 = unsignedLongAt((referrer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		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;
		l8:
		;
		/* end numStrongSlotsOf:format:ephemeronInactiveIf: */
		foundNewReferentOrIsWeakling2 = 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;
						foundNewReferentOrIsWeakling2 = 1;
					} else {
						newLocation = copyAndForward(referent3);
						if (((newLocation & (tagMask())) == 0) && (((newLocation & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (newLocation >= ((GIV(memoryMap)->newSpaceStart))))) {
							foundNewReferentOrIsWeakling2 = 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 = foundNewReferentOrIsWeakling2;
		/* end scavengeReferentsOf:additionalTestingBlock: */
		if (returnValue) {
			result = 1;
			goto l17;
		}
		if (refersOldSpace) {
			result = 2;
			goto l17;
		}
		result = 3;
		l17:
		;
		/* 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;
	sqInt i;
	sqInt i2;
	sqInt referrer;
	VMRememberedSet * self_in_rememberedSetWithIndexDostartingAt;
	sqInt startIndex;

	/* begin rememberedSetWithIndexDo:startingAt: */
	/* begin getFromOldSpaceRememberedSet */
	self_in_rememberedSetWithIndexDostartingAt = GIV(fromOldSpaceRememberedSet);
	/* end getFromOldSpaceRememberedSet */
	startIndex = ((getFromOldSpaceRememberedSet())->numRememberedEphemerons);
	for (i2 = startIndex; i2 < ((self_in_rememberedSetWithIndexDostartingAt->rememberedSetSize)); i2 += 1) {
		referrer = (self_in_rememberedSetWithIndexDostartingAt->rememberedSetArray)[i2];
		{
			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;
	sqInt i;
	sqInt i2;
	sqInt i3;
	sqInt i4;
	sqInt oop;
	VMRememberedSet * self_in_rememberedSetWithIndexDo;
	VMRememberedSet * self_in_rememberedSetWithIndexDo1;
	VMRememberedSet * self_in_rememberedSetWithIndexDo2;

	{
		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_rememberedSetWithIndexDo1 = GIV(fromPermToOldSpaceRememberedSet);
	/* end getFromPermToOldSpaceRememberedSet */
	/* begin rememberedSetWithIndexDo:startingAt: */
	for (i3 = 0; i3 < ((self_in_rememberedSetWithIndexDo1->rememberedSetSize)); i3 += 1) {
		oop = (self_in_rememberedSetWithIndexDo1->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_rememberedSetWithIndexDo2 = GIV(fromPermToNewSpaceRememberedSet);
	/* end getFromPermToNewSpaceRememberedSet */
	/* begin rememberedSetWithIndexDo:startingAt: */
	for (i4 = 0; i4 < ((self_in_rememberedSetWithIndexDo2->rememberedSetSize)); i4 += 1) {
		oop = (self_in_rememberedSetWithIndexDo2->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;
	sqInt anIndex;
	sqInt anIndex1;
	sqInt aValue;
	sqInt aValue1;
	sqInt ephemeron;
	sqInt ephemeron2;
	sqInt ephemeronCorpse;
	sqInt hasNewReferents;
	int i;
	int i2;
	sqInt index1;
	sqInt key;
	sqInt key2;
	sqInt listOffset;
	sqLong newRememberedSetSize;
	sqLong newRememberedSetSize2;
	sqInt objStack;
	sqInt objStack1;
	sqInt oldCorpse;
	sqInt oldList;
	sqInt referent;
	sqInt referent2;
	sqInt referrer;
	VMRememberedSet * self_in_removeLastEphemeronAndMoveTo;
	VMRememberedSet * self_in_removeLastEphemeronAndMoveTo1;
	VMRememberedSet * self_in_removeLastEphemeronToandSave;
	sqInt unfiredEphemeronsScavenged;
	int unfiredEphemeronsScavenged2;
	sqInt valuePointer;
	sqInt valuePointer1;

	/* 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: */
				index1 = (self_in_removeLastEphemeronToandSave->numRememberedEphemerons);
				(self_in_removeLastEphemeronToandSave->rememberedSetArray)[index1] = referrer;
				/* end save:at: */
				/* end removeLastEphemeronTo:andSave: */
			} else {
				/* begin removeLastEphemeronAndMoveTo: */
				/* begin getFromOldSpaceRememberedSet */
				self_in_removeLastEphemeronAndMoveTo1 = GIV(fromOldSpaceRememberedSet);
				/* end getFromOldSpaceRememberedSet */
				/* begin removeLastEphemeronAndKeepIn: */
				(self_in_removeLastEphemeronAndMoveTo1->numRememberedEphemerons) = ((self_in_removeLastEphemeronAndMoveTo1->numRememberedEphemerons)) - 1;
				(self_in_removeLastEphemeronAndMoveTo1->rememberedSetArray)[i2] = (self_in_removeLastEphemeronAndMoveTo1->rememberedSetArray)[(self_in_removeLastEphemeronAndMoveTo1->numRememberedEphemerons)];
				/* end removeLastEphemeronAndKeepIn: */
				/* begin removeByIndexUsingPreviousSize: */
				anIndex1 = (self_in_removeLastEphemeronAndMoveTo1->numRememberedEphemerons);
				(self_in_removeLastEphemeronAndMoveTo1->previousRememberedSetSize) = ((self_in_removeLastEphemeronAndMoveTo1->previousRememberedSetSize)) - 1;
				newRememberedSetSize2 = ((self_in_removeLastEphemeronAndMoveTo1->rememberedSetSize)) - 1;
				{
					(self_in_removeLastEphemeronAndMoveTo1->rememberedSetArray)[anIndex1] = (self_in_removeLastEphemeronAndMoveTo1->rememberedSetArray)[(self_in_removeLastEphemeronAndMoveTo1->previousRememberedSetSize)];
					(self_in_removeLastEphemeronAndMoveTo1->rememberedSetArray)[(self_in_removeLastEphemeronAndMoveTo1->previousRememberedSetSize)] = (self_in_removeLastEphemeronAndMoveTo1->rememberedSetArray)[newRememberedSetSize2];
				}
				/* begin setRememberedSetSize: */
				(self_in_removeLastEphemeronAndMoveTo1->rememberedSetSize) = newRememberedSetSize2;
				if (newRememberedSetSize2 < ((self_in_removeLastEphemeronAndMoveTo1->rememberedSetLimit))) {
					(self_in_removeLastEphemeronAndMoveTo1->rememberedSetArray)[newRememberedSetSize2] = 0;
				}
				/* end setRememberedSetSize: */
				/* end removeByIndexUsingPreviousSize: */
				/* end removeLastEphemeronAndMoveTo: */
				/* begin setIsRememberedOf:to: */
				/* begin unsignedLong64At:put: */
				aValue1 = (uint64AtPointer(referrer)) & (~((usqIntptr_t) (1U << (rememberedBitShift())) ));
				uint64AtPointerput(referrer, aValue1);
				/* 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 l21;
		}
		oldCorpse = null;
		/* begin firstCorpse: */
		/* begin corpseForCorpseOffset: */
		ephemeronCorpse = ((sqInt) (((usqInt) (GIV(ephemeronList) - 1) ) << 3) ) + (((getMemoryMap())->newSpaceStart));
		/* end corpseForCorpseOffset: */
		/* end firstCorpse: */
		oldList = GIV(ephemeronList);
		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: */
					objStack1 = GIV(mournQueue);
					assert(addressCouldBeOop(ephemeron2));
					if (ephemeron2 & (tagMask())) {
						assert(objStack1 == GIV(markStack));
						assert(addressCouldBeObj(topOfObjStack(((0 == (fetchPointerofObject(ObjStackTopx, objStack1)))
							 ? fetchPointerofObject(ObjStackNextx, objStack1)
							 : objStack1))));
					} else {
						assert(!((objStack1 == GIV(markStack)) && (isWeakNonImm(ephemeron2))));
						assert((objStack1 != GIV(weaklingStack)) || (isWeakNonImm(ephemeron2)));
					}
					noCheckPushonObjStack(ephemeron2, objStack1);
					/* 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: */
				valuePointer1 = copyAndForward(key2);
				assert(!(isOopForwarded(ephemeron2)));
				longAtput((ephemeron2 + BaseHeaderSize) + (0U << (shiftForWord())), valuePointer1);
				/* end storePointerUnchecked:ofObject:withValue: */
				assert(!((isScavengeSurvivor(key2)) && (isEphemeron(ephemeron2))));
			}
			((void) (scavengeReferentsOfFromOldSpace(ephemeron2)) );
			oldCorpse = ephemeronCorpse;
			/* 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: */
		};
		l21:
		;
		/* 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;
	sqInt aNewValue;
	sqInt aValue;
	int i;
	sqInt listOffset;
	sqInt referent;
	sqInt rootObj;
	VMRememberedSet * self_in_moveLastObjectTo;
	VMRememberedSet * self_in_removeLastObject;
	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;
	int firstTime;
	sqInt i;
	sqInt previousFutureSurvivorStart;
	VMRememberedSet * self_in_rememberPreviousSize;
	VMRememberedSet * self_in_startingLoop;
	StackPage *thePage;
	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 */
	}
	for (i = 0; i < GIV(numStackPages); i += 1) {
		/* begin stackPageAt: */
		thePage = stackPageAtpages(i, GIV(pages));
		/* end stackPageAt: */
		(thePage->trace = StackPageUnreached);
	};
	/* 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 aReferent;
	sqInt aReferrer;
	sqInt classFormat;
	sqInt contextSize;
	sqInt fmt;
	sqInt foundNewReferentOrIsWeakling;
	sqInt foundNewReferentOrIsWeakling2;
	sqInt header;
	sqInt header2;
	sqInt i;
	sqInt newLocation;
	sqInt numLiterals;
	sqInt numSlots;
	usqInt numSlots2;
	usqInt numSlots3;
	sqInt objOop1;
	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 l8;
		}
		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 l6;
				}
				assert((ReceiverIndex + (sp >> 3)) < (lengthOf(referrer)));
				contextSize = sp >> 3;
				l6:
				;
				/* end fetchStackPointerOf: */
				numSlots = CtxtTempFrameStart + contextSize;
				goto l8;
			}
			numSlots = numSlots3;
			goto l8;
		}
		if (fmt == (weakArrayFormat())) {
			/* begin fixedFieldsOfClass: */
			objOop1 = fetchClassOfNonImm(referrer);
			/* begin fixedFieldsOfClassFormat: */
			classFormat = (unsignedLongAt((objOop1 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
			numSlots = classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
			goto l8;
			/* end fixedFieldsOfClassFormat: */
			/* end fixedFieldsOfClass: */
		}
		assert(fmt == (ephemeronFormat()));
		numSlots = ((isScavengeSurvivor(keyOfEphemeron(referrer)))
			 ? numSlots3
			 : 0);
		goto l8;
	}
	if (fmt == 7) {
		numSlots = 1;
		goto l8;
	}
	if (fmt < (firstCompiledMethodFormat())) {
		numSlots = 0;
		goto l8;
	}
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(referrer));
	header2 = unsignedLongAt((referrer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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;
	l8:
	;
	/* end numStrongSlotsOf:format:ephemeronInactiveIf: */
	foundNewReferentOrIsWeakling2 = 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;
					foundNewReferentOrIsWeakling2 = 1;
				} else {
					newLocation = copyAndForward(referent);
					if (((newLocation & (tagMask())) == 0) && (((newLocation & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (newLocation >= ((GIV(memoryMap)->newSpaceStart))))) {
						foundNewReferentOrIsWeakling2 = 1;
					} else {
						{
						}
					}
				}
				unsignedLongAtput((referrer + BaseHeaderSize) + ((sqInt) (((usqInt) i ) << (shiftForWord())) ), newLocation);
			} else {
				unsignedLongAtput((referrer + BaseHeaderSize) + ((sqInt) (((usqInt) i ) << (shiftForWord())) ), referent);
				{
				}
			}
		}
	};
	return foundNewReferentOrIsWeakling2;
	/* 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;
	sqInt aValue;
	sqInt destIndex;
	sqInt format;
	sqInt referrer;
	VMRememberedSet * self_in_moveNewEphemerondestinationIndex;
	VMRememberedSet * self_in_saveat;
	VMRememberedSet * self_in_setRememberedSetSize;
	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;
	SpurSegmentInfo *aSegment;
	size_t bytesWritten;
	sqImageFile f;
	squeakFileOffsetType headerStart;
	sqInt i;
	sqInt iLimiT;
	size_t imageBytes;
	sqInt imageHeaderSize;
	sqInt segmentIndex;
	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 l1;
				}
				flag("endianness");
				followingWord = unsignedLongAt(followingWordAddress);
				objAfter = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
					 ? followingWordAddress + BaseHeaderSize
					 : followingWordAddress);
				l1:
				;
				/* 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 l3;
			}
			flag("endianness");
			followingWord2 = unsignedLongAt(followingWordAddress2);
			objAfter = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress2 + BaseHeaderSize
				 : followingWordAddress2);
			l3:
			;
			/* 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 l4;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		objAfter = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l4:
		;
		/* 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 fieldIndex1;
	sqInt index;
	sqInt nextFreeChunk;
	sqInt nextFreeChunk1;
	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: */
			nextFreeChunk1 = unsignedLongAt((child + BaseHeaderSize) + (0U << (shiftForWord())));
			/* begin storePointer:ofFreeChunk:withValue: */
			assert(isFreeObject(freeChunk));
			assert((nextFreeChunk1 == 0) || (isFreeObject(nextFreeChunk1)));
			unsignedLongAtput((freeChunk + BaseHeaderSize) + (0U << (shiftForWord())), nextFreeChunk1);
			/* end storePointer:ofFreeChunk:withValue: */
			if ((nextFreeChunk1 != 0) && !0) {
				/* begin storePointer:ofFreeChunk:withValue: */
				assert(isFreeObject(nextFreeChunk1));
				assert((freeChunk == 0) || (isFreeObject(freeChunk)));
				unsignedLongAtput((nextFreeChunk1 + 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: */
	fieldIndex1 = ((childBytes > chunkBytes)
		 ? 3
		 : 4);
	assert(isFreeObject(parent));
	assert((freeChunk == 0) || (isFreeObject(freeChunk)));
	unsignedLongAtput((parent + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (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 address1;
	sqInt address11;
	sqInt address2;
	usqInt bytes;
	sqInt c;
	sqInt classIndex;
	sqInt classOrNil;
	sqInt count;
	int count2;
	int count3;
	sqInt currentObject;
	sqInt currentObject2;
	sqInt entry;
	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 limit1;
	sqInt limit11;
	usqInt limit3;
	usqInt limit32;
	sqInt newObj;
	sqInt newObj2;
	usqInt numBytes;
	usqInt numBytes2;
	usqInt numSlots;
	usqInt numSlots2;
	usqInt numSlots22;
	usqInt numSlots3;
	sqInt obj;
	sqInt obj2;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	sqInt p;
	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 l3;
			}
		}
		newObj = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(GIV(freeStart), 0, 2, ClassArrayCompactIndex, 0);
		assert((numBytes % (allocationUnit())) == 0);
		assert((newObj % (allocationUnit())) == 0);
		GIV(freeStart) += numBytes;
		freeChunk = newObj;
		l3:
		;
		/* 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: */
			limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			followingWordAddress4 = addressAfter(objOop2);
			if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
				objOop2 = limit1;
				goto l6;
			}
			flag("endianness");
			followingWord4 = unsignedLongAt(followingWordAddress4);
			objOop2 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress4 + BaseHeaderSize
				 : followingWordAddress4);
			l6:
			;
			/* 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 l10;
			}
			flag("endianness");
			followingWord = unsignedLongAt(followingWordAddress);
			objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress + BaseHeaderSize
				 : followingWordAddress);
			l10:
			;
			/* end objectAfter:limit: */
		};
		/* begin objectStartingAt: */
		address1 = ((eden()).start);
		numSlots2 = byteAt(address1 + 7);
		objOop = ((numSlots2 == (numSlotsMask()))
			 ? address1 + BaseHeaderSize
			 : address1);
		/* 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 l8;
			}
			flag("endianness");
			followingWord2 = unsignedLongAt(followingWordAddress2);
			objOop = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress2 + BaseHeaderSize
				 : followingWordAddress2);
			l8:
			;
			/* 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 l5;
			}
			flag("endianness");
			followingWord3 = unsignedLongAt(followingWordAddress3);
			currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress3 + BaseHeaderSize
				 : followingWordAddress3);
			l5:
			;
			/* 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: */
			limit11 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			followingWordAddress42 = addressAfter(objOop22);
			if (oopisGreaterThanOrEqualTo(followingWordAddress42, limit11)) {
				objOop22 = limit11;
				goto l16;
			}
			flag("endianness");
			followingWord42 = unsignedLongAt(followingWordAddress42);
			objOop22 = (((((usqInt) followingWord42 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress42 + BaseHeaderSize
				 : followingWordAddress42);
			l16:
			;
			/* end objectAfter:limit: */
		};
		;
		;
		/* end allOldSpaceEntitiesFrom:do: */
		/* end allOldSpaceEntitiesDo: */
		/* begin allNewSpaceEntitiesDo: */
		prevPrevObj3 = (prevObj3 = null);
		assert((((pastSpace()).start)) < (((eden()).start)));
		/* begin objectStartingAt: */
		address2 = ((pastSpace()).start);
		numSlots3 = byteAt(address2 + 7);
		objOop3 = ((numSlots3 == (numSlotsMask()))
			 ? address2 + BaseHeaderSize
			 : address2);
		/* 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 l15;
			}
			flag("endianness");
			followingWord5 = unsignedLongAt(followingWordAddress5);
			objOop3 = (((((usqInt) followingWord5 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress5 + BaseHeaderSize
				 : followingWordAddress5);
			l15:
			;
			/* end objectAfter:limit: */
		};
		/* begin objectStartingAt: */
		address11 = ((eden()).start);
		numSlots22 = byteAt(address11 + 7);
		objOop3 = ((numSlots22 == (numSlotsMask()))
			 ? address11 + BaseHeaderSize
			 : address11);
		/* 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 l12;
			}
			flag("endianness");
			followingWord22 = unsignedLongAt(followingWordAddress22);
			objOop3 = (((((usqInt) followingWord22 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress22 + BaseHeaderSize
				 : followingWordAddress22);
			l12:
			;
			/* 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 l13;
			}
			flag("endianness");
			followingWord32 = unsignedLongAt(followingWordAddress32);
			currentObject2 = (((((usqInt) followingWord32 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress32 + BaseHeaderSize
				 : followingWordAddress32);
			l13:
			;
			/* 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 l4;
			}
			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 l4;
			}
		}
		newObj2 = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(GIV(freeStart), count, 2, ClassArrayCompactIndex, 0);
		assert((numBytes2 % (allocationUnit())) == 0);
		assert((newObj2 % (allocationUnit())) == 0);
		GIV(freeStart) += numBytes2;
		smallObj = newObj2;
		l4:
		;
		/* 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 address1;
	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 limit1;
	usqInt limit3;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop2);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop2 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop2 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l7;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 address1;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt o;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	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 l1;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l1:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 o;
	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 l1;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l1:
		;
		/* 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 fieldIndex1;
	sqInt fieldIndex2;
	sqInt index;
	usqInt initialIndex;
	sqInt next;
	sqInt next2;
	sqInt next3;
	sqInt nextFreeChunk;
	sqInt nextFreeChunk1;
	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: */
						fieldIndex1 = 1;
						assert(isFreeObject(next2));
						assert(1);
						unsignedLongAtput((next2 + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (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: */
						fieldIndex2 = 1;
						assert(isFreeObject(next3));
						assert(1);
						unsignedLongAtput((next3 + 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;
			}
		};
	}
	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: */
		nextFreeChunk1 = unsignedLongAt((chunk + BaseHeaderSize) + (0U << (shiftForWord())));
		/* begin storePointer:ofFreeChunk:withValue: */
		assert(isFreeObject(parent));
		assert((nextFreeChunk1 == 0) || (isFreeObject(nextFreeChunk1)));
		unsignedLongAtput((parent + BaseHeaderSize) + (0U << (shiftForWord())), nextFreeChunk1);
		/* end storePointer:ofFreeChunk:withValue: */
		if ((nextFreeChunk1 != 0) && !0) {
			/* begin storePointer:ofFreeChunk:withValue: */
			assert(isFreeObject(nextFreeChunk1));
			assert((parent == 0) || (isFreeObject(parent)));
			unsignedLongAtput((nextFreeChunk1 + 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 f;
	sqInt fieldIndex;
	sqInt fieldIndex1;
	sqInt fieldIndex2;
	sqInt index;
	usqInt initialIndex;
	sqInt newOop;
	sqInt next;
	sqInt next2;
	sqInt next3;
	sqInt next4;
	sqInt nextFreeChunk;
	sqInt nextFreeChunk1;
	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 l27;
						}
						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: */
										fieldIndex1 = 1;
										assert(isFreeObject(next3));
										assert(1);
										unsignedLongAtput((next3 + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (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 l27;
							}
							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: */
										fieldIndex2 = 1;
										assert(isFreeObject(next4));
										assert(1);
										unsignedLongAtput((next4 + 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 l27;
							}
							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 l27;
					}
				};
				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 l27;
				}
			}
			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: */
				nextFreeChunk1 = unsignedLongAt((acceptedChunk + BaseHeaderSize) + (0U << (shiftForWord())));
				/* begin storePointer:ofFreeChunk:withValue: */
				assert(isFreeObject(acceptedNode));
				assert((nextFreeChunk1 == 0) || (isFreeObject(nextFreeChunk1)));
				unsignedLongAtput((acceptedNode + BaseHeaderSize) + (0U << (shiftForWord())), nextFreeChunk1);
				/* end storePointer:ofFreeChunk:withValue: */
				if ((nextFreeChunk1 != 0) && !0) {
					/* begin storePointer:ofFreeChunk:withValue: */
					assert(isFreeObject(nextFreeChunk1));
					assert((acceptedNode == 0) || (isFreeObject(acceptedNode)));
					unsignedLongAtput((nextFreeChunk1 + 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 l27;
			}
			/* 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 l27;
		}
		GIV(totalFreeOldSpace) += totalBytes;
		chunk = null;
		l27:
		;
		/* 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;
	sqInt o;

	/* 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 l1;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		currentObject = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l1:
		;
		/* 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 fieldIndex1;
	sqInt fieldIndex2;
	sqInt freeNode;
	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 l4;
			}
			cameFrom = -1;
			do{
				assert((bytesInObject(treeNode)) >= ((numFreeLists()) * (allocationUnit())));
				/* begin fetchPointer:ofFreeChunk: */
				fieldIndex1 = 3;
				smallChild = unsignedLongAt((treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (shiftForWord())) ));
				/* end fetchPointer:ofFreeChunk: */
				/* begin fetchPointer:ofFreeChunk: */
				fieldIndex2 = 4;
				largeChild = unsignedLongAt((treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex2 ) << (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);
			l4:
			;
			/* 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 errCode;
	sqInt fieldOffset;
	sqInt fmt;
	sqInt hash;
	sqInt header;
	sqInt header2;
	sqInt i;
	sqInt i2;
	sqInt iLimiT;
	sqInt iLimiT1;
	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 l39;
			}
			assert((ReceiverIndex + (sp >> 3)) < (lengthOf(array1)));
			contextSize = sp >> 3;
			l39:
			;
			/* end fetchStackPointerOf: */
			fieldOffset = (((CtxtTempFrameStart - 1) + contextSize) * BytesPerOop) + BaseHeaderSize;
			goto l35;
		}
		fieldOffset = (((numSlotsOf(array1)) - 1) * BytesPerOop) + BaseHeaderSize;
		goto l35;
	}
	if (fmt < (firstCompiledMethodFormat())) {
		fieldOffset = 0;
		goto l35;
	}
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(array1));
	header2 = unsignedLongAt((array1 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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;
	l35:
	;
	/* 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 l41;
			}
			goto l27;
		}
		if (((((usqInt) (longAt(oop1)) ) >> (pinnedBitShift())) & 1) != 0) {
			{
				ec = PrimErrObjectIsPinned;
				goto l41;
			}
			goto l27;
		}
		if (
#      if IMMUTABILITY
				(/* begin isImmutable: */ ((((usqInt) (longAt(oop1)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#      else /* IMMUTABILITY */
				0
#      endif /* IMMUTABILITY */
				) {
			{
				ec = PrimErrNoModification;
				goto l41;
			}
			goto l27;
		}
		l27:
		;
		/* 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 l41;
				}
				goto l31;
			}
			if (((((usqInt) (longAt(oop2)) ) >> (pinnedBitShift())) & 1) != 0) {
				{
					ec = PrimErrObjectIsPinned;
					goto l41;
				}
				goto l31;
			}
			if (
#        if IMMUTABILITY
					(/* begin isImmutable: */ ((((usqInt) (longAt(oop2)) ) >> (immutableBitShift())) & 1) != 0 /* end isImmutable: */)
#        else /* IMMUTABILITY */
					0
#        endif /* IMMUTABILITY */
					) {
				{
					ec = PrimErrNoModification;
					goto l41;
				}
				goto l31;
			}
			l31:
			;
			/* 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 l41;
			}
		}
		fieldOffset -= BytesPerOop;
	};
	if (size >= (sizeOfLargestFreeChunk())) {
		ec = PrimErrNoMemory;
		goto l41;
	}
	GIV(becomeEffectsFlags) = effectsFlags;
	ec = 0;
	l41:
	;
	/* 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 l15;
				}
				outOfPlaceBecomeandcopyHashFlag(obj1, obj2, copyHashFlag);
				if (copyHashFlag) {
					goto l15;
				}
				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: */
					}
				}
				l15:
				;
				/* 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, iLimiT1 = (numSlotsOf(array1)) - 1; i2 <= iLimiT1; 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 l21;
				}
				if (obj22 & (tagMask())) {
					goto l21;
				}
				if (!(obj12 >= 0x20000000000LL)) {
					goto l21;
				}
				if (obj22 >= 0x20000000000LL) {
					goto l21;
				}
				if ((obj22 >= GIV(nilObj)) && (obj22 <= GIV(trueObj))) {
					goto l21;
				}
				if (!(obj22 >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l21;
				}
				remember(getFromPermToNewSpaceRememberedSet(), obj12);
				l21:
				;
				/* 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 l1;
		}
	}
	long64Atput(newObj, ((((usqLong) numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) objFormat ) << (formatShift())) )) + ClassFloatCompactIndex);
	GIV(freeStart) += numBytes;
	newFloatObj = newObj;
	/* end allocateSmallNewSpaceSlots:format:classIndex: */
	l1:
	;
	/* 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: */
}
/* 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 address1;
	sqInt fi;
	sqInt fieldOop;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	sqInt i;
	sqInt iLimiT;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	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 l6;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l6:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l5;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l5:
		;
		/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress3 = addressAfter(objOop2);
		if (oopisGreaterThanOrEqualTo(followingWordAddress3, limit1)) {
			objOop2 = limit1;
			goto l18;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		objOop2 = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l18:
		;
		/* 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 address1;
	sqInt classIndex;
	sqInt classIndex1;
	sqInt classIndex2;
	sqInt classIndex3;
	sqInt classOop;
	sqInt classTablePage;
	sqInt classTablePage2;
	sqInt classTablePage3;
	int containsYoung;
	sqInt fi;
	sqInt fieldIndex;
	sqInt fieldIndex1;
	sqInt fieldIndex11;
	sqInt fieldIndex12;
	sqInt fieldIndex2;
	sqInt fieldIndex3;
	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 limit1;
	sqInt numOnThisPage;
	int numRememberedObjectsInHeap;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	sqInt objOop;
	sqInt objOop2;
	sqInt objStackPage;
	int ok;
	sqInt page;
	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: */
					classIndex1 = (classIndex = (longAt(objOop)) & (classIndexMask()));
					assert((classIndex1 <= (tagMask())) || (classIndex1 >= (arrayClassIndexPun())));
					/* begin fetchPointer:ofObject: */
					fieldIndex = ((usqInt) classIndex1 ) >> (classTableMajorIndexShift());
					classTablePage = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (classTablePage == GIV(nilObj)) {
						classOop = GIV(nilObj);
						goto l49;
					}
					/* begin fetchPointer:ofObject: */
					fieldIndex1 = classIndex1 & ((1U << (classTableMajorIndexShift())) - 1);
					classOop = unsignedLongAt((classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					l49:
					;
					/* 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 l6;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l6:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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: */
					classIndex2 = (classIndex = (longAt(objOop)) & (classIndexMask()));
					assert((classIndex2 <= (tagMask())) || (classIndex2 >= (arrayClassIndexPun())));
					/* begin fetchPointer:ofObject: */
					fieldIndex2 = ((usqInt) classIndex2 ) >> (classTableMajorIndexShift());
					classTablePage2 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex2 ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (classTablePage2 == GIV(nilObj)) {
						classOop = GIV(nilObj);
						goto l50;
					}
					/* begin fetchPointer:ofObject: */
					fieldIndex11 = classIndex2 & ((1U << (classTableMajorIndexShift())) - 1);
					classOop = unsignedLongAt((classTablePage2 + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex11 ) << (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: */
		followingWordAddress2 = addressAfter(objOop);
		if (oopisGreaterThanOrEqualTo(followingWordAddress2, GIV(freeStart))) {
			objOop = GIV(freeStart);
			goto l5;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l5:
		;
		/* 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: */
						classIndex3 = (classIndex = (longAt(objOop2)) & (classIndexMask()));
						assert((classIndex3 <= (tagMask())) || (classIndex3 >= (arrayClassIndexPun())));
						/* begin fetchPointer:ofObject: */
						fieldIndex3 = ((usqInt) classIndex3 ) >> (classTableMajorIndexShift());
						classTablePage3 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex3 ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						if (classTablePage3 == GIV(nilObj)) {
							classOop = GIV(nilObj);
							goto l51;
						}
						/* begin fetchPointer:ofObject: */
						fieldIndex12 = classIndex3 & ((1U << (classTableMajorIndexShift())) - 1);
						classOop = unsignedLongAt((classTablePage3 + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex12 ) << (shiftForWord())) ));
						/* end fetchPointer:ofObject: */
						l51:
						;
						/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress3 = addressAfter(objOop2);
		if (oopisGreaterThanOrEqualTo(followingWordAddress3, limit1)) {
			objOop2 = limit1;
			goto l46;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		objOop2 = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l46:
		;
		/* 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 l9;
	}
	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: */
	};
	l9:
	;
	/* 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;
}
/*	Attempt to verify that the given obj has a reasonable behavior. The class 
	must be a 
	valid, non-integer oop and must not be nilObj. It must be a pointers 
	object with three 
	or more fields. Finally, the instance specification field of the behavior 
	must match that 
	of the instance. If OK answer true. If not, print reason and answer false. */
/* SpurMemoryManager>>#checkOopHasOkayClass: */
sqInt
checkOopHasOkayClass(usqInt obj)
{
	usqInt objClass;
	sqInt objFormat;

	if (!(checkOkayOop(obj))) {
		return 0;
	}
	objClass = ((usqInt) (fetchClassOfNonImm(obj)) );
	if (objClass & (tagMask())) {
		{
			print("obj ");
			printHex(obj);
			print(" an immediate is not a valid class or behavior");
			/* begin cr */
			print("\n");
			/* end cr */
		}
		return 0;
	}
	if (!(okayOop(objClass))) {
		{
			print("obj ");
			printHex(obj);
			print(" class obj is not ok");
			/* begin cr */
			print("\n");
			/* end cr */
		}
		return 0;
	}
	if (!((((((usqInt) (longAt(objClass)) ) >> (formatShift())) & (formatMask())) <= 5) && ((numSlotsOf(objClass)) >= 3))) {
		{
			print("obj ");
			printHex(obj);
			print(" a class (behavior) must be a pointers object of size >= 3");
			/* begin cr */
			print("\n");
			/* end cr */
		}
		return 0;
	}
	if (((obj & (tagMask())) == 0) && (((((usqInt) (longAt(obj)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat()))) {
		objFormat = (((((usqInt) (longAt(obj)) ) >> (formatShift())) & (formatMask())) | 7) - 7;
	} else {
		objFormat = (((usqInt) (longAt(obj)) ) >> (formatShift())) & (formatMask());
	}
	if ((instSpecOfClassFormat((unsignedLongAt((objClass + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3)) != objFormat) {
		{
			print("obj ");
			printHex(obj);
			print(" and its class (behavior) formats differ");
			/* begin cr */
			print("\n");
			/* end cr */
		}
		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 fieldIndex1;

	assert((classIndex >= 0) && ((classIndex <= (tagMask())) || ((classIndex >= (arrayClassIndexPun())) && (classIndex <= (classIndexMask())))));
	/* 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: */
	fieldIndex1 = classIndex & ((1U << (classTableMajorIndexShift())) - 1);
	return unsignedLongAt((classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (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 fieldIndex1;

	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: */
	fieldIndex1 = classIndex & ((1U << (classTableMajorIndexShift())) - 1);
	assert(!(isForwarded(classTablePage)));
	if (((classTablePage & (tagMask())) == 0) && ((classTablePage & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		int t0;
		int t1;

		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 l2;
	}
	if (objOop & (tagMask())) {
		goto l2;
	}
	if (!(classTablePage >= 0x20000000000LL)) {
		goto l2;
	}
	if (objOop >= 0x20000000000LL) {
		goto l2;
	}
	if ((objOop >= GIV(nilObj)) && (objOop <= GIV(trueObj))) {
		goto l2;
	}
	if (!(objOop >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l2;
	}
	remember(getFromPermToNewSpaceRememberedSet(), classTablePage);
	l2:
	;
	/* end possiblePermObjectStoreInto:value: */
	return unsignedLongAtput((classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (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 fieldIndex1;

	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: */
	fieldIndex1 = classIndex & ((1U << (classTableMajorIndexShift())) - 1);
	return unsignedLongAt((classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (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;
	int destIndex;
	sqInt newLimit;
	sqInt newSize;
	sqInt newStart;
	sqInt newTop;
	sqInt referrer;
	VMRememberedSet * self_in_saveat;
	VMRememberedSet * self_in_setRememberedSetSize;
	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;
	int destIndex;
	sqInt i;
	sqInt i2;
	sqInt newLimit;
	sqInt newSize;
	sqInt newStart;
	sqInt newTop;
	sqInt oop;
	sqInt referrer;
	VMRememberedSet * self_in_rememberedSetWithIndexDo;
	VMRememberedSet * self_in_saveat;
	VMRememberedSet * self_in_setRememberedSetSize;
	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 (i2 = 0; i2 < ((self_in_rememberedSetWithIndexDo->rememberedSetSize)); i2 += 1) {
		oop = (self_in_rememberedSetWithIndexDo->rememberedSetArray)[i2];
		{
			/* 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 objOop;
	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 l1;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l1:
		;
		/* 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 classIndex1;
	sqInt classIndex2;
	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: */
			classIndex1 = (longAt(objOop)) & (classIndexMask());
			newObj = allocateSlotsInOldSpacebytesformatclassIndex(numSlots, ((numSlots == 0)
				 ? 8 + BaseHeaderSize
				 : (numSlots << (shiftForWord())) + (((numSlots >= (numSlotsMask()))
					 ? BaseHeaderSize + BaseHeaderSize
					 : BaseHeaderSize))), fmt, classIndex1);
			/* end allocateSlotsInOldSpace:format:classIndex: */
		} else {
			/* begin allocateSlots:format:classIndex: */
			classIndex2 = (longAt(objOop)) & (classIndexMask());
			/* begin allocateSlots:format:classIndex:isPinned:isOldSpace: */
			if (numSlots >= (numSlotsMask())) {
				if ((((usqInt) numSlots ) >> 56) > 0) {
					newObj = null;
					goto l10;
				}
				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, classIndex2);
					goto l10;
				}
			}
			newObj2 = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(GIV(freeStart), numSlots, fmt, classIndex2, 0);
			assert((numBytes % (allocationUnit())) == 0);
			assert((newObj2 % (allocationUnit())) == 0);
			GIV(freeStart) += numBytes;
			newObj = newObj2;
			/* end allocateSlots:format:classIndex:isPinned:isOldSpace: */
			l10:
			;
			/* 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>>#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 address1;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	usqInt limit;
	sqInt limit1;
	sqInt nm;
	int nu;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt o;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	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: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l7;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l7:
		;
		/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 l7;
			}
			assert((ReceiverIndex + (sp >> 3)) < (lengthOf(objOop)));
			contextSize = sp >> 3;
			l7:
			;
			/* end fetchStackPointerOf: */
			numPointerSlots = CtxtTempFrameStart + contextSize;
			goto l10;
		}
		/* begin numSlotsOf: */
		assert((classIndexOf(objOop)) > (isForwardedObjectClassIndexPun()));
		numSlots3 = byteAt(objOop + 7);
		numPointerSlots = ((numSlots3 == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(objOop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : numSlots3);
		goto l10;
		/* end numSlotsOf: */
	}
	if (fmt2 == 7) {
		numPointerSlots = 1;
		goto l10;
	}
	if (fmt2 < (firstCompiledMethodFormat())) {
		numPointerSlots = 0;
		goto l10;
	}
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(objOop));
	header2 = unsignedLongAt((objOop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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;
	l10:
	;
	/* 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 l12;
	}
	if (newObj & (tagMask())) {
		goto l12;
	}
	if (!(objOop >= 0x20000000000LL)) {
		goto l12;
	}
	if (newObj >= 0x20000000000LL) {
		goto l12;
	}
	if ((newObj >= GIV(nilObj)) && (newObj <= GIV(trueObj))) {
		goto l12;
	}
	if (!(newObj >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l12;
	}
	remember(getFromPermToNewSpaceRememberedSet(), objOop);
	l12:
	;
	/* 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 = (freeStart()) - ((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 address1;
	sqInt anOop;
	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 limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	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 l1;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l1:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 classIndex1;
	sqInt formatField;
	sqInt formatField1;
	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: */
			formatField1 = sixtyFourBitIndexableFormat();
			classIndex1 = sixtyFourBitLongsClassIndexPun();
			freeOrNewPage = allocateSlotsInOldSpacebytesformatclassIndex(ObjStackPageSlots, ((sqInt) (((usqInt) ObjStackPageSlots ) << (shiftForWord())) ) + (BaseHeaderSize + BaseHeaderSize), formatField1, classIndex1);
			/* 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)))) {
				int t0;
				int t1;

				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 l8;
			}
			if (freeOrNewPage & (tagMask())) {
				goto l8;
			}
			if (!(GIV(hiddenRootsObj) >= 0x20000000000LL)) {
				goto l8;
			}
			if (freeOrNewPage >= 0x20000000000LL) {
				goto l8;
			}
			if ((freeOrNewPage >= GIV(nilObj)) && (freeOrNewPage <= GIV(trueObj))) {
				goto l8;
			}
			if (!(freeOrNewPage >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l8;
			}
			remember(getFromPermToNewSpaceRememberedSet(), GIV(hiddenRootsObj));
			l8:
			;
			/* 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)))) {
			int t0;
			int t1;

			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 l11;
		}
		if (freeOrNewPage & (tagMask())) {
			goto l11;
		}
		if (!(GIV(hiddenRootsObj) >= 0x20000000000LL)) {
			goto l11;
		}
		if (freeOrNewPage >= 0x20000000000LL) {
			goto l11;
		}
		if ((freeOrNewPage >= GIV(nilObj)) && (freeOrNewPage <= GIV(trueObj))) {
			goto l11;
		}
		if (!(freeOrNewPage >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l11;
		}
		remember(getFromPermToNewSpaceRememberedSet(), GIV(hiddenRootsObj));
		l11:
		;
		/* 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 numSlots1;
	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: */
			numSlots1 = 1U << (classTableMajorIndexShift());
			assert(oopisLessThan(((page + BaseHeaderSize) + (numSlots1 * BytesPerOop)) - 1, addressAfter(page)));
			for (p = ((usqInt) (page + BaseHeaderSize) ); p <= ((usqInt) (((page + BaseHeaderSize) + (numSlots1 * 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)))) {
				int t0;
				int t1;

				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 l2;
			}
			if (page & (tagMask())) {
				goto l2;
			}
			if (!(GIV(hiddenRootsObj) >= 0x20000000000LL)) {
				goto l2;
			}
			if (page >= 0x20000000000LL) {
				goto l2;
			}
			if ((page >= GIV(nilObj)) && (page <= GIV(trueObj))) {
				goto l2;
			}
			if (!(page >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l2;
			}
			remember(getFromPermToNewSpaceRememberedSet(), GIV(hiddenRootsObj));
			l2:
			;
			/* 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)))) {
					int t0;
					int t1;

					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 l4;
				}
				if (aBehavior & (tagMask())) {
					goto l4;
				}
				if (!(page >= 0x20000000000LL)) {
					goto l4;
				}
				if (aBehavior >= 0x20000000000LL) {
					goto l4;
				}
				if ((aBehavior >= GIV(nilObj)) && (aBehavior <= GIV(trueObj))) {
					goto l4;
				}
				if (!(aBehavior >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l4;
				}
				remember(getFromPermToNewSpaceRememberedSet(), page);
				l4:
				;
				/* 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 address1;
	sqInt classIndex;
	sqInt followingWord;
	sqInt followingWord2;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt limit;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	sqInt objOop;
	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 l1;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l1:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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 fieldIndex1;

	/* 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: */
	fieldIndex1 = classIndex & ((1U << (classTableMajorIndexShift())) - 1);
	return unsignedLongAt((classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (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 address1;
	sqInt cssz;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	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 l7;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 address1;
	sqInt cssz;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	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 l7;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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)))) {
		int t0;
		int t1;

		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 l2;
	}
	if (objOop & (tagMask())) {
		goto l2;
	}
	if (!(anObject >= 0x20000000000LL)) {
		goto l2;
	}
	if (objOop >= 0x20000000000LL) {
		goto l2;
	}
	if ((objOop >= GIV(nilObj)) && (objOop <= GIV(trueObj))) {
		goto l2;
	}
	if (!(objOop >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l2;
	}
	remember(getFromPermToNewSpaceRememberedSet(), anObject);
	l2:
	;
	/* 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)))) {
					int t0;
					int t1;

					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 l5;
				}
				if (oop & (tagMask())) {
					goto l5;
				}
				if (!(objOop >= 0x20000000000LL)) {
					goto l5;
				}
				if (oop >= 0x20000000000LL) {
					goto l5;
				}
				if ((oop >= GIV(nilObj)) && (oop <= GIV(trueObj))) {
					goto l5;
				}
				if (!(oop >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l5;
				}
				remember(getFromPermToNewSpaceRememberedSet(), objOop);
				l5:
				;
				/* 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;
}
/*	Make sure the obj at fieldIndex in anObject is not forwarded (follow the 
	forwarder there-in if so). Answer the (possibly followed) obj at 
	fieldIndex.  */
/* SpurMemoryManager>>#followObjField:ofObject: */
static sqInt NoDbgRegParms
followObjFieldofObject(sqInt fieldIndex, sqInt anObject)
{
	sqInt objOop;

	/* begin fetchPointer:ofObject: */
	objOop = unsignedLongAt((anObject + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	assert(isNonImmediate(objOop));
	if (((long64At(objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		objOop = fixFollowedFieldofObjectwithInitialValue(fieldIndex, anObject, objOop);
	}
	return objOop;
}
/* 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;
	sqInt address;
	sqInt aValue;
	usqLong compactionStartUsecs;
	usqLong gcMarkEndUsecs;
	sqInt i;
	int index;
	sqLong newRememberedSetSize;
	usqInt numSlots;
	sqInt obj;
	sqInt objOop;
	sqInt segIndex;
	VMRememberedSet * self_in_removeObjectAt;

	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);
	GIV(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);
	GIV(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) - GIV(compactionStartUsecs);
	if (!(GIV(gcSweepEndUsecs) == 0)) {
		GIV(statSweepUsecs) += GIV(gcSweepEndUsecs) - GIV(compactionStartUsecs);
	}
	GIV(statMarkUsecs) += GIV(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: */
				}
			}
			sqMakeMemoryNotExecutableFromTo((segInfo->segStart), ((segInfo->segSize)) + ((segInfo->segStart)));
			/* 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 referenced;
	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)))) {
					int t0;
					int t1;

					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 l5;
				}
				if (referenced2 & (tagMask())) {
					goto l5;
				}
				if (!(objOop >= 0x20000000000LL)) {
					goto l5;
				}
				if (referenced2 >= 0x20000000000LL) {
					goto l5;
				}
				if ((referenced2 >= GIV(nilObj)) && (referenced2 <= GIV(trueObj))) {
					goto l5;
				}
				if (!(referenced2 >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l5;
				}
				remember(getFromPermToNewSpaceRememberedSet(), objOop);
				l5:
				;
				/* 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 referenced;
	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)))) {
					int t0;
					int t1;

					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 l5;
				}
				if (referenced2 & (tagMask())) {
					goto l5;
				}
				if (!(objOop >= 0x20000000000LL)) {
					goto l5;
				}
				if (referenced2 >= 0x20000000000LL) {
					goto l5;
				}
				if ((referenced2 >= GIV(nilObj)) && (referenced2 <= GIV(trueObj))) {
					goto l5;
				}
				if (!(referenced2 >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l5;
				}
				remember(getFromPermToNewSpaceRememberedSet(), objOop);
				l5:
				;
				/* 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 address1;
	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 limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	sqInt objOop4;
	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 l1;
	}
	/* begin tenuringClassIndex: */
	GIV(tenuringClassIndex) = classIndex2;
	/* end tenuringClassIndex: */
	scavengingGCTenuringIf(TenureByClass);
	assert(!(existInstancesInNewSpaceOf(classObj)));
	l1:
	;
	/* 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 l7;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 address1;
	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 fieldIndex1;
	sqInt fieldIndex2;
	sqInt fieldIndex3;
	sqInt fieldIndex4;
	sqInt fieldOop;
	sqInt fieldOop2;
	sqInt firstObj;
	sqInt followingWord;
	sqInt followingWord2;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	sqInt freeChunk;
	sqInt freeListObj;
	sqInt freeNode;
	usqInt freeOldStart;
	sqInt i;
	sqInt i2;
	sqInt i3;
	sqInt iLimiT;
	sqInt iLimiT1;
	sqInt index;
	sqInt largeChild;
	usqInt limit;
	sqInt limit1;
	int min;
	sqInt nilObjPreSwizzle;
	usqInt numSlots;
	usqInt numSlots2;
	usqInt numSlots3;
	sqInt obj;
	sqInt oop;
	sqInt smallChild;
	usqInt startOfFreeOldSpace;
	sqInt treeNode;
	sqInt valuePointer;
	sqInt valuePointer2;

	assert(BaseHeaderSize == BaseHeaderSize);
	assert(((sqInt) ((maxSlotsForAlloc()) * BytesPerWord) ) > 0);
	{
		initSegmentBridgeWithBytesat(2 * BaseHeaderSize, ((GIV(memoryMap)->oldSpaceEnd)) - (2 * BaseHeaderSize));
	}
	/* begin adjustAllOopsBy: */
	assert(newSpaceIsEmpty());
	/* begin countNumClassPagesPreSwizzle: */
	/* begin objectStartingAt: */
	address1 = ((sqInt) ((GIV(memoryMap)->oldSpaceStart)) );
	numSlots3 = byteAt(address1 + 7);
	firstObj = ((numSlots3 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l22;
		}
	};
	l22:
	;
	/* end countNumClassPagesPreSwizzle: */
	if ((bytesToShift == 0) && ((numSegments()) == 1)) {
		goto l24;
	}
	/* 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: */
				fieldIndex3 = 0;
				field = unsignedLongAt((obj + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex3 ) << (shiftForWord())) ));
				/* end fetchPointer:ofFreeChunk: */
				if (field != 0) {
					/* begin storePointerNoAssert:ofFreeChunk:withValue: */
					fieldIndex4 = 0;
					valuePointer = swizzleObj(field);
					unsignedLongAtput((obj + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex4 ) << (shiftForWord())) ), valuePointer);
					/* end storePointerNoAssert:ofFreeChunk:withValue: */
				}
				chunkBytes = bytesInObject(obj);
				;
				if (chunkBytes >= (64 * 8)) {
					for (index = 2, iLimiT1 = 4; index <= iLimiT1; index += 1) {
						/* begin fetchPointer:ofFreeChunk: */
						field = unsignedLongAt((obj + BaseHeaderSize) + ((sqInt) (((usqInt) index ) << (shiftForWord())) ));
						/* end fetchPointer:ofFreeChunk: */
						if (field != 0) {
							/* begin storePointerNoAssert:ofFreeChunk:withValue: */
							valuePointer2 = swizzleObj(field);
							unsignedLongAtput((obj + BaseHeaderSize) + ((sqInt) (((usqInt) index ) << (shiftForWord())) ), valuePointer2);
							/* end storePointerNoAssert:ofFreeChunk:withValue: */
						}
					};
				}
				/* end swizzleFieldsOfFreeChunk: */
			}
		}
		/* begin objectAfter:limit: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress = addressAfter(obj);
		if (oopisGreaterThanOrEqualTo(followingWordAddress, limit1)) {
			obj = limit1;
			goto l21;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		obj = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l21:
		;
		/* 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 l12;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		currentObject = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l12:
		;
		/* end objectAfter:limit: */
	};
	/* end allPermSpaceObjectsDo: */
	l24:
	;
	/* 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 l6;
		}
	};
	GIV(classTableIndex) = 1U << (classTableMajorIndexShift());
	l6:
	;
	/* 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 l9;
	}
	cameFrom = -1;
	do{
		assert((bytesInObject(treeNode)) >= ((numFreeLists()) * (allocationUnit())));
		/* begin fetchPointer:ofFreeChunk: */
		fieldIndex1 = 3;
		smallChild = unsignedLongAt((treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (shiftForWord())) ));
		/* end fetchPointer:ofFreeChunk: */
		/* begin fetchPointer:ofFreeChunk: */
		fieldIndex2 = 4;
		largeChild = unsignedLongAt((treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex2 ) << (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);
	l9:
	;
	/* 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 classIndex;
	sqInt err;
	sqInt hash;
	int hasToScheduleScavenge;
	sqInt instSpec;
	sqInt newObj;
	sqInt newObj2;
	usqInt numBytes;
	sqInt numSlots;
	usqInt p;

	classFormat = (unsignedLongAt((classObj + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	instSpec = (((usqInt) classFormat ) >> (fixedFieldsFieldWidth())) & (formatMask());
	if (!((instSpec <= 1) || (instSpec == 5))) {
		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 l3;
		}
		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 l3;
		} else {
			newObj = allocateSlotsInOldSpacebytesformatclassIndex(numSlots, numBytes, instSpec, classIndex);
			goto l3;
		}
	}
	newObj2 = initializeHeaderOfStartAddressnumSlotsformatclassIndexpinned(GIV(freeStart), numSlots, instSpec, classIndex, 0);
	assert((numBytes % (allocationUnit())) == 0);
	assert((newObj2 % (allocationUnit())) == 0);
	GIV(freeStart) += numBytes;
	newObj = newObj2;
	l3:
	;
	/* 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, 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 entry;
	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;
}
/* 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 aForwardedPermSpaceObject;
	sqInt anObj;
	sqInt currentObject;
	sqInt followingWord;
	usqInt followingWordAddress;
	int isValid;
	sqInt objOop;
	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 l2;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		currentObject = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l2:
		;
		/* 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;
	sqInt i;
	sqInt i2;
	sqInt isInPermToNewRememberedSet;
	sqInt isInPermToOldRememberedSet;
	VMRememberedSet * self_in_isInRememberedSet;
	VMRememberedSet * self_in_isInRememberedSet1;

	/* 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 l1;
		}
	};
	isInPermToNewRememberedSet = 0;
	l1:
	;
	/* end isInRememberedSet: */
	/* begin isInRememberedSet: */
	/* begin getFromPermToOldSpaceRememberedSet */
	self_in_isInRememberedSet1 = GIV(fromPermToOldSpaceRememberedSet);
	/* end getFromPermToOldSpaceRememberedSet */
	for (i2 = 0; i2 < ((self_in_isInRememberedSet1->rememberedSetSize)); i2 += 1) {
		if (((self_in_isInRememberedSet1->rememberedSetArray)[i2]) == objOop) {
			isInPermToOldRememberedSet = 1;
			goto l2;
		}
	};
	isInPermToOldRememberedSet = 0;
	l2:
	;
	/* 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 fieldIndex1;

	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 l2;
	}
	/* begin fetchPointer:ofObject: */
	fieldIndex1 = classIndex & ((1U << (classTableMajorIndexShift())) - 1);
	classOrNil = unsignedLongAt((classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	l2:
	;
	/* 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));
	header2 = unsignedLongAt((objOop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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 l2;
			}
			assert((ReceiverIndex + (sp >> 3)) < (lengthOf(objOop)));
			contextSize = sp >> 3;
			l2:
			;
			/* end fetchStackPointerOf: */
			return (((CtxtTempFrameStart - 1) + contextSize) * BytesPerOop) + BaseHeaderSize;
		}
		return (((numSlotsOf(objOop)) - 1) * BytesPerOop) + BaseHeaderSize;
	}
	if (fmt < (firstCompiledMethodFormat())) {
		return 0;
	}
	/* begin methodHeaderOf: */
	assert(isCompiledMethod(objOop));
	header2 = unsignedLongAt((objOop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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));
	header2 = unsignedLongAt((methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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 address1;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop2);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop2 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop2 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l7;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 address1;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	sqInt i;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	usqInt numSlots3;
	sqInt obj;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	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: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l7;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l7:
		;
		/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 i;
	sqInt i2;
	sqInt mourner;
	sqInt numOnThisPage;
	sqInt objStackPage;
	sqInt page;
	sqInt referent;

	/* begin objStack:do: */
	if (GIV(mournQueue) == GIV(nilObj)) {
		goto l7;
	}
	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: */
	};
	l7:
	;
	/* 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 fieldIndex1;
	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 l4;
	}
	/* begin fetchPointer:ofObject: */
	fieldIndex1 = classIndex & ((1U << (classTableMajorIndexShift())) - 1);
	classObj = unsignedLongAt((classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	l4:
	;
	/* 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 *aRememberedSet1;
	sqInt i;
	sqInt i2;
	sqInt i22;
	sqInt i3;
	sqInt i4;
	sqInt objOop;
	sqInt objOop1;
	sqInt objOop2;
	sqInt objOop4;
	sqInt objOop5;
	sqInt objStackRootIndex;
	sqInt objStackRootIndex1;
	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 */
	aRememberedSet1 = GIV(fromPermToNewSpaceRememberedSet);
	/* end getFromPermToNewSpaceRememberedSet */
	/* begin objStackAt: */
	objStackRootIndex1 = (aRememberedSet1->rootIndex);
	/* begin fetchPointer:ofObject: */
	rememberedSetOop2 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) objStackRootIndex1 ) << (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 (i22 = 0; i22 < ((aRememberedSet1->rememberedSetSize)); i22 += 1) {
		objOop5 = (aRememberedSet1->rememberedSetArray)[i22];
		{
			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: */
	objOop1 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) OldRememberedSetRootIndex ) << (shiftForWord())) ));
	assert(!(isFreeObject(objOop1)));
	unsignedLongAtput(objOop1, (unsignedLongAt(objOop1)) | (1ULL << (markedBitFullShift())));
	/* end setIsMarkedOf:to: */
	/* begin setIsMarkedOf:to: */
	{
		assert((firstIndexableField(oldSpaceObjectAfter(GIV(trueObj)))) == GIV(freeLists));
		objOop2 = oldSpaceObjectAfter(GIV(trueObj));
	}
	assert(!(isFreeObject(objOop2)));
	unsignedLongAtput(objOop2, (unsignedLongAt(objOop2)) | (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 format2;
	sqInt format22;
	sqInt header;
	sqInt header2;
	sqInt index;
	sqInt key;
	sqInt key2;
	sqInt numLiterals;
	usqInt numSlots;
	usqInt numSlots2;
	usqInt numSlots3;
	usqInt numStrongSlots;
	sqInt objOop1;
	sqInt objOop11;
	sqInt objOop2;
	sqInt objStack;
	sqInt objStack1;
	sqInt objStack2;
	sqInt objStack3;
	sqInt objStack4;
	sqInt objStack5;
	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: */
		}
		format2 = (((usqInt) (longAt(objOop)) ) >> (formatShift())) & (formatMask());
		if ((format2 >= (sixtyFourBitIndexableFormat())) && (format2 < (firstCompiledMethodFormat()))) {
			if (((longAt(objOop)) & (classIndexMask())) > (lastClassIndexPun())) {
				markAndTraceClassOf(objOop);
			}
			{
				return;
			}
		}
		if (format2 == (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 ((format2 == 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 l14;
					}
					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 l14;
						}
						numStrongSlots = ((sqInt) numSlots3 );
						goto l14;
					}
					if (fmt == (weakArrayFormat())) {
						/* begin fixedFieldsOfClass: */
						objOop11 = fetchClassOfNonImm(objToScan);
						/* begin fixedFieldsOfClassFormat: */
						classFormat = (unsignedLongAt((objOop11 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
						numStrongSlots = classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
						goto l14;
						/* end fixedFieldsOfClassFormat: */
						/* end fixedFieldsOfClass: */
					}
				}
				if (fmt == 7) {
					numStrongSlots = 1;
					goto l14;
				}
				if (fmt < (firstCompiledMethodFormat())) {
					numStrongSlots = 0;
					goto l14;
				}
				/* begin methodHeaderOf: */
				assert(isCompiledMethod(objToScan));
				header2 = unsignedLongAt((objToScan + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				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;
				l14:
				;
				/* 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 l3;
						}
						assert(!(isForwarded(field)));
						if (((((usqInt) (longAt(field)) ) >> (markedBitFullShift())) & 1) != 0) {
							assert(!(isPermanentObject(GIV(memoryMap), field)));
							goto l3;
						}
						if (!(field >= 0x20000000000LL)) {
							/* begin setIsMarkedOf:to: */
							assert(!(isFreeObject(field)));
							unsignedLongAtput(field, (unsignedLongAt(field)) | (1ULL << (markedBitFullShift())));
							/* end setIsMarkedOf:to: */
						}
						format22 = (((usqInt) (longAt(field)) ) >> (formatShift())) & (formatMask());
						if ((format22 >= (sixtyFourBitIndexableFormat())) && (format22 < (firstCompiledMethodFormat()))) {
							if (((longAt(field)) & (classIndexMask())) > (lastClassIndexPun())) {
								markAndTraceClassOf(field);
							}
							goto l3;
						}
						if (format22 == (weakArrayFormat())) {
							/* begin push:onObjStack: */
							objStack5 = GIV(weaklingStack);
							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: */
							goto l3;
						}
						if ((format22 == 5) && (activeAndDeferredScan(field))) {
							goto l3;
						}
						if (index > 0) {
							if ((topOfObjStack(GIV(markStack))) != objToScan) {
								/* begin push:onObjStack: */
								objStack1 = GIV(markStack);
								assert(addressCouldBeOop(objToScan));
								if (objToScan & (tagMask())) {
									assert(objStack1 == GIV(markStack));
									assert(addressCouldBeObj(topOfObjStack(((0 == (fetchPointerofObject(ObjStackTopx, objStack1)))
										 ? fetchPointerofObject(ObjStackNextx, objStack1)
										 : objStack1))));
								} else {
									assert(!((objStack1 == GIV(markStack)) && (isWeakNonImm(objToScan))));
									assert((objStack1 != GIV(weaklingStack)) || (isWeakNonImm(objToScan)));
								}
								noCheckPushonObjStack(objToScan, objStack1);
								/* end push:onObjStack: */
							}
							/* begin push:onObjStack: */
							objOop1 = ((((usqInt) index ) << 3) | 1);
							objStack2 = GIV(markStack);
							assert(addressCouldBeOop(objOop1));
							if (objOop1 & (tagMask())) {
								assert(objStack2 == GIV(markStack));
								assert(addressCouldBeObj(topOfObjStack(((0 == (fetchPointerofObject(ObjStackTopx, objStack2)))
									 ? fetchPointerofObject(ObjStackNextx, objStack2)
									 : objStack2))));
							} else {
								assert(!((objStack2 == GIV(markStack)) && (isWeakNonImm(objOop1))));
								assert((objStack2 != GIV(weaklingStack)) || (isWeakNonImm(objOop1)));
							}
							noCheckPushonObjStack(objOop1, objStack2);
							/* end push:onObjStack: */
						}
						objToScan = field;
						index = -1;
						l3:
						;
					}
				}
			};
			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: */
						objStack4 = GIV(markStack);
						assert(addressCouldBeOop(field));
						if (field & (tagMask())) {
							assert(objStack4 == GIV(markStack));
							assert(addressCouldBeObj(topOfObjStack(((0 == (fetchPointerofObject(ObjStackTopx, objStack4)))
								 ? fetchPointerofObject(ObjStackNextx, objStack4)
								 : objStack4))));
						} else {
							assert(!((objStack4 == GIV(markStack)) && (isWeakNonImm(field))));
							assert((objStack4 != GIV(weaklingStack)) || (isWeakNonImm(field)));
						}
						noCheckPushonObjStack(field, objStack4);
						/* end push:onObjStack: */
						if (((byteAt(field + 7)) > 64) && (((numStrongSlots = numStrongSlotsOfInephemeral(field))) > 64)) {
							/* begin push:onObjStack: */
							objOop2 = ((numStrongSlots << 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 = 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 i5;
	sqInt iLimiT;
	sqInt iLimiT1;
	sqInt j;
	sqInt oop;
	usqInt oop2;
	sqInt referent;
	sqInt referent2;
	sqInt referent22;
	sqInt referent3;
	sqInt referent4;
	StackPage *thePage;
	char *theSP;
	sqInt toDoLimit1;

	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 */
	}
	for (i2 = 0; i2 < GIV(numStackPages); i2 += 1) {
		/* begin stackPageAt: */
		thePage = stackPageAtpages(i2, GIV(pages));
		/* end stackPageAt: */
		(thePage->trace = StackPageUnreached);
	};
	/* end initStackPageGC */
	markAndTraceHiddenRoots();
	/* begin markAndTraceExtraRoots */
	assert(GIV(remapBufferCount) == 0);
	for (i3 = 1; i3 <= GIV(extraRootCount); i3 += 1) {
		oop = GIV(extraRoots)[i3][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 (i5 = 1, iLimiT1 = remapBufferCount(); i5 <= iLimiT1; i5 += 1) {
		oop2 = GIV(remapBuffer)[i5];
		if (!(oop2 & (tagMask()))) {
			markAndTrace(oop2);
		}
	};
	for (i5 = 1; i5 <= GIV(jmpDepth); i5 += 1) {
		oop2 = GIV(suspendedCallbacks)[i5];
		if (!(oop2 & (tagMask()))) {
			markAndTrace(oop2);
		}
		oop2 = GIV(suspendedMethods)[i5];
		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, iLimiT = (1U << (classTableMajorIndexShift())) - 1; j <= iLimiT; 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), toDoLimit1 = ((GIV(permSpaceForwardersToCleanUp)->top)) - BytesPerOop; anAddress <= toDoLimit1; 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 ephemeron1;
	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: */
				ephemeron1 = longAt(p);
				{
					/* begin queueMourner: */
					assert((isNonImmediate(ephemeron1)) && (((formatOf(ephemeron1)) == (ephemeronFormat())) || ((formatOf(ephemeron1)) == (weakArrayFormat()))));
					assert(!(((formatOf(ephemeron1)) == (ephemeronFormat())) && (isonObjStack(ephemeron1, GIV(mournQueue)))));
					/* begin push:onObjStack: */
					objStack = GIV(mournQueue);
					assert(addressCouldBeOop(ephemeron1));
					if (ephemeron1 & (tagMask())) {
						assert(objStack == GIV(markStack));
						assert(addressCouldBeObj(topOfObjStack(((0 == (fetchPointerofObject(ObjStackTopx, objStack)))
							 ? fetchPointerofObject(ObjStackNextx, objStack)
							 : objStack))));
					} else {
						assert(!((objStack == GIV(markStack)) && (isWeakNonImm(ephemeron1))));
						assert((objStack != GIV(weaklingStack)) || (isWeakNonImm(ephemeron1)));
					}
					noCheckPushonObjStack(ephemeron1, objStack);
					/* end push:onObjStack: */
					/* end queueMourner: */
					/* begin setFormatOf:to: */
					assert((1 >= 0) && (1 <= (formatMask())));
					longAtput(ephemeron1, ((longAt(ephemeron1)) & (~((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))) {
		int t5;
		int t6;

		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 objOop1;

	/* begin fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	objOop = unsignedLongAt((objOop1 + 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 anObj;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	sqInt limit;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop3;
	sqInt permObj;
	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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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 l1;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		currentObject = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l1:
		;
		/* 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)))) {
				int t0;
				int t1;

				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 l5;
			}
			if (newObj & (tagMask())) {
				goto l5;
			}
			if (!(anArrayOop >= 0x20000000000LL)) {
				goto l5;
			}
			if (newObj >= 0x20000000000LL) {
				goto l5;
			}
			if ((newObj >= GIV(nilObj)) && (newObj <= GIV(trueObj))) {
				goto l5;
			}
			if (!(newObj >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l5;
			}
			remember(getFromPermToNewSpaceRememberedSet(), anArrayOop);
			l5:
			;
			/* 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 fieldIndex1;

	/* 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: */
	fieldIndex1 = classIndex & ((1U << (classTableMajorIndexShift())) - 1);
	return unsignedLongAt((classTablePage + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (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 l2;
			}
			assert((ReceiverIndex + (sp >> 3)) < (lengthOf(objOop)));
			contextSize = sp >> 3;
			l2:
			;
			/* 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));
	header2 = unsignedLongAt((objOop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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 objOop1;
	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 l3;
				}
				assert((ReceiverIndex + (sp >> 3)) < (lengthOf(objOop)));
				contextSize = sp >> 3;
				l3:
				;
				/* end fetchStackPointerOf: */
				return CtxtTempFrameStart + contextSize;
			}
			return numSlots;
		}
		if (fmt == (weakArrayFormat())) {
			/* begin fixedFieldsOfClass: */
			objOop1 = fetchClassOfNonImm(objOop);
			/* begin fixedFieldsOfClassFormat: */
			classFormat = (unsignedLongAt((objOop1 + 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));
	header2 = unsignedLongAt((objOop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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 objOop1;

	assert((formatOf(objOop)) == (weakArrayFormat()));
	/* begin fixedFieldsOfClass: */
	objOop1 = fetchClassOfNonImm(objOop);
	/* begin fixedFieldsOfClassFormat: */
	classFormat = (unsignedLongAt((objOop1 + 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 limit1;
	sqInt limit2;

	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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->permSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			return limit1;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		return (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		/* end objectAfter:limit: */
	} else {
		/* begin objectAfter:limit: */
		limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress5 = addressAfter(objOop);
		if (oopisGreaterThanOrEqualTo(followingWordAddress5, limit2)) {
			return limit2;
		}
		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 address1;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt o;
	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 l1;
			}
			flag("endianness");
			followingWord = unsignedLongAt(followingWordAddress);
			objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress + BaseHeaderSize
				 : followingWordAddress);
			l1:
			;
			/* end objectAfter:limit: */
		};
		/* begin objectStartingAt: */
		address1 = ((eden()).start);
		numSlots2 = byteAt(address1 + 7);
		objOop2 = ((numSlots2 == (numSlotsMask()))
			 ? address1 + BaseHeaderSize
			 : address1);
		/* 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 l2;
			}
			flag("endianness");
			followingWord2 = unsignedLongAt(followingWordAddress2);
			objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress2 + BaseHeaderSize
				 : followingWordAddress2);
			l2:
			;
			/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress3 = addressAfter(objOop3);
		if (oopisGreaterThanOrEqualTo(followingWordAddress3, limit1)) {
			objOop3 = limit1;
			goto l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		objOop3 = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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: */
}
/*	Verify that the given oop is legitimate. Check address, header, and size 
	but not class. */
/* SpurMemoryManager>>#okayOop: */
static sqInt NoDbgRegParms
okayOop(sqInt signedOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt classIndex;
	sqInt fmt;
	usqInt oop;
	usqLong unusedBits;
	int unusedBitsInYoungObjects;

	oop = ((usqInt) signedOop );
	if (oop & (tagMask())) {
		return 1;
	}
	if (!(addressCouldBeObj(oop))) {
		error("oop is not a valid address");
		return 0;
	}
	if (!(oopisLessThanOrEqualTo(addressAfter(oop), (GIV(memoryMap)->oldSpaceEnd)))) {
		error("oop size would make it extend beyond the end of memory");
		return 0;
	}
	if (!(((classIndex = (longAt(oop)) & (classIndexMask()))) >= (firstClassIndexPun()))) {
		error("oop is a free chunk, or bridge, not an object");
		return 0;
	}
	if (((byteAt(oop + 7)) == (numSlotsMask())) && ((byteAt((oop - BaseHeaderSize) + 7)) != (numSlotsMask()))) {
		error("oop 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)) {
		error("oop has an unknown format type");
		return 0;
	}
	if ((fmt == 7) != (classIndex == (isForwardedObjectClassIndexPun()))) {
		error("oop 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) {
		error("some unused header bits are set; should be zero");
		return 0;
	}
	unusedBitsInYoungObjects = ((1U << (greyBitShift())) | (1U << (pinnedBitShift()))) | (1U << (rememberedBitShift()));
	if (((longAt(oop)) & unusedBitsInYoungObjects) != 0) {
		error("some header bits unused in young objects are set; should be zero");
		return 0;
	}
	return 1;
}
/*	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 classIndex1;
	sqInt clone1;
	sqInt clone2;
	sqInt hash;
	sqInt hash1;
	sqInt hash2;
	sqInt hash3;

	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: */
		hash1 = (uint32AtPointer(obj2 + 4)) & (identityHashHalfWordMask());
		assert((hash1 >= 0) && (hash1 <= (identityHashHalfWordMask())));
		uint32AtPointerput(clone2 + 4, (((uint32AtPointer(clone2 + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + hash1);
		/* end setHashBitsOf:to: */
	} else {
		/* begin setHashBitsOf:to: */
		hash2 = (uint32AtPointer(obj2 + 4)) & (identityHashHalfWordMask());
		assert((hash2 >= 0) && (hash2 <= (identityHashHalfWordMask())));
		uint32AtPointerput(clone1 + 4, (((uint32AtPointer(clone1 + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + hash2);
		/* end setHashBitsOf:to: */
		/* begin setHashBitsOf:to: */
		hash3 = (uint32AtPointer(obj1 + 4)) & (identityHashHalfWordMask());
		assert((hash3 >= 0) && (hash3 <= (identityHashHalfWordMask())));
		uint32AtPointerput(clone2 + 4, (((uint32AtPointer(clone2 + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + hash3);
		/* 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 l4;
		}
		if (clone2 & (tagMask())) {
			goto l4;
		}
		if (!(obj1 >= 0x20000000000LL)) {
			goto l4;
		}
		if (clone2 >= 0x20000000000LL) {
			goto l4;
		}
		if ((clone2 >= GIV(nilObj)) && (clone2 <= GIV(trueObj))) {
			goto l4;
		}
		if (!(clone2 >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l4;
		}
		remember(getFromPermToNewSpaceRememberedSet(), obj1);
		l4:
		;
		/* 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: */
		classIndex1 = isForwardedObjectClassIndexPun();
		assert((classIndex1 >= 0) && (classIndex1 <= (classIndexMask())));
		assert((7 >= 0) && (7 <= (formatMask())));
		longAtput(obj2, ((longAt(obj2)) & (~((usqIntptr_t) (((sqInt) (((usqInt) (formatMask()) ) << (formatShift())) ) + (classIndexMask())) ))) + (classIndex1 + (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 l6;
		}
		if (clone1 & (tagMask())) {
			goto l6;
		}
		if (!(obj2 >= 0x20000000000LL)) {
			goto l6;
		}
		if (clone1 >= 0x20000000000LL) {
			goto l6;
		}
		if ((clone1 >= GIV(nilObj)) && (clone1 <= GIV(trueObj))) {
			goto l6;
		}
		if (!(clone1 >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l6;
		}
		remember(getFromPermToNewSpaceRememberedSet(), obj2);
		l6:
		;
		/* 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;
	}
}
/*	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 l1;
			}
		};
		seg = null;
		l1:
		;
		/* 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 l6;
		}
		if (oldClone & (tagMask())) {
			goto l6;
		}
		if (!(objOop >= 0x20000000000LL)) {
			goto l6;
		}
		if (oldClone >= 0x20000000000LL) {
			goto l6;
		}
		if ((oldClone >= GIV(nilObj)) && (oldClone <= GIV(trueObj))) {
			goto l6;
		}
		if (!(oldClone >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l6;
		}
		remember(getFromPermToNewSpaceRememberedSet(), objOop);
		l6:
		;
		/* 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)))) {
		int t0;
		int t1;

		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 l10;
	}
	if (195948557 & (tagMask())) {
		goto l10;
	}
	if (!(objStack >= 0x20000000000LL)) {
		goto l10;
	}
	;
	if ((195948557 >= GIV(nilObj)) && (195948557 <= GIV(trueObj))) {
		goto l10;
	}
	if (!(195948557 >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l10;
	}
	remember(getFromPermToNewSpaceRememberedSet(), objStack);
	l10:
	;
	/* 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)))) {
			int t0;
			int t1;

			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 l8;
		}
		if (nextPage & (tagMask())) {
			goto l8;
		}
		if (!(GIV(hiddenRootsObj) >= 0x20000000000LL)) {
			goto l8;
		}
		if (nextPage >= 0x20000000000LL) {
			goto l8;
		}
		if ((nextPage >= GIV(nilObj)) && (nextPage <= GIV(trueObj))) {
			goto l8;
		}
		if (!(nextPage >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l8;
		}
		remember(getFromPermToNewSpaceRememberedSet(), GIV(hiddenRootsObj));
		l8:
		;
		/* 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 & BecamePointerObjectFlag)) {
		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)))) {
						int t0;
						int t1;

						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 l6;
					}
					if (classOrNil & (tagMask())) {
						goto l6;
					}
					if (!(page >= 0x20000000000LL)) {
						goto l6;
					}
					if (classOrNil >= 0x20000000000LL) {
						goto l6;
					}
					if ((classOrNil >= GIV(nilObj)) && (classOrNil <= GIV(trueObj))) {
						goto l6;
					}
					if (!(classOrNil >= (startOfObjectMemory(GIV(memoryMap))))) {
						goto l6;
					}
					remember(getFromPermToNewSpaceRememberedSet(), page);
					l6:
					;
					/* 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 address1;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	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 l7;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 address1;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	sqInt i;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	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 l7;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 address1;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt objOop;
	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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop2);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop2 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop2 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l7;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop3 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop3 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop3 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 address1;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt o;
	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 l1;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l1:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress3 = addressAfter(objOop2);
		if (oopisGreaterThanOrEqualTo(followingWordAddress3, limit1)) {
			objOop2 = limit1;
			goto l7;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		objOop2 = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l7:
		;
		/* 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 *p1;
	void *p2;
	void *p3;
	void *p4;
	void *p5;

	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: */
		p1 = ((void *) (unsignedLongAt((freeChunk + BaseHeaderSize) + (0U << (shiftForWord())))) );
		printHexnp(oopForPointer(p1));
		/* end printHexPtrnp: */
	}
	if (!((assert(numBytes >= (BaseHeaderSize + (allocationUnit()))), numBytes == (BaseHeaderSize + 8)))) {
		{
			print(" prev ");
			/* begin printHexPtrnp: */
			p2 = ((void *) (unsignedLongAt((freeChunk + BaseHeaderSize) + (1U << (shiftForWord())))) );
			printHexnp(oopForPointer(p2));
			/* end printHexPtrnp: */
		}
	}
	if ((numBytes >= (64 * 8)) && printAsTreeNode) {
		{
			print(" ^ ");
			/* begin printHexPtrnp: */
			p3 = ((void *) (unsignedLongAt((freeChunk + BaseHeaderSize) + (2U << (shiftForWord())))) );
			printHexnp(oopForPointer(p3));
			/* end printHexPtrnp: */
			print(" < ");
			/* begin printHexPtrnp: */
			p4 = ((void *) (unsignedLongAt((freeChunk + BaseHeaderSize) + (3U << (shiftForWord())))) );
			printHexnp(oopForPointer(p4));
			/* end printHexPtrnp: */
			print(" > ");
			/* begin printHexPtrnp: */
			p5 = ((void *) (unsignedLongAt((freeChunk + BaseHeaderSize) + (4U << (shiftForWord())))) );
			printHexnp(oopForPointer(p5));
			/* 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 address1;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop2);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop2 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop2 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l7;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 classOrNil;
	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 address1;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	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 l7;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 address1;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	sqInt i;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	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 l7;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 address1;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop2);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop2 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop2 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l7;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 address1;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	usqInt limit;
	sqInt limit1;
	int n;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt o;
	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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop2);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop2 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop2 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l7;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 address1;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	usqInt limit;
	sqInt limit1;
	int n;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt o;
	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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop2);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop2 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop2 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l7;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l7:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 address1;
	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 limit1;
	sqInt numLiterals;
	usqInt numSlots;
	usqInt numSlots2;
	usqInt numSlots3;
	sqInt obj;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	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 l13;
						}
						assert((ReceiverIndex + (sp >> 3)) < (lengthOf(objOop2)));
						contextSize = sp >> 3;
						l13:
						;
						/* end fetchStackPointerOf: */
						i = ((usqInt) (CtxtTempFrameStart + contextSize) );
						goto l12;
					}
					/* begin numSlotsOf: */
					assert((classIndexOf(objOop2)) > (isForwardedObjectClassIndexPun()));
					numSlots = byteAt(objOop2 + 7);
					i = ((numSlots == (numSlotsMask()))
						 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(objOop2 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
						 : numSlots);
					goto l12;
					/* end numSlotsOf: */
				}
				if (fmt == 7) {
					i = 1;
					goto l12;
				}
				if (fmt < (firstCompiledMethodFormat())) {
					i = 0;
					goto l12;
				}
				/* begin methodHeaderOf: */
				assert(isCompiledMethod(objOop2));
				header2 = unsignedLongAt((objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				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) );
				l12:
				;
				/* 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 l11;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l11:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l15;
						}
						assert((ReceiverIndex + (sp >> 3)) < (lengthOf(objOop2)));
						contextSize = sp >> 3;
						l15:
						;
						/* end fetchStackPointerOf: */
						i = ((usqInt) (CtxtTempFrameStart + contextSize) );
						goto l14;
					}
					/* begin numSlotsOf: */
					assert((classIndexOf(objOop2)) > (isForwardedObjectClassIndexPun()));
					numSlots = byteAt(objOop2 + 7);
					i = ((numSlots == (numSlotsMask()))
						 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(objOop2 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
						 : numSlots);
					goto l14;
					/* end numSlotsOf: */
				}
				if (fmt == 7) {
					i = 1;
					goto l14;
				}
				if (fmt < (firstCompiledMethodFormat())) {
					i = 0;
					goto l14;
				}
				/* begin methodHeaderOf: */
				assert(isCompiledMethod(objOop2));
				header2 = unsignedLongAt((objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				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) );
				l14:
				;
				/* 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 l8;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l8:
		;
		/* 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 l17;
							}
							assert((ReceiverIndex + (sp >> 3)) < (lengthOf(objOop22)));
							contextSize = sp >> 3;
							l17:
							;
							/* end fetchStackPointerOf: */
							i = ((usqInt) (CtxtTempFrameStart + contextSize) );
							goto l16;
						}
						/* begin numSlotsOf: */
						assert((classIndexOf(objOop22)) > (isForwardedObjectClassIndexPun()));
						numSlots = byteAt(objOop22 + 7);
						i = ((numSlots == (numSlotsMask()))
							 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(objOop22 - 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(objOop22));
					header2 = unsignedLongAt((objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					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((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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l19;
						}
						assert((ReceiverIndex + (sp >> 3)) < (lengthOf(currentObject)));
						contextSize = sp >> 3;
						l19:
						;
						/* end fetchStackPointerOf: */
						i = ((usqInt) (CtxtTempFrameStart + contextSize) );
						goto l18;
					}
					/* begin numSlotsOf: */
					assert((classIndexOf(currentObject)) > (isForwardedObjectClassIndexPun()));
					numSlots = byteAt(currentObject + 7);
					i = ((numSlots == (numSlotsMask()))
						 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(currentObject - BaseHeaderSize)) ) << 8) ) ) ) >> 8
						 : numSlots);
					goto l18;
					/* end numSlotsOf: */
				}
				if (fmt == 7) {
					i = 1;
					goto l18;
				}
				if (fmt < (firstCompiledMethodFormat())) {
					i = 0;
					goto l18;
				}
				/* begin methodHeaderOf: */
				assert(isCompiledMethod(currentObject));
				header2 = unsignedLongAt((currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				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) );
				l18:
				;
				/* 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 l9;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l9:
		;
		/* 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>>#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;
	sqInt aForwardedPermSpaceObject;
	sqInt anObj;
	sqInt anOop;
	sqInt anOop1;
	sqInt aPermSpaceObject;
	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 objStackRootIndex1;
	sqInt oldObj;
	sqInt oldObj2;
	sqInt referenced;
	sqInt referent;
	sqInt referent2;
	int refersNewSpace;
	int refersOldSpace;
	sqInt rootIndex;
	sqInt rootIndex1;
	VMRememberedSet * self_in_emptyRememberedSet;
	VMRememberedSet * self_in_emptyRememberedSet1;
	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_emptyRememberedSet1 = GIV(fromPermToNewSpaceRememberedSet);
	/* end getFromPermToNewSpaceRememberedSet */
	/* begin objStackAt: */
	objStackRootIndex1 = (self_in_emptyRememberedSet1->rootIndex);
	/* begin fetchPointer:ofObject: */
	oldObj2 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) objStackRootIndex1 ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end objStackAt: */
	if (!(oldObj2 == GIV(nilObj))) {
		/* begin rememberedSet:oop: */
		rootIndex1 = (self_in_emptyRememberedSet1->rootIndex);
		anOop1 = GIV(nilObj);
		assert(isOldObject(GIV(memoryMap), anOop1));
		{
			assert(!(isOopForwarded(GIV(hiddenRootsObj))));
			longAtput((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) rootIndex1 ) << (shiftForWord())) ), anOop1);
		}
		/* end rememberedSet:oop: */
		freeObject(oldObj2);
	}
	initializeRememberedSetShouldStartEmpty(self_in_emptyRememberedSet1, 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 l22;
								}
								assert((ReceiverIndex + (sp >> 3)) < (lengthOf(currentObject)));
								contextSize = sp >> 3;
								l22:
								;
								/* end fetchStackPointerOf: */
								numPointerSlots = CtxtTempFrameStart + contextSize;
								goto l21;
							}
							/* begin numSlotsOf: */
							assert((classIndexOf(currentObject)) > (isForwardedObjectClassIndexPun()));
							numSlots = byteAt(currentObject + 7);
							numPointerSlots = ((numSlots == (numSlotsMask()))
								 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(currentObject - BaseHeaderSize)) ) << 8) ) ) ) >> 8
								 : numSlots);
							goto l21;
							/* end numSlotsOf: */
						}
						if (fmt == 7) {
							numPointerSlots = 1;
							goto l21;
						}
						if (fmt < (firstCompiledMethodFormat())) {
							numPointerSlots = 0;
							goto l21;
						}
						/* begin methodHeaderOf: */
						assert(isCompiledMethod(currentObject));
						header2 = unsignedLongAt((currentObject + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
						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;
						l21:
						;
						/* 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 l14;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		currentObject = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l14:
		;
		/* 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;
	sqInt i;
	sqInt memEnd;
	sqInt memStart;
	int probe;
	VMMemoryMap * self_in_doCheckMemoryMap;

	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 l2;
	}
	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 */
	l2:
	;
	/* 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)))) {
		int t0;
		int t1;

		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 l1;
	}
	if (valuePointer & (tagMask())) {
		goto l1;
	}
	if (!(objOop >= 0x20000000000LL)) {
		goto l1;
	}
	if (valuePointer >= 0x20000000000LL) {
		goto l1;
	}
	if ((valuePointer >= GIV(nilObj)) && (valuePointer <= GIV(trueObj))) {
		goto l1;
	}
	if (!(valuePointer >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l1;
	}
	remember(getFromPermToNewSpaceRememberedSet(), objOop);
	l1:
	;
	/* 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 l1;
		}
		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 l1;
		}
	}
	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: */
	l1:
	;
	/* 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 fieldIndex1;
	sqInt fieldIndex11;
	sqInt fieldIndex2;
	sqInt fieldIndex3;
	sqInt i;
	sqInt iLimiT;
	sqInt largeChild;
	sqInt listNode;
	sqInt nextNode;
	sqInt smallChild;
	sqInt totalFreeBytes;
	sqInt treeNode;
	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 l6;
	}
	cameFrom = -1;
	do{
		assert((bytesInObject(treeNode2)) >= ((numFreeLists()) * (allocationUnit())));
		/* begin fetchPointer:ofFreeChunk: */
		fieldIndex11 = 3;
		smallChild = unsignedLongAt((treeNode2 + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex11 ) << (shiftForWord())) ));
		/* end fetchPointer:ofFreeChunk: */
		/* begin fetchPointer:ofFreeChunk: */
		fieldIndex2 = 4;
		largeChild = unsignedLongAt((treeNode2 + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex2 ) << (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: */
					fieldIndex1 = 0;
					nextNode = unsignedLongAt((listNode + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (shiftForWord())) ));
					/* end fetchPointer:ofFreeChunk: */
					assert(nextNode != listNode);
					listNode = nextNode;
				};
			}
			cameFrom = treeNode2;
			/* begin fetchPointer:ofFreeChunk: */
			fieldIndex3 = 2;
			treeNode2 = unsignedLongAt((treeNode2 + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex3 ) << (shiftForWord())) ));
			/* end fetchPointer:ofFreeChunk: */
		} else {
			if ((smallChild != 0) && (cameFrom != smallChild)) {
				treeNode2 = smallChild;
			} else {
				assert(largeChild != 0);
				treeNode2 = largeChild;
			}
			cameFrom = -1;
		}
	}while(treeNode2 != 0);
	l6:
	;
	/* 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 fieldIndex1;
	sqInt fieldIndex2;
	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: */
			fieldIndex2 = 1;
			assert(isFreeObject(next2));
			assert(1);
			unsignedLongAtput((next2 + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex2 ) << (shiftForWord())) ), 0);
			/* end storePointer:ofFreeChunk:withValue: */
		}
		/* end unlinkFreeChunk:atIndex:isLilliputianSize: */
		return freeChunk;
	}
	/* begin fetchPointer:ofFreeChunk: */
	fieldIndex1 = 0;
	next = unsignedLongAt((freeChunk + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (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 fieldIndex1;
	sqInt fieldIndex2;
	sqInt fieldIndex3;
	sqInt fieldIndex4;
	sqInt fieldIndex5;
	sqInt fieldIndex6;
	sqInt fieldIndex7;
	sqInt fieldIndex8;
	sqInt larger;
	sqInt parent;
	sqInt smaller;

	assert((fetchPointerofFreeChunk(freeChunkNextIndex(), freeTreeNode)) == 0);
	/* begin fetchPointer:ofFreeChunk: */
	fieldIndex6 = 3;
	smaller = unsignedLongAt((freeTreeNode + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex6 ) << (shiftForWord())) ));
	/* end fetchPointer:ofFreeChunk: */
	/* begin fetchPointer:ofFreeChunk: */
	fieldIndex7 = 4;
	larger = unsignedLongAt((freeTreeNode + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex7 ) << (shiftForWord())) ));
	/* end fetchPointer:ofFreeChunk: */
	/* begin fetchPointer:ofFreeChunk: */
	fieldIndex8 = 2;
	parent = unsignedLongAt((freeTreeNode + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex8 ) << (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: */
			fieldIndex1 = 2;
			assert(isFreeObject(smaller));
			assert(1);
			unsignedLongAtput((smaller + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (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 */
				fieldIndex3 = 3;
				/* end freeChunkSmallerIndex */
			} else {
				/* begin freeChunkLargerIndex */
				fieldIndex3 = 4;
				/* end freeChunkLargerIndex */
			}
			assert(isFreeObject(parent));
			assert((larger == 0) || (isFreeObject(larger)));
			unsignedLongAtput((parent + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex3 ) << (shiftForWord())) ), larger);
			/* end storePointer:ofFreeChunk:withValue: */
			if (larger != 0) {
				/* begin storePointer:ofFreeChunk:withValue: */
				fieldIndex2 = 2;
				assert(isFreeObject(larger));
				assert((parent == 0) || (isFreeObject(parent)));
				unsignedLongAtput((larger + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex2 ) << (shiftForWord())) ), parent);
				/* end storePointer:ofFreeChunk:withValue: */
			}
		} else {
			/* 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((smaller == 0) || (isFreeObject(smaller)));
			unsignedLongAtput((parent + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex4 ) << (shiftForWord())) ), smaller);
			/* end storePointer:ofFreeChunk:withValue: */
			/* begin storePointer:ofFreeChunk:withValue: */
			fieldIndex5 = 2;
			assert(isFreeObject(smaller));
			assert((parent == 0) || (isFreeObject(parent)));
			unsignedLongAtput((smaller + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex5 ) << (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 fieldIndex1;
	sqInt fieldIndex2;
	sqInt obj;
	sqInt prev;

	if (freeNode == 0) {
		return;
	}
	assert(!(isLilliputianSize(bytesInObject(freeNode))));
	prev = freeNode;
	/* begin storePointer:ofFreeChunk:withValue: */
	fieldIndex2 = 1;
	assert(isFreeObject(prev));
	assert(1);
	unsignedLongAtput((prev + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex2 ) << (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: */
		fieldIndex1 = 1;
		assert(isFreeObject(obj));
		assert((prev == 0) || (isFreeObject(prev)));
		unsignedLongAtput((obj + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (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 classOrNil;
	sqInt classOrNil2;
	sqInt hash;
	sqInt i;
	sqInt ignored;
	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;
	sqInt address;
	sqInt address1;
	sqInt address2;
	sqInt finalPass;
	int firstPass;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	sqInt hash;
	sqInt hash1;
	sqInt hash2;
	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 objOop;
	sqInt objOop1;
	sqInt objOop11;
	sqInt objOop12;
	sqInt objOop2;
	sqInt objOop21;
	sqInt objOop211;
	sqInt objOop212;
	sqInt objOop23;
	sqInt objOop24;
	sqInt objOop3;
	sqInt objOop31;
	sqInt objOop311;
	sqInt objOop312;
	sqInt objOop33;
	sqInt objOop34;
	sqInt objOop4;
	sqInt objOop41;
	sqInt objOop42;
	sqInt objOop5;
	sqInt objOop51;
	sqInt objOop52;
	sqInt objOop6;
	sqInt objOop61;
	sqInt objOop62;
	sqInt objOop8;
	sqInt objOop9;
	sqInt prevObj;
	sqInt prevObj2;
	sqInt prevObj3;
	sqInt prevPrevObj;
	sqInt prevPrevObj2;
	sqInt prevPrevObj3;
	VMRememberedSet * self_in_relocateRememberedSet;
	VMRememberedSet * self_in_relocateRememberedSet1;
	VMRememberedSet * self_in_relocateRememberedSet11;
	VMRememberedSet * self_in_relocateRememberedSet2;
	VMRememberedSet * self_in_relocateRememberedSet21;
	VMRememberedSet * self_in_relocateRememberedSet3;
	sqInt sizeOfEden;
	sqInt spaceEstimate;
	sqInt spaceEstimate2;
	sqInt stackOrNil;
	sqInt stackOrNil2;
	sqInt stackOrNil3;
	sqInt theLimit;
	sqInt theLimit1;
	sqInt theLimit11;
	sqInt theLimit2;
	sqInt theStart;
	sqInt theStart1;
	sqInt theStart11;
	sqInt theStart2;

	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 l1;
				}
				flag("endianness");
				followingWord = unsignedLongAt(followingWordAddress);
				objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
					 ? followingWordAddress + BaseHeaderSize
					 : followingWordAddress);
				l1:
				;
				/* 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 l13;
					}
				}
			}
			highestSuitableFreeBlock = null;
			l13:
			;
			/* end findHighestSuitableFreeBlock: */
			if (!(highestSuitableFreeBlock == null)) {
				if ((spaceEstimate2 > ((assert(isFreeObject(highestSuitableFreeBlock)), bytesInObject(highestSuitableFreeBlock)))) && (useSegmentForSavedFirstFieldsSpace(spaceEstimate2))) {
					goto l14;
				}
				if (((assert(isFreeObject(highestSuitableFreeBlock)), bytesInObject(highestSuitableFreeBlock))) > sizeOfEden) {
					/* begin useFreeChunkForSavedFirstFieldsSpace: */
					assert(validFreeTreeChunk(highestSuitableFreeBlock));
					/* begin configureSavedFirstFieldsSpaceStart:limit:isOldSpace: */
					theStart11 = highestSuitableFreeBlock + (4 * BytesPerOop);
					theLimit11 = addressAfter(highestSuitableFreeBlock);
					limit22 = theLimit11;
					if (GIV(savedFirstFieldSpaceMaxSlots)) {
						limit22 = ((limit22 < (theStart11 + (GIV(savedFirstFieldSpaceMaxSlots) * BytesPerOop))) ? limit22 : theStart11 + (GIV(savedFirstFieldSpaceMaxSlots) * BytesPerOop));
					}
					{
						(GIV(savedFirstFieldsSpace).start = theStart11);
						(GIV(savedFirstFieldsSpace).limit = limit22);
					}
					GIV(savedFirstFieldsSpaceNotInOldSpace) = !1;
					/* end configureSavedFirstFieldsSpaceStart:limit:isOldSpace: */
					assert(!(savedFirstFieldsSpaceWasAllocated()));
					/* end useFreeChunkForSavedFirstFieldsSpace: */
					goto l14;
				}
			}
		}
		if (useSegmentForSavedFirstFieldsSpace(spaceEstimate2)) {
			goto l14;
		}
	}
	/* begin useEdenForSavedFirstFieldsSpace */
	/* begin configureSavedFirstFieldsSpaceStart:limit:isOldSpace: */
	theStart2 = ((eden()).start);
	theLimit2 = ((eden()).limit);
	limit3 = theLimit2;
	if (GIV(savedFirstFieldSpaceMaxSlots)) {
		limit3 = ((limit3 < (theStart2 + (GIV(savedFirstFieldSpaceMaxSlots) * BytesPerOop))) ? limit3 : theStart2 + (GIV(savedFirstFieldSpaceMaxSlots) * BytesPerOop));
	}
	{
		(GIV(savedFirstFieldsSpace).start = theStart2);
		(GIV(savedFirstFieldsSpace).limit = limit3);
	}
	GIV(savedFirstFieldsSpaceNotInOldSpace) = !0;
	/* end configureSavedFirstFieldsSpaceStart:limit:isOldSpace: */
	assert(!(savedFirstFieldsSpaceWasAllocated()));
	/* end useEdenForSavedFirstFieldsSpace */
	l14:
	;
	/* end selectSavedFirstFieldsSpace */
	/* begin unpinRememberedSet */
	/* begin fetchPointer:ofObject: */
	/* begin oldRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	objOop6 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) OldRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end oldRememberedSetObj */
	GIV(firstFieldOfRememberedSet) = unsignedLongAt((objOop6 + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	/* begin setIsPinnedOf:to: */
	/* begin oldRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	objOop31 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) OldRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end oldRememberedSetObj */
	longAtput(objOop31, (longAt(objOop31)) & (~((usqIntptr_t) (1U << (pinnedBitShift())) )));
	/* end setIsPinnedOf:to: */
	/* begin fetchPointer:ofObject: */
	/* begin permToOldRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	objOop1 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToOldRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end permToOldRememberedSetObj */
	GIV(firstFieldOfPermToOldRememberedSet) = unsignedLongAt((objOop1 + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	/* begin setIsPinnedOf:to: */
	/* begin permToOldRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	objOop4 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToOldRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end permToOldRememberedSetObj */
	longAtput(objOop4, (longAt(objOop4)) & (~((usqIntptr_t) (1U << (pinnedBitShift())) )));
	/* end setIsPinnedOf:to: */
	/* begin fetchPointer:ofObject: */
	/* begin permToNewRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	objOop21 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToNewRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end permToNewRememberedSetObj */
	GIV(firstFieldOfPermToNewRememberedSet) = unsignedLongAt((objOop21 + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	/* begin setIsPinnedOf:to: */
	/* begin permToNewRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	objOop5 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToNewRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end permToNewRememberedSetObj */
	longAtput(objOop5, (longAt(objOop5)) & (~((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: */
				hash1 = unsignedLongAt((stackOrNil2 + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ));
				assert((hash1 >= 0) && (hash1 <= (identityHashHalfWordMask())));
				uint32AtPointerput(stackOrNil2 + 4, (((uint32AtPointer(stackOrNil2 + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + hash1);
				/* end setHashBitsOf:to: */
			}while(((stackOrNil2 = unsignedLongAt((stackOrNil2 + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) )))) != 0);
			l16:
			;
			/* end prepareObjStackForPlanningCompactor: */
			/* begin prepareObjStackForPlanningCompactor: */
			if (GIV(mournQueue) == GIV(nilObj)) {
				goto l15;
			}
			stackOrNil3 = GIV(mournQueue);
			do{
				assert((numSlotsOfAny(stackOrNil3)) == ObjStackPageSlots);
				/* begin setHashBitsOf:to: */
				hash2 = unsignedLongAt((stackOrNil3 + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackTopx ) << (shiftForWord())) ));
				assert((hash2 >= 0) && (hash2 <= (identityHashHalfWordMask())));
				uint32AtPointerput(stackOrNil3 + 4, (((uint32AtPointer(stackOrNil3 + 4)) | (identityHashHalfWordMask())) - (identityHashHalfWordMask())) + hash2);
				/* end setHashBitsOf:to: */
			}while(((stackOrNil3 = unsignedLongAt((stackOrNil3 + BaseHeaderSize) + ((sqInt) (((usqInt) ObjStackNextx ) << (shiftForWord())) )))) != 0);
			l15:
			;
			/* 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: */
					address1 = ((pastSpace()).start);
					numSlots2 = byteAt(address1 + 7);
					objOop23 = ((numSlots2 == (numSlotsMask()))
						 ? address1 + BaseHeaderSize
						 : address1);
					/* 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 l29;
						}
						flag("endianness");
						followingWord2 = unsignedLongAt(followingWordAddress2);
						objOop23 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
							 ? followingWordAddress2 + BaseHeaderSize
							 : followingWordAddress2);
						l29:
						;
						/* 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: */
					objOop61 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) OldRememberedSetRootIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					/* end oldRememberedSetObj */
					assert(!(isOopForwarded(objOop61)));
					longAtput((objOop61 + BaseHeaderSize) + (0U << (shiftForWord())), GIV(firstFieldOfRememberedSet));
					/* end storePointerUnchecked:ofObject:withValue: */
				}
				/* begin setIsPinnedOf:to: */
				/* begin oldRememberedSetObj */
				/* begin fetchPointer:ofObject: */
				objOop311 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) OldRememberedSetRootIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				/* end oldRememberedSetObj */
				longAtput(objOop311, (longAt(objOop311)) | (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: */
					objOop11 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToOldRememberedSetRootIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					/* end permToOldRememberedSetObj */
					assert(!(isOopForwarded(objOop11)));
					longAtput((objOop11 + BaseHeaderSize) + (0U << (shiftForWord())), GIV(firstFieldOfPermToOldRememberedSet));
					/* end storePointerUnchecked:ofObject:withValue: */
				}
				/* begin setIsPinnedOf:to: */
				/* begin permToOldRememberedSetObj */
				/* begin fetchPointer:ofObject: */
				objOop41 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToOldRememberedSetRootIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				/* end permToOldRememberedSetObj */
				longAtput(objOop41, (longAt(objOop41)) | (1U << (pinnedBitShift())));
				/* end setIsPinnedOf:to: */
				/* begin relocateRememberedSet */
				/* begin getFromPermToOldSpaceRememberedSet */
				self_in_relocateRememberedSet1 = GIV(fromPermToOldSpaceRememberedSet);
				/* end getFromPermToOldSpaceRememberedSet */
				(self_in_relocateRememberedSet1->rememberedSetArray = rememberedSetArrayPointerFromObject(self_in_relocateRememberedSet1, objectOop(self_in_relocateRememberedSet1)));
				/* end relocateRememberedSet */
				if ((((getFromPermToNewSpaceRememberedSet())->rememberedSetSize)) > 0) {
					/* begin storePointerUnchecked:ofObject:withValue: */
					/* begin permToNewRememberedSetObj */
					/* begin fetchPointer:ofObject: */
					objOop211 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToNewRememberedSetRootIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					/* end permToNewRememberedSetObj */
					assert(!(isOopForwarded(objOop211)));
					longAtput((objOop211 + BaseHeaderSize) + (0U << (shiftForWord())), GIV(firstFieldOfPermToNewRememberedSet));
					/* end storePointerUnchecked:ofObject:withValue: */
				}
				/* begin setIsPinnedOf:to: */
				/* begin permToNewRememberedSetObj */
				/* begin fetchPointer:ofObject: */
				objOop51 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToNewRememberedSetRootIndex ) << (shiftForWord())) ));
				/* end fetchPointer:ofObject: */
				/* end permToNewRememberedSetObj */
				longAtput(objOop51, (longAt(objOop51)) | (1U << (pinnedBitShift())));
				/* end setIsPinnedOf:to: */
				/* begin relocateRememberedSet */
				/* begin getFromPermToNewSpaceRememberedSet */
				self_in_relocateRememberedSet2 = GIV(fromPermToNewSpaceRememberedSet);
				/* end getFromPermToNewSpaceRememberedSet */
				(self_in_relocateRememberedSet2->rememberedSetArray = rememberedSetArrayPointerFromObject(self_in_relocateRememberedSet2, objectOop(self_in_relocateRememberedSet2)));
				/* 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 l3;
						}
					}
				}
				largestFreeChunk = null;
				l3:
				;
				/* 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: */
					theStart1 = largestFreeChunk + (4 * BytesPerOop);
					theLimit1 = addressAfter(largestFreeChunk);
					limit2 = theLimit1;
					if (GIV(savedFirstFieldSpaceMaxSlots)) {
						limit2 = ((limit2 < (theStart1 + (GIV(savedFirstFieldSpaceMaxSlots) * BytesPerOop))) ? limit2 : theStart1 + (GIV(savedFirstFieldSpaceMaxSlots) * BytesPerOop));
					}
					{
						(GIV(savedFirstFieldsSpace).start = theStart1);
						(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: */
		address2 = ((pastSpace()).start);
		numSlots3 = byteAt(address2 + 7);
		objOop24 = ((numSlots3 == (numSlotsMask()))
			 ? address2 + BaseHeaderSize
			 : address2);
		/* 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 l43;
			}
			flag("endianness");
			followingWord3 = unsignedLongAt(followingWordAddress3);
			objOop24 = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress3 + BaseHeaderSize
				 : followingWordAddress3);
			l43:
			;
			/* 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: */
		objOop62 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) OldRememberedSetRootIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end oldRememberedSetObj */
		assert(!(isOopForwarded(objOop62)));
		longAtput((objOop62 + BaseHeaderSize) + (0U << (shiftForWord())), GIV(firstFieldOfRememberedSet));
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	/* begin setIsPinnedOf:to: */
	/* begin oldRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	objOop312 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) OldRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end oldRememberedSetObj */
	longAtput(objOop312, (longAt(objOop312)) | (1U << (pinnedBitShift())));
	/* end setIsPinnedOf:to: */
	/* begin relocateRememberedSet */
	/* begin getFromOldSpaceRememberedSet */
	self_in_relocateRememberedSet3 = GIV(fromOldSpaceRememberedSet);
	/* end getFromOldSpaceRememberedSet */
	(self_in_relocateRememberedSet3->rememberedSetArray = rememberedSetArrayPointerFromObject(self_in_relocateRememberedSet3, objectOop(self_in_relocateRememberedSet3)));
	/* end relocateRememberedSet */
	if ((((getFromPermToOldSpaceRememberedSet())->rememberedSetSize)) > 0) {
		/* begin storePointerUnchecked:ofObject:withValue: */
		/* begin permToOldRememberedSetObj */
		/* begin fetchPointer:ofObject: */
		objOop12 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToOldRememberedSetRootIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end permToOldRememberedSetObj */
		assert(!(isOopForwarded(objOop12)));
		longAtput((objOop12 + BaseHeaderSize) + (0U << (shiftForWord())), GIV(firstFieldOfPermToOldRememberedSet));
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	/* begin setIsPinnedOf:to: */
	/* begin permToOldRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	objOop42 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToOldRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end permToOldRememberedSetObj */
	longAtput(objOop42, (longAt(objOop42)) | (1U << (pinnedBitShift())));
	/* end setIsPinnedOf:to: */
	/* begin relocateRememberedSet */
	/* begin getFromPermToOldSpaceRememberedSet */
	self_in_relocateRememberedSet11 = GIV(fromPermToOldSpaceRememberedSet);
	/* end getFromPermToOldSpaceRememberedSet */
	(self_in_relocateRememberedSet11->rememberedSetArray = rememberedSetArrayPointerFromObject(self_in_relocateRememberedSet11, objectOop(self_in_relocateRememberedSet11)));
	/* end relocateRememberedSet */
	if ((((getFromPermToNewSpaceRememberedSet())->rememberedSetSize)) > 0) {
		/* begin storePointerUnchecked:ofObject:withValue: */
		/* begin permToNewRememberedSetObj */
		/* begin fetchPointer:ofObject: */
		objOop212 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToNewRememberedSetRootIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end permToNewRememberedSetObj */
		assert(!(isOopForwarded(objOop212)));
		longAtput((objOop212 + BaseHeaderSize) + (0U << (shiftForWord())), GIV(firstFieldOfPermToNewRememberedSet));
		/* end storePointerUnchecked:ofObject:withValue: */
	}
	/* begin setIsPinnedOf:to: */
	/* begin permToNewRememberedSetObj */
	/* begin fetchPointer:ofObject: */
	objOop52 = unsignedLongAt((GIV(hiddenRootsObj) + BaseHeaderSize) + ((sqInt) (((usqInt) PermToNewRememberedSetRootIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end permToNewRememberedSetObj */
	longAtput(objOop52, (longAt(objOop52)) | (1U << (pinnedBitShift())));
	/* end setIsPinnedOf:to: */
	/* begin relocateRememberedSet */
	/* begin getFromPermToNewSpaceRememberedSet */
	self_in_relocateRememberedSet21 = GIV(fromPermToNewSpaceRememberedSet);
	/* end getFromPermToNewSpaceRememberedSet */
	(self_in_relocateRememberedSet21->rememberedSetArray = rememberedSetArrayPointerFromObject(self_in_relocateRememberedSet21, objectOop(self_in_relocateRememberedSet21)));
	/* 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 limit1;
	sqInt n;
	usqInt next;
	usqInt nextBytes;
	sqInt nextObj;
	usqInt numSlots;
	usqInt numSlots2;
	usqInt numSlots3;
	usqInt o;
	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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress = addressAfter(objOop);
		if (oopisGreaterThanOrEqualTo(followingWordAddress, limit1)) {
			nextObj = limit1;
			goto l7;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		nextObj = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l7:
		;
		/* 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 l12;
	}
	/* 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;
		}
	};
	l12:
	;
	/* 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;
	usqInt o;
	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 l6;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l6:
		;
		/* 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 o;
	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 l2;
			}
			flag("endianness");
			followingWord = unsignedLongAt(followingWordAddress);
			objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress + BaseHeaderSize
				 : followingWordAddress);
			l2:
			;
			/* 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 o;
	sqInt objOop;
	sqInt prevObj;
	sqInt prevPrevObj;

	firstFree = 0;
	/* begin allOldSpaceEntitiesFrom:do: */
	assert(isOldObject(GIV(memoryMap), initialObject));
	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 l1;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l1:
		;
		/* 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 o;
	sqInt objOop;
	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 l1;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l1:
		;
		/* 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 o;
	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 l4;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l4:
		;
		/* 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 limit1;
	sqInt limit2;
	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 o;
	sqInt o2;
	sqInt o3;
	usqInt o4;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop23;
	sqInt objOop3;
	sqInt objOop4;
	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;

	previousPin = 0;
	/* begin logPhase: */
	/* 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 l41;
						}
						assert((ReceiverIndex + (sp2 >> 3)) < (lengthOf(objOop22)));
						contextSize2 = sp2 >> 3;
						l41:
						;
						/* end fetchStackPointerOf: */
						numPointerSlots2 = CtxtTempFrameStart + contextSize2;
						goto l40;
					}
					/* begin numSlotsOf: */
					assert((classIndexOf(objOop22)) > (isForwardedObjectClassIndexPun()));
					numSlots2 = byteAt(objOop22 + 7);
					numPointerSlots2 = ((numSlots2 == (numSlotsMask()))
						 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(objOop22 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
						 : numSlots2);
					goto l40;
					/* end numSlotsOf: */
				}
				if (fmt2 == 7) {
					numPointerSlots2 = 1;
					goto l40;
				}
				if (fmt2 < (firstCompiledMethodFormat())) {
					numPointerSlots2 = 0;
					goto l40;
				}
				/* begin methodHeaderOf: */
				assert(isCompiledMethod(objOop22));
				header22 = unsignedLongAt((objOop22 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				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;
				l40:
				;
				/* 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 l15;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop22 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l15:
		;
		/* 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 l26;
					}
					/* 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 l43;
							}
							assert((ReceiverIndex + (sp3 >> 3)) < (lengthOf(objOop23)));
							contextSize3 = sp3 >> 3;
							l43:
							;
							/* end fetchStackPointerOf: */
							numPointerSlots3 = CtxtTempFrameStart + contextSize3;
							goto l42;
						}
						/* begin numSlotsOf: */
						assert((classIndexOf(objOop23)) > (isForwardedObjectClassIndexPun()));
						numSlots4 = byteAt(objOop23 + 7);
						numPointerSlots3 = ((numSlots4 == (numSlotsMask()))
							 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(objOop23 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
							 : numSlots4);
						goto l42;
						/* end numSlotsOf: */
					}
					if (fmt3 == 7) {
						numPointerSlots3 = 1;
						goto l42;
					}
					if (fmt3 < (firstCompiledMethodFormat())) {
						numPointerSlots3 = 0;
						goto l42;
					}
					/* begin methodHeaderOf: */
					assert(isCompiledMethod(objOop23));
					header23 = unsignedLongAt((objOop23 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					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;
					l42:
					;
					/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress3 = addressAfter(objOop23);
		if (oopisGreaterThanOrEqualTo(followingWordAddress3, limit1)) {
			objOop23 = limit1;
			goto l23;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		objOop23 = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l23:
		;
		/* end objectAfter:limit: */
	};
	;
	;
	/* end allOldSpaceEntitiesFrom:do: */
	/* end allOldSpaceObjectsFrom:do: */
	l26:
	;
	/* 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 l44;
							}
							assert((ReceiverIndex + (sp4 >> 3)) < (lengthOf(objOop5)));
							contextSize4 = sp4 >> 3;
							l44:
							;
							/* end fetchStackPointerOf: */
							numPointerSlots4 = CtxtTempFrameStart + contextSize4;
							goto l45;
						}
						/* begin numSlotsOf: */
						assert((classIndexOf(objOop5)) > (isForwardedObjectClassIndexPun()));
						numSlots22 = byteAt(objOop5 + 7);
						numPointerSlots4 = ((numSlots22 == (numSlotsMask()))
							 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(objOop5 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
							 : numSlots22);
						goto l45;
						/* end numSlotsOf: */
					}
					if (fmt4 == 7) {
						numPointerSlots4 = 1;
						goto l45;
					}
					if (fmt4 < (firstCompiledMethodFormat())) {
						numPointerSlots4 = 0;
						goto l45;
					}
					/* begin methodHeaderOf: */
					assert(isCompiledMethod(objOop5));
					header24 = unsignedLongAt((objOop5 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					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;
					l45:
					;
					/* 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 l39;
					}
				}
			}
		}
		prevPrevObj4 = prevObj4;
		prevObj4 = objOop5;
		/* begin objectAfter:limit: */
		limit2 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop5);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit2)) {
			objOop5 = limit2;
			goto l31;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop5 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l31:
		;
		/* end objectAfter:limit: */
	};
	;
	;
	/* end allOldSpaceEntitiesFrom:do: */
	assert(((GIV(savedFirstFieldsSpace).top)) == (top - BytesPerOop));
	onePass = 1;
	l39:
	;
	/* 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 l46;
									}
									assert((ReceiverIndex + (sp >> 3)) < (lengthOf(objOop2)));
									contextSize = sp >> 3;
									l46:
									;
									/* end fetchStackPointerOf: */
									numPointerSlots = CtxtTempFrameStart + contextSize;
									goto l47;
								}
								/* begin numSlotsOf: */
								assert((classIndexOf(objOop2)) > (isForwardedObjectClassIndexPun()));
								numSlots = byteAt(objOop2 + 7);
								numPointerSlots = ((numSlots == (numSlotsMask()))
									 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(objOop2 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
									 : numSlots);
								goto l47;
								/* end numSlotsOf: */
							}
							if (fmt == 7) {
								numPointerSlots = 1;
								goto l47;
							}
							if (fmt < (firstCompiledMethodFormat())) {
								numPointerSlots = 0;
								goto l47;
							}
							/* begin methodHeaderOf: */
							assert(isCompiledMethod(objOop2));
							header2 = unsignedLongAt((objOop2 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
							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;
							l47:
							;
							/* 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 l1;
			}
			flag("endianness");
			followingWord = unsignedLongAt(followingWordAddress);
			objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress + BaseHeaderSize
				 : followingWordAddress);
			l1:
			;
			/* 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;
	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 index;
	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 obj1;
	sqInt oop;
	sqInt oop2;
	sqInt oop3;
	sqInt oop4;
	sqInt oop5;
	sqInt oop6;
	VMRememberedSet * self_in_rememberedSetWithIndexDostartingAt;
	VMRememberedSet * self_in_rememberedSetWithIndexDostartingAt1;
	VMRememberedSet * self_in_rememberedSetWithIndexDostartingAt2;
	VMRememberedSet * self_in_rememberedSetWithIndexDostartingAt3;
	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 l15;
					}
					assert((ReceiverIndex + (sp >> 3)) < (lengthOf(obj)));
					contextSize = sp >> 3;
					l15:
					;
					/* end fetchStackPointerOf: */
					numPointerSlots = CtxtTempFrameStart + contextSize;
					goto l17;
				}
				/* begin numSlotsOf: */
				assert((classIndexOf(obj)) > (isForwardedObjectClassIndexPun()));
				numSlots = byteAt(obj + 7);
				numPointerSlots = ((numSlots == (numSlotsMask()))
					 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(obj - BaseHeaderSize)) ) << 8) ) ) ) >> 8
					 : numSlots);
				goto l17;
				/* end numSlotsOf: */
			}
			if (fmt == 7) {
				numPointerSlots = 1;
				goto l17;
			}
			if (fmt < (firstCompiledMethodFormat())) {
				numPointerSlots = 0;
				goto l17;
			}
			/* begin methodHeaderOf: */
			assert(isCompiledMethod(obj));
			header2 = unsignedLongAt((obj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			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;
			l17:
			;
			/* 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 l43;
						}
						assert((ReceiverIndex + (sp2 >> 3)) < (lengthOf(oop)));
						contextSize2 = sp2 >> 3;
						l43:
						;
						/* end fetchStackPointerOf: */
						numPointerSlots2 = CtxtTempFrameStart + contextSize2;
						goto l44;
					}
					/* begin numSlotsOf: */
					assert((classIndexOf(oop)) > (isForwardedObjectClassIndexPun()));
					numSlots2 = byteAt(oop + 7);
					numPointerSlots2 = ((numSlots2 == (numSlotsMask()))
						 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(oop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
						 : numSlots2);
					goto l44;
					/* end numSlotsOf: */
				}
				if (fmt2 == 7) {
					numPointerSlots2 = 1;
					goto l44;
				}
				if (fmt2 < (firstCompiledMethodFormat())) {
					numPointerSlots2 = 0;
					goto l44;
				}
				/* begin methodHeaderOf: */
				assert(isCompiledMethod(oop));
				header22 = unsignedLongAt((oop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				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;
				l44:
				;
				/* 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: */
			obj1 = GIV(firstFieldOfPermToNewRememberedSet);
			/* begin numPointerSlotsOf: */
			fmt3 = (((usqInt) (longAt(obj1)) ) >> (formatShift())) & (formatMask());
			if (fmt3 <= 5) {
				if ((fmt3 == (indexablePointersFormat())) && (((longAt(obj1)) & (classIndexMask())) == ClassMethodContextCompactIndex)) {
					/* begin fetchStackPointerOf: */
					/* begin fetchPointer:ofObject: */
					sp3 = unsignedLongAt((obj1 + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
					/* end fetchPointer:ofObject: */
					if (!(((sp3 & 7) == 1))) {
						contextSize3 = 0;
						goto l29;
					}
					assert((ReceiverIndex + (sp3 >> 3)) < (lengthOf(obj1)));
					contextSize3 = sp3 >> 3;
					l29:
					;
					/* end fetchStackPointerOf: */
					numPointerSlots3 = CtxtTempFrameStart + contextSize3;
					goto l31;
				}
				/* begin numSlotsOf: */
				assert((classIndexOf(obj1)) > (isForwardedObjectClassIndexPun()));
				numSlots3 = byteAt(obj1 + 7);
				numPointerSlots3 = ((numSlots3 == (numSlotsMask()))
					 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(obj1 - BaseHeaderSize)) ) << 8) ) ) ) >> 8
					 : numSlots3);
				goto l31;
				/* end numSlotsOf: */
			}
			if (fmt3 == 7) {
				numPointerSlots3 = 1;
				goto l31;
			}
			if (fmt3 < (firstCompiledMethodFormat())) {
				numPointerSlots3 = 0;
				goto l31;
			}
			/* begin methodHeaderOf: */
			assert(isCompiledMethod(obj1));
			header23 = unsignedLongAt((obj1 + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
			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;
			l31:
			;
			/* end numPointerSlotsOf: */
			for (i8 = 0; i8 < numPointerSlots3; i8 += 1) {
				/* begin updatePointer:in: */
				/* begin fetchPointer:ofObject: */
				oop5 = unsignedLongAt((obj1 + 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(obj1)));
					longAtput((obj1 + 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_rememberedSetWithIndexDostartingAt1 = GIV(fromPermToNewSpaceRememberedSet);
	/* end getFromPermToNewSpaceRememberedSet */
	for (i3 = 1; i3 < ((self_in_rememberedSetWithIndexDostartingAt1->rememberedSetSize)); i3 += 1) {
		oop = (self_in_rememberedSetWithIndexDostartingAt1->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 l46;
						}
						assert((ReceiverIndex + (sp4 >> 3)) < (lengthOf(oop)));
						contextSize4 = sp4 >> 3;
						l46:
						;
						/* end fetchStackPointerOf: */
						numPointerSlots4 = CtxtTempFrameStart + contextSize4;
						goto l45;
					}
					/* begin numSlotsOf: */
					assert((classIndexOf(oop)) > (isForwardedObjectClassIndexPun()));
					numSlots4 = byteAt(oop + 7);
					numPointerSlots4 = ((numSlots4 == (numSlotsMask()))
						 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(oop - BaseHeaderSize)) ) << 8) ) ) ) >> 8
						 : numSlots4);
					goto l45;
					/* end numSlotsOf: */
				}
				if (fmt4 == 7) {
					numPointerSlots4 = 1;
					goto l45;
				}
				if (fmt4 < (firstCompiledMethodFormat())) {
					numPointerSlots4 = 0;
					goto l45;
				}
				/* begin methodHeaderOf: */
				assert(isCompiledMethod(oop));
				header24 = unsignedLongAt((oop + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
				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;
				l45:
				;
				/* 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_rememberedSetWithIndexDostartingAt2 = GIV(fromPermToNewSpaceRememberedSet);
	/* end getFromPermToNewSpaceRememberedSet */
	for (i4 = 1; i4 < ((self_in_rememberedSetWithIndexDostartingAt2->rememberedSetSize)); i4 += 1) {
		oop = (self_in_rememberedSetWithIndexDostartingAt2->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_rememberedSetWithIndexDostartingAt3 = GIV(fromPermToOldSpaceRememberedSet);
	/* end getFromPermToOldSpaceRememberedSet */
	for (i5 = 1; i5 < ((self_in_rememberedSetWithIndexDostartingAt3->rememberedSetSize)); i5 += 1) {
		oop = (self_in_rememberedSetWithIndexDostartingAt3->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 l5;
			}
			assert((ReceiverIndex + (sp >> 3)) < (lengthOf(obj)));
			contextSize = sp >> 3;
			l5:
			;
			/* end fetchStackPointerOf: */
			numPointerSlots = CtxtTempFrameStart + contextSize;
			goto l8;
		}
		/* begin numSlotsOf: */
		assert((classIndexOf(obj)) > (isForwardedObjectClassIndexPun()));
		numSlots = byteAt(obj + 7);
		numPointerSlots = ((numSlots == (numSlotsMask()))
			 ? ((usqInt) ((usqInt) ((sqInt) (((usqInt) (longAt(obj - BaseHeaderSize)) ) << 8) ) ) ) >> 8
			 : numSlots);
		goto l8;
		/* end numSlotsOf: */
	}
	assert(!(fmt == (forwardedFormat())));
	if (fmt < (firstCompiledMethodFormat())) {
		numPointerSlots = 0;
		goto l8;
	}
	/* begin methodHeaderFromSavedFirstField: */
	field = longAt(firstFieldPtr);
	if (((field & 7) == 1)) {
		header = field;
		goto l6;
	}
	assert((isNonImmediate(field)) && (field < ((GIV(memoryMap)->newSpaceStart))));
	assert((((((CogMethod *) field ))->objectHeader)) == (nullHeaderForMachineCodeMethod()));
	header = ((((CogMethod *) field ))->methodHeader);
	l6:
	;
	/* end methodHeaderFromSavedFirstField: */
	{
		assert(((header & 7) == 1));
		numLiterals = (header >> 3) & AlternateHeaderNumLiteralsMask;
	}
	numPointerSlots = numLiterals + LiteralStart;
	l8:
	;
	/* 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;
	sqInt address;
	sqInt allocatedSize;
	sqInt aSize;
	sqInt limit;
	sqInt minAddress;
	sqInt roundedSize;
	void *segAddress;
	void *segmentAddress;
	VMMemoryMap * self_in_allocateSegmentOfSizeminAddressresultsIn;
	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 o;
	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 l2;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l2:
		;
		/* 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;
	sqInt address;
	usqInt allocatedSize;
	sqInt aSize;
	sqInt i;
	sqInt idx;
	sqInt lastSegIndex;
	sqInt minAddress;
	SpurSegmentInfo *newSeg;
	sqInt newSegIndex;
	void *segAddress;
	sqInt segAddress1;
	sqInt segIndex;
	void *segmentAddress;
	VMMemoryMap * self_in_allocateSegmentOfSizeminAddressresultsIn;
	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: */
		segAddress1 = ((usqIntptr_t) segAddress );
		assert(segAddress1 >= (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 (segAddress1 >= ((((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 l1;
			}
			segIndex -= 1;
		};
		l1:
		;
		/* 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;
	sqInt cameFrom;
	SpurSegmentInfo * cascade0;
	usqInt chunkBytes;
	sqInt fieldIndex;
	sqInt fieldIndex1;
	sqInt fieldIndex2;
	sqInt fieldIndex3;
	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 l5;
	}
	cameFrom = -1;
	do{
		assert((bytesInObject(treeNode)) >= ((numFreeLists()) * (allocationUnit())));
		/* begin fetchPointer:ofFreeChunk: */
		fieldIndex1 = 3;
		smallChild = unsignedLongAt((treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex1 ) << (shiftForWord())) ));
		/* end fetchPointer:ofFreeChunk: */
		/* begin fetchPointer:ofFreeChunk: */
		fieldIndex2 = 4;
		largeChild = unsignedLongAt((treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex2 ) << (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 l9;
					}
					flag("endianness");
					followingWord = unsignedLongAt(followingWordAddress);
					next = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
						 ? followingWordAddress + BaseHeaderSize
						 : followingWordAddress);
					l9:
					;
					/* 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: */
			fieldIndex3 = 2;
			treeNode = unsignedLongAt((treeNode + BaseHeaderSize) + ((sqInt) (((usqInt) fieldIndex3 ) << (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: */
	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;

	i = 0;
	/* begin checkFreeSpace: */
	assert(bitsSetInFreeSpaceMaskForAllFreeLists());
	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 l1;
			}
		};
		error("segment not found");
		l1:
		;
		/* 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 objOop1;

	/* begin memoryActiveProcess */
	/* begin fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	objOop = unsignedLongAt((objOop1 + 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)))) {
			int t0;
			int t1;

			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 l2;
		}
		if (proc & (tagMask())) {
			goto l2;
		}
		if (!(aList >= 0x20000000000LL)) {
			goto l2;
		}
		if (proc >= 0x20000000000LL) {
			goto l2;
		}
		if ((proc >= GIV(nilObj)) && (proc <= GIV(trueObj))) {
			goto l2;
		}
		if (!(proc >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l2;
		}
		remember(getFromPermToNewSpaceRememberedSet(), aList);
		l2:
		;
		/* 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)))) {
			int t0;
			int t1;

			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 l4;
		}
		if (proc & (tagMask())) {
			goto l4;
		}
		if (!(lastLink >= 0x20000000000LL)) {
			goto l4;
		}
		if (proc >= 0x20000000000LL) {
			goto l4;
		}
		if ((proc >= GIV(nilObj)) && (proc <= GIV(trueObj))) {
			goto l4;
		}
		if (!(proc >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l4;
		}
		remember(getFromPermToNewSpaceRememberedSet(), lastLink);
		l4:
		;
		/* 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)))) {
		int t0;
		int t1;

		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 l6;
	}
	if (proc & (tagMask())) {
		goto l6;
	}
	if (!(aList >= 0x20000000000LL)) {
		goto l6;
	}
	if (proc >= 0x20000000000LL) {
		goto l6;
	}
	if ((proc >= GIV(nilObj)) && (proc <= GIV(trueObj))) {
		goto l6;
	}
	if (!(proc >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l6;
	}
	remember(getFromPermToNewSpaceRememberedSet(), aList);
	l6:
	;
	/* 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)))) {
		int t0;
		int t1;

		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 l8;
	}
	if (aList & (tagMask())) {
		goto l8;
	}
	if (!(proc >= 0x20000000000LL)) {
		goto l8;
	}
	if (aList >= 0x20000000000LL) {
		goto l8;
	}
	if ((aList >= GIV(nilObj)) && (aList <= GIV(trueObj))) {
		goto l8;
	}
	if (!(aList >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l8;
	}
	remember(getFromPermToNewSpaceRememberedSet(), proc);
	l8:
	;
	/* 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));
	header2 = unsignedLongAt((methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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;
}
/*	Leave from a previous callbackFor now, do not allow a callback return unless we're in a 
	primitiveResponse  */
/* StackInterpreter>>#callbackLeave: */
EXPORT(sqInt)
callbackLeave(sqInt cbID)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	jmp_buf jmpBuf[MaxJumpBuf + 1 /* 33 */];

	if (!(asserta(primitiveFunctionPointer != 0))) {
		return 0;
	}
	if (!(cbID == GIV(jmpDepth))) {
		return 0;
	}
	if (cbID < 1) {
		return 0;
	}
	longjmp(GIV(jmpBuf)[GIV(jmpDepth)], 1);
	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());
}
/*	Ensure that all accessible objects in the heap are okay. */
/* StackInterpreter>>#checkAllAccessibleObjectsOkay */
sqInt
checkAllAccessibleObjectsOkay(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt address;
	sqInt address1;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	sqInt ok;
	sqInt oop;
	sqInt prevObj;
	sqInt prevObj2;
	sqInt prevPrevObj;
	sqInt prevPrevObj2;

	ok = 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));
			{
				ok = ok && (checkOkayFields(objOop2));
			}
		}
		prevPrevObj = prevObj;
		prevObj = objOop2;
		/* begin objectAfter:limit: */
		followingWordAddress = addressAfter(objOop2);
		if (oopisGreaterThanOrEqualTo(followingWordAddress, limit)) {
			objOop2 = limit;
			goto l1;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l1:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* end objectStartingAt: */
	while (oopisLessThan(objOop2, GIV(freeStart))) {
		{
			assert(isEnumerableObjectNoAssert(objOop2));
			{
				ok = ok && (checkOkayFields(objOop2));
			}
		}
		prevPrevObj = prevObj;
		prevObj = objOop2;
		/* begin objectAfter:limit: */
		followingWordAddress2 = addressAfter(objOop2);
		if (oopisGreaterThanOrEqualTo(followingWordAddress2, GIV(freeStart))) {
			objOop2 = GIV(freeStart);
			goto l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* 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)) {
				{
					ok = ok && (checkOkayFields(objOop22));
				}
			}
		}
		prevPrevObj2 = prevObj2;
		prevObj2 = objOop22;
		/* begin objectAfter:limit: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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()))) {
			{
				ok = ok && (checkOkayFields(currentObject));
			}
		}
		/* begin objectAfter:limit: */
		followingWordAddress3 = addressAfter(currentObject);
		if (oopisGreaterThanOrEqualTo(followingWordAddress3, GIV(permSpaceFreeStart))) {
			currentObject = GIV(permSpaceFreeStart);
			goto l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* end objectAfter:limit: */
	};
	/* end allPermSpaceObjectsDo: */
	/* end allObjectsDo: */
	return ok;
}
/*	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 objOop1;
	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: */
			objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			/* end splObj: */
			objOop = unsignedLongAt((objOop1 + 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;
		}
	}
	if (((now = ioUTCMicroseconds())) >= GIV(nextPollUsecs)) {
		ioProcessEvents();
		GIV(nextPollUsecs) = now + 20000;
	}
	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 ((!(isFree(thePage))) && ((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;
}
/* StackInterpreter>>#checkOkayInterpreterObjects: */
sqInt
checkOkayInterpreterObjects(sqInt writeBack)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt i;
	sqInt iLimiT;
	sqInt ok;
	sqInt oop;
	sqIntptr_t oopOrZero;

	ok = 1;
	ok = ok && (checkOkayFields(GIV(nilObj)));
	ok = ok && (checkOkayFields(GIV(falseObj)));
	ok = ok && (checkOkayFields(GIV(trueObj)));
	ok = ok && (checkOkayFields(GIV(specialObjectsOop)));
	ok = ok && (checkOkayFields(GIV(messageSelector)));
	ok = ok && (checkOkayFields(GIV(newMethod)));
	ok = ok && (checkOkayFields(GIV(lkupClass)));
	for (i = 0; i < MethodCacheEntries; i += MethodCacheEntrySize) {
		oopOrZero = GIV(methodCache)[i + MethodCacheSelector];
		if (!(oopOrZero == 0)) {
			ok = ok && (checkOkayFields(GIV(methodCache)[i + MethodCacheSelector]));
			ok = ok && (checkOkayFields(GIV(methodCache)[i + MethodCacheMethod]));
		}
	};
	for (i = 1, iLimiT = remapBufferCount(); i <= iLimiT; i += 1) {
		oop = GIV(remapBuffer)[i];
		if (!(oop & (tagMask()))) {
			ok = ok && (checkOkayFields(oop));
		}
	};
	ok = ok && (checkOkayStackZone(writeBack));
	return ok;
}
/* StackInterpreter>>#checkOkayStackPage: */
static sqInt NoDbgRegParms
checkOkayStackPage(StackPage *thePage)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *callerFP;
	char *frameRcvrOffset;
	sqInt ok;
	sqInt oop;
	char *theFP;
	char *theSP;

	theSP = (thePage->headSP);
	theFP = (thePage->headFP);
	ok = 1;
	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 & 7) == 1))) {
				ok = ok && (checkOkayFields(oop));
			}
			theSP += BytesPerWord;
		};
		if (((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
			 ? ((unsignedLongAt(theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
			 : (byteAt((theFP + FoxIFrameFlags) + 2)) != 0)) {
			assert(isContext(frameContext(theFP)));
			ok = ok && (checkOkayFields(unsignedLongAt(theFP + FoxThisContext)));
		}
		ok = ok && (checkOkayFields(((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
			 ? ((mframeHomeMethod(theFP))->methodObject)
			 : unsignedLongAt(theFP + FoxMethod))));
		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 & 7) == 1))) {
			ok = ok && (checkOkayFields(oop));
		}
		theSP += BytesPerWord;
	};
	return ok;
}
/*	Check that all objects in the stack zone are okay */
/* StackInterpreter>>#checkOkayStackZone: */
static sqInt NoDbgRegParms
checkOkayStackZone(sqInt writeBack)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt i;
	sqInt ok;
	StackPage *thePage;
	char *theSP;

	if (writeBack) {
		/* 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 */
	}
	ok = 1;
	for (i = 0; i < GIV(numStackPages); i += 1) {
		/* begin stackPageAt: */
		thePage = stackPageAtpages(i, GIV(pages));
		/* end stackPageAt: */
		if (!(isFree(thePage))) {
			ok = ok && (checkOkayStackPage(thePage));
		}
	};
	return ok;
}
/*	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 objOop1;

	assert(GIV(nextProfileTick) != 0);
	if ((ioHighResClock()) >= GIV(nextProfileTick)) {
		/* begin memoryActiveProcess */
		/* begin fetchPointer:ofObject: */
		/* begin fetchPointer:ofObject: */
		/* begin splObj: */
		/* begin fetchPointer:ofObject: */
		objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		objOop = unsignedLongAt((objOop1 + 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;
	}
}
/*	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));
		header2 = unsignedLongAt((methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		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 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 -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 mnuBreakpoint:receiver: */
	mnuBreakpointreceiver(firstFixedFieldOfMaybeImmediate(GIV(messageSelector)), lengthOfMaybeImmediate(GIV(messageSelector)), null);
	/* end mnuBreakpoint:receiver: */
	/* 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 l4;
		}
	}
	long64Atput(newObj, ((((usqLong) GIV(argumentCount) ) << (numSlotsFullShift())) + (2U << (formatShift()))) + ClassArrayCompactIndex);
	GIV(freeStart) += numBytes;
	argumentArray = newObj;
	/* end allocateSmallNewSpaceSlots:format:classIndex: */
	l4:
	;
	/* 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 l5;
		}
	}
	long64Atput(newObj2, ((((usqLong) numSlots ) << (numSlotsFullShift())) + (1U << (formatShift()))) + ClassMessageCompactIndex);
	GIV(freeStart) += numBytes2;
	message = newObj2;
	/* end allocateSmallNewSpaceSlots:format:classIndex: */
	l5:
	;
	/* 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;
	StackPage *aPage;
	sqInt i;
	char *theFP;
	char *theSP;
	char *theSP1;

	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);
	theSP1 = 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, theSP1);
	l2:
	;
	/* end ensureFrameIsMarried:SP: */
	for (i = 0; i < GIV(numStackPages); i += 1) {
		/* begin stackPageAt: */
		aPage = stackPageAtpages(i, GIV(pages));
		/* end stackPageAt: */
		if (!(isFree(aPage))) {
			divorceFramesIn(aPage);
		}
	};
	/* 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 valuePointer1;

	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 l6;
		}
		theContext = marryFrameSP(theFP, theSP);
		l6:
		;
		/* 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)))) {
				int t0;
				int t1;

				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 l2;
			}
			if (theContext & (tagMask())) {
				goto l2;
			}
			if (!(calleeContext >= 0x20000000000LL)) {
				goto l2;
			}
			if (theContext >= 0x20000000000LL) {
				goto l2;
			}
			if ((theContext >= GIV(nilObj)) && (theContext <= GIV(trueObj))) {
				goto l2;
			}
			if (!(theContext >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l2;
			}
			remember(getFromPermToNewSpaceRememberedSet(), calleeContext);
			l2:
			;
			/* 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)));
	valuePointer1 = callerContextOrNil;
	/* end frameCallerContext: */
	assert(!(isForwarded(theContext)));
	if (((theContext & (tagMask())) == 0) && ((theContext & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		int t0;
		int t1;

		if (((valuePointer1 & (tagMask())) == 0) && (((valuePointer1 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (valuePointer1 >= ((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 (valuePointer1 & (tagMask())) {
		goto l4;
	}
	if (!(theContext >= 0x20000000000LL)) {
		goto l4;
	}
	if (valuePointer1 >= 0x20000000000LL) {
		goto l4;
	}
	if ((valuePointer1 >= GIV(nilObj)) && (valuePointer1 <= GIV(trueObj))) {
		goto l4;
	}
	if (!(valuePointer1 >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l4;
	}
	remember(getFromPermToNewSpaceRememberedSet(), theContext);
	l4:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((theContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), valuePointer1);
	/* 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 l7;
		/* 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 l7;
	}
	callerCtx = marryFrameSP(callerFP2, (assert(!(isBaseFrame(theFP))), (theFP + (frameStackedReceiverOffset(theFP))) + BytesPerWord));
	/* end ensureFrameIsMarried:SP: */
	l7:
	;
	/* 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 l2;
		}
		divorceFramesIn(lruOrFree);
		newPage = lruOrFree;
		l2:
		;
		/* 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)))) {
		int t0;
		int t1;

		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 l3;
	}
	if (callerCtx & (tagMask())) {
		goto l3;
	}
	if (!(ctxt >= 0x20000000000LL)) {
		goto l3;
	}
	if (callerCtx >= 0x20000000000LL) {
		goto l3;
	}
	if ((callerCtx >= GIV(nilObj)) && (callerCtx <= GIV(trueObj))) {
		goto l3;
	}
	if (!(callerCtx >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l3;
	}
	remember(getFromPermToNewSpaceRememberedSet(), ctxt);
	l3:
	;
	/* 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 objOop1;

	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: */
		objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		objOop = unsignedLongAt((objOop1 + 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: */
		}
	}
}
/* StackInterpreter>>#dummyReferToProxy */
static void
dummyReferToProxy(void)
{
}
/*	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 address1;
	sqInt address11;
	sqInt address2;
	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 limit1;
	sqInt limit11;
	usqInt limit3;
	sqInt methodHeader;
	usqInt numSlots;
	usqInt numSlots2;
	usqInt numSlots22;
	usqInt numSlots3;
	sqInt obj;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop222;
	sqInt objOop23;
	sqInt objOop3;
	sqInt objOop32;
	sqInt objOop4;
	sqInt oop;
	sqInt prevObj;
	sqInt prevObj2;
	sqInt prevObj22;
	sqInt prevObj3;
	sqInt prevPrevObj;
	sqInt prevPrevObj2;
	sqInt prevPrevObj22;
	sqInt prevPrevObj3;
	sqInt startAddr;
	sqInt stopAddr;
	sqInt stopAddr1;
	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: */
		address2 = ((pastSpace()).start);
		numSlots3 = byteAt(address2 + 7);
		objOop23 = ((numSlots3 == (numSlotsMask()))
			 ? address2 + BaseHeaderSize
			 : address2);
		/* 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: */
						stopAddr1 = objOop23 + (((numSlotsOf(objOop23)) << (shiftForWord())) + BaseHeaderSize);
						addr2 = wordAddr;
						while (oopisLessThan(addr2, stopAddr1)) {
							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 l12;
			}
			flag("endianness");
			followingWord5 = unsignedLongAt(followingWordAddress5);
			objOop23 = (((((usqInt) followingWord5 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress5 + BaseHeaderSize
				 : followingWordAddress5);
			l12:
			;
			/* end objectAfter:limit: */
		};
		/* begin objectStartingAt: */
		address11 = ((eden()).start);
		numSlots22 = byteAt(address11 + 7);
		objOop23 = ((numSlots22 == (numSlotsMask()))
			 ? address11 + BaseHeaderSize
			 : address11);
		/* 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: */
						stopAddr1 = objOop23 + (((numSlotsOf(objOop23)) << (shiftForWord())) + BaseHeaderSize);
						addr2 = wordAddr;
						while (oopisLessThan(addr2, stopAddr1)) {
							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 l9;
			}
			flag("endianness");
			followingWord22 = unsignedLongAt(followingWordAddress22);
			objOop23 = (((((usqInt) followingWord22 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress22 + BaseHeaderSize
				 : followingWordAddress22);
			l9:
			;
			/* 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: */
							stopAddr1 = objOop222 + (((numSlotsOf(objOop222)) << (shiftForWord())) + BaseHeaderSize);
							addr2 = wordAddr;
							while (oopisLessThan(addr2, stopAddr1)) {
								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: */
			limit11 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			followingWordAddress42 = addressAfter(objOop222);
			if (oopisGreaterThanOrEqualTo(followingWordAddress42, limit11)) {
				objOop222 = limit11;
				goto l13;
			}
			flag("endianness");
			followingWord42 = unsignedLongAt(followingWordAddress42);
			objOop222 = (((((usqInt) followingWord42 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress42 + BaseHeaderSize
				 : followingWordAddress42);
			l13:
			;
			/* 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: */
						stopAddr1 = currentObject2 + (((numSlotsOf(currentObject2)) << (shiftForWord())) + BaseHeaderSize);
						addr2 = wordAddr;
						while (oopisLessThan(addr2, stopAddr1)) {
							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 l10;
			}
			flag("endianness");
			followingWord32 = unsignedLongAt(followingWordAddress32);
			currentObject2 = (((((usqInt) followingWord32 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress32 + BaseHeaderSize
				 : followingWordAddress32);
			l10:
			;
			/* end objectAfter:limit: */
		};
		/* end allPermSpaceObjectsDo: */
		/* end allObjectsDo: */
		/* end updateObjectsPostByteSwap */
		/* end reverseBytesInImage */
	} else {
		/* begin convertFloatsToPlatformOrder */
		if (VMBIGENDIAN == GIV(imageFloatsBigEndian)) {
			goto l7;
		}
		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 l1;
			}
			flag("endianness");
			followingWord = unsignedLongAt(followingWordAddress);
			objOop2 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress + BaseHeaderSize
				 : followingWordAddress);
			l1:
			;
			/* end objectAfter:limit: */
		};
		/* begin objectStartingAt: */
		address1 = ((eden()).start);
		numSlots2 = byteAt(address1 + 7);
		objOop2 = ((numSlots2 == (numSlotsMask()))
			 ? address1 + BaseHeaderSize
			 : address1);
		/* 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 l2;
			}
			flag("endianness");
			followingWord2 = unsignedLongAt(followingWordAddress2);
			objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress2 + BaseHeaderSize
				 : followingWordAddress2);
			l2:
			;
			/* 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: */
			limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
			followingWordAddress4 = addressAfter(objOop22);
			if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
				objOop22 = limit1;
				goto l6;
			}
			flag("endianness");
			followingWord4 = unsignedLongAt(followingWordAddress4);
			objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress4 + BaseHeaderSize
				 : followingWordAddress4);
			l6:
			;
			/* 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 l5;
			}
			flag("endianness");
			followingWord3 = unsignedLongAt(followingWordAddress3);
			currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
				 ? followingWordAddress3 + BaseHeaderSize
				 : followingWordAddress3);
			l5:
			;
			/* end objectAfter:limit: */
		};
		/* end allPermSpaceObjectsDo: */
		/* end allObjectsDo: */
		l7:
		;
		/* 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 *thePage1;

	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: */
		thePage1 = GIV(stackPage);
		GIV(stackPointer) = (thePage1->headSP);
		GIV(framePointer) = (thePage1->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;
	}
	/* end primitiveFail */
	return null;
	/* 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: */
			callerFP = pointerForOop(unsignedLongAt(spouseFP + FoxSavedFP));
			if (callerFP == 0) {
				/* begin frameCallerContext: */
				assert(isBaseFrame(spouseFP));
				/* 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: */
				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(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: */
				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: */
				/* begin findFrameAbove:inPage: */
				fp = (thePage2->headFP);
				if (fp == spouseFP) {
					theFPAbove = 0;
					goto l6;
				}
				while (((callerFP2 = pointerForOop(unsignedLongAt(fp + FoxSavedFP)))) != 0) {
					if (callerFP2 == spouseFP) {
						theFPAbove = fp;
						goto l6;
					}
					fp = callerFP2;
				};
				error("did not find theFP in stack page");
				theFPAbove = 0;
				l6:
				;
				/* end findFrameAbove:inPage: */
				theIP = ((theFPAbove == 0)
					 ? longAt((thePage2->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 l1;
		}
		theSP = ((thePage == GIV(stackPage))
			 ? (thePage->headSP)
			 : ((thePage->headSP)) + BytesPerWord);
		goto l1;
	}
	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 l1;
		}
	};
	theSP = null;
	l1:
	;
	/* 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 l4;
		}
		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 l4;
				}
				ctxtOrNilOrZero = marryFrameSP(theFP, theSP);
				goto l4;
				/* 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 l4;
		/* end nilObject */
	}
	ctxtOrNilOrZero = findMethodWithPrimitiveFromContextUpToContext(198, senderContext, homeContext);
	l4:
	;
	/* 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 oop;
	char *ptr;
	sqInt referent;
	char * toDoLimit1;
	char * toDoLimit2;

	for (ptr = theSP, toDoLimit1 = ((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
		 ? theFP + FoxMFReceiver
		 : theFP + FoxIFReceiver); ptr <= toDoLimit1; ptr += BytesPerWord) {
		oop = unsignedLongAt(ptr);
		if (((oop & (tagMask())) == 0) && (((long64At(oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			unsignedLongAtput(ptr, followForwarded(oop));
		}
	};
	for (ptr = (theFP + FoxCallerSavedIP) + BytesPerWord, toDoLimit2 = theFP + (frameStackedReceiverOffsetNumArgs(((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
		 ? ((((CogMethod *) ((unsignedLongAt(theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
		 : byteAt((theFP + FoxIFrameFlags) + 1)))); ptr <= toDoLimit2; 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))));
	}
}
/*	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;
}
/* 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 *thePage;

	for (i = 0; i < GIV(numStackPages); i += 1) {
		/* begin stackPageAt: */
		thePage = stackPageAtpages(i, GIV(pages));
		/* end stackPageAt: */
		if ((!(isFree(thePage))) && (((thePage->trace)) == StackPageUnreached)) {
			assert(noMarkedContextsOnPage(thePage));
			freeStackPage(thePage);
		}
		assert(((thePage->trace = StackPageTraceInvalid)) != 0);
	};
}
/*	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:inClass: */
void (*functionPointerForinClass(sqInt primIdx,sqInt theClass))(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)) )))
		 ? longAt(GIV(framePointer) + FoxMFReceiver)
		 : unsignedLongAt(GIV(framePointer) + FoxIFReceiver)))) {
		followForwardedObjectFieldstoDepth(((isMachineCodeIP(((usqInt) (unsignedLongAt(GIV(framePointer) + FoxMethod)) )))
			 ? longAt(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)) )))
		 ? longAt(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;
	StackPage *lruOrFree;
	StackPage *newPage;
	sqInt overflowCount;
	char *overflowLimitAddress;
	sqInt source;
	char *theFP;
	StackPage *thePage;

	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 l3;
		/* 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 l3;
	}
	marryFrameSP(callerFP2, (assert(!(isBaseFrame(theFP))), (theFP + (frameStackedReceiverOffset(theFP))) + BytesPerWord));
	/* end ensureFrameIsMarried:SP: */
	l3:
	;
	/* end ensureCallerContext: */
	/* begin newStackPage */
	lruOrFree = (GIV(mostRecentlyUsedPage)->nextPage);
	if (((lruOrFree->baseFP)) == 0) {
		newPage = lruOrFree;
		goto l1;
	}
	divorceFramesIn(lruOrFree);
	newPage = lruOrFree;
	l1:
	;
	/* 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)))));
	}
}
/*	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;
	char *theSP;

	/* 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 (GIV(stackLimit) == ((GIV(stackPage)->realStackLimit))) {
		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;
}
/* StackInterpreter>>#iframeMethod: */
static usqInt NoDbgRegParms
iframeMethod(char *theFP)
{
	return unsignedLongAt(theFP + FoxMethod);
}
/*	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 valuePointer1;

	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 (!((isFree(thePage)) || (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: */
		valuePointer1 = GIV(nilObj);
		assert(!(isOopForwarded(aOnceMarriedContext)));
		longAtput((aOnceMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), valuePointer1);
		/* 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 valuePointer1;

	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 (!((isFree(thePage)) || (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: */
		valuePointer1 = GIV(nilObj);
		assert(!(isOopForwarded(aOnceMarriedContext)));
		longAtput((aOnceMarriedContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), valuePointer1);
		/* 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 objOop1;

	runLeakCheckerFor(GCModeFull);
	/* begin memoryActiveProcess */
	/* begin fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	objOop = unsignedLongAt((objOop1 + 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 fmt1;
	sqInt fmt2;
	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: */
			fmt1 = (((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 (fmt1 <= 5) {
				len = numSlots;
				goto l7;
			}
			if (fmt1 >= (firstByteFormat())) {
				len = (numSlots << (shiftForWord())) - (fmt1 & 7);
				goto l7;
			}
			if (fmt1 >= (firstShortFormat())) {
				len = (numSlots << ((shiftForWord()) - 1)) - (fmt1 & 3);
				goto l7;
			}
			if (fmt1 >= (firstLongFormat())) {
				len = (numSlots << ((shiftForWord()) - 2)) - (fmt1 & 1);
				goto l7;
			}
			if (fmt1 == (sixtyFourBitIndexableFormat())) {
				len = numSlots;
				goto l7;
			}
			len = 0;
			l7:
			;
			/* 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 l19;
					}
				}
				printDecodeMethodHeaderOop(fieldOop);
				goto l19;
				l19:
				;
				/* 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: */
		fmt2 = (((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 (fmt2 <= 5) {
			lastIndex = numSlots3;
			goto l17;
		}
		if (fmt2 >= (firstByteFormat())) {
			lastIndex = (numSlots3 << (shiftForWord())) - (fmt2 & 7);
			goto l17;
		}
		if (fmt2 >= (firstShortFormat())) {
			lastIndex = (numSlots3 << ((shiftForWord()) - 1)) - (fmt2 & 3);
			goto l17;
		}
		if (fmt2 >= (firstLongFormat())) {
			lastIndex = (numSlots3 << ((shiftForWord()) - 2)) - (fmt2 & 1);
			goto l17;
		}
		if (fmt2 == (sixtyFourBitIndexableFormat())) {
			lastIndex = numSlots3;
			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 > 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 objOop4;
	sqInt objOop5;
	sqInt objOop6;
	sqInt objOop7;
	sqInt selector;
	int wrapAround;

	assert(addressCouldBeClassObj(class));
	/* begin lookupBreakFor: */
	if ((breakLookupClassTag != null) && ((class == breakLookupClassTag) || (((uint32AtPointer(class + 4)) & (identityHashHalfWordMask())) == breakLookupClassTag))) {
		warning("lookup class send break (heartbeat suppressed)");
	}
	/* end lookupBreakFor: */
	currentClass = class;
	while (currentClass != GIV(nilObj)) {
		/* begin followObjField:ofObject: */
		/* begin fetchPointer:ofObject: */
		objOop = unsignedLongAt((currentClass + BaseHeaderSize) + ((sqInt) (((usqInt) MethodDictionaryIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		assert(isNonImmediate(objOop));
		if (((long64At(objOop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
			objOop = fixFollowedFieldofObjectwithInitialValue(MethodDictionaryIndex, currentClass, objOop);
		}
		dictionary = objOop;
		/* 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: */
			return lookupMethodInClass(followFieldofObject(SuperclassIndex, currentClass));
		}
		/* 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 l20;
				}
				index += 1;
			};
			found = 0;
			goto l20;
		}
		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 l20;
			}
			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 l20;
			}
			index += 1;
			if (index == length) {
				if (wrapAround) {
					found = 0;
					goto l20;
				}
				wrapAround = 1;
				index = SelectorStart;
			}
		};
		found = 0;
		l20:
		;
		/* end lookupMethodInDictionary: */
		if (found) {
			return currentClass;
		}
		/* begin followField:ofObject: */
		/* begin fetchPointer:ofObject: */
		objOop2 = unsignedLongAt((currentClass + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((objOop2 & (tagMask())) == 0) && (((long64At(objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
			objOop2 = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, currentClass, objOop2);
		}
		currentClass = objOop2;
		/* 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 rather than performing MNU 
	processing etc. */
/* StackInterpreter>>#lookupMNUInClass: */
static sqInt NoDbgRegParms
lookupMNUInClass(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;

	/* begin lookupBreakFor: */
	if ((breakLookupClassTag != null) && ((class == breakLookupClassTag) || (((uint32AtPointer(class + 4)) & (identityHashHalfWordMask())) == breakLookupClassTag))) {
		warning("lookup class send break (heartbeat suppressed)");
	}
	/* end lookupBreakFor: */
	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 l18;
				}
				index += 1;
			};
			found = 0;
			goto l18;
		}
		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 l18;
			}
			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 l18;
			}
			index += 1;
			if (index == length) {
				if (wrapAround) {
					found = 0;
					goto l18;
				}
				wrapAround = 1;
				index = SelectorStart;
			}
		};
		found = 0;
		l18:
		;
		/* 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 messageSelector in class. Answer 0 on success. Answer the splObj: 
	index for the error selector to use on failure rather than performing MNU 
	processing etc. */
/* StackInterpreter>>#lookupOrdinaryNoMNUEtcInClass: */
static sqInt NoDbgRegParms
lookupOrdinaryNoMNUEtcInClass(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;

	/* begin lookupBreakFor: */
	if ((breakLookupClassTag != null) && ((class == breakLookupClassTag) || (((uint32AtPointer(class + 4)) & (identityHashHalfWordMask())) == breakLookupClassTag))) {
		warning("lookup class send break (heartbeat suppressed)");
	}
	/* end lookupBreakFor: */
	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 l18;
				}
				index += 1;
			};
			found = 0;
			goto l18;
		}
		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 l18;
			}
			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 l18;
			}
			index += 1;
			if (index == length) {
				if (wrapAround) {
					found = 0;
					goto l18;
				}
				wrapAround = 1;
				index = SelectorStart;
			}
		};
		found = 0;
		l18:
		;
		/* 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 l6;
				}
				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 l6;
					/* end followField:ofObject: */
				}
				index += 1;
				if (index == length) {
					if (wrapAround) {
						meth = null;
						goto l6;
					}
					wrapAround = 1;
					index = SelectorStart;
				}
			};
			meth = null;
			l6:
			;
			/* 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;
}
/*	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 valuePointer1;
	sqInt valuePointer2;

	assert(isContext(ctxt));
	if ((((unsignedLongAt((ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
		/* begin markContextAsDead: */
		assert(isContext(ctxt));
		{
			/* begin storePointerUnchecked:ofObject:withValue: */
			valuePointer2 = GIV(nilObj);
			assert(!(isOopForwarded(ctxt)));
			longAtput((ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), valuePointer2);
			/* end storePointerUnchecked:ofObject:withValue: */
			/* begin storePointerUnchecked:ofObject:withValue: */
			valuePointer1 = GIV(nilObj);
			assert(!(isOopForwarded(ctxt)));
			longAtput((ctxt + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), valuePointer1);
			/* 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 l3;
		}
	}
	long64Atput(newObj, ((((usqLong) numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) objFormat ) << (formatShift())) )) + classIndex);
	GIV(freeStart) += numBytes;
	pointResult = newObj;
	/* end allocateSmallNewSpaceSlots:format:classIndex: */
	/* end eeInstantiateSmallClassIndex:format:numSlots: */
	l3:
	;
	/* 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));
	}
}
/*	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;

	if (!fullGCFlag) {
		for (i = 0; i < GIV(numStackPages); i += 1) {
			/* begin stackPageAt: */
			thePage = stackPageAtpages(i, GIV(pages));
			/* end stackPageAt: */
			if (!(isFree(thePage))) {
				markAndTraceStackPage(thePage);
			}
		};
		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;
}
/*	Trace any untraced pages */
/* StackInterpreter>>#markAndTraceUntracedReachableStackPages */
static void
markAndTraceUntracedReachableStackPages(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	int foundToBeTracedPage;
	sqInt i;
	StackPage *thePage;

	do{
		foundToBeTracedPage = 0;
		for (i = 0; i < GIV(numStackPages); i += 1) {
			/* begin stackPageAt: */
			thePage = stackPageAtpages(i, GIV(pages));
			/* end stackPageAt: */
			if ((!(isFree(thePage))) && (((thePage->trace)) == StackPageReachedButUntraced)) {
				foundToBeTracedPage = 1;
				markAndTraceStackPage(thePage);
			}
		};
	}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;
	char * numStack;
	sqInt theContext;
	char *value;
	sqInt valuePointer;
	sqInt valuePointer2;
	sqInt valuePointer3;
	sqInt valuePointer4;
	sqInt valuePointer5;
	sqInt valuePointer6;

	/* 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));
	header = unsignedLongAt((methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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);
		valuePointer3 = (oopForPointer(theFP)) + (smallIntegerTag());
	}
	assert(!(isOopForwarded(theContext)));
	longAtput((theContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), valuePointer3);
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	/* begin withSmallIntegerTags: */
	value = pointerForOop(unsignedLongAt(theFP + FoxSavedFP));
	assert(((oopForPointer(value)) & (BytesPerWord - 1)) == 0);
	valuePointer4 = (oopForPointer(value)) + (smallIntegerTag());
	/* end withSmallIntegerTags: */
	assert(!(isOopForwarded(theContext)));
	longAtput((theContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), valuePointer4);
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	assert(!(isOopForwarded(theContext)));
	longAtput((theContext + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ), ((((usqInt) numStack ) << 3) | 1));
	/* end storePointerUnchecked:ofObject:withValue: */
	/* begin storePointerUnchecked:ofObject:withValue: */
	valuePointer5 = ((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
		 ? ((mframeHomeMethod(theFP))->methodObject)
		 : unsignedLongAt(theFP + FoxMethod));
	assert(!(isOopForwarded(theContext)));
	longAtput((theContext + BaseHeaderSize) + ((sqInt) (((usqInt) MethodIndex ) << (shiftForWord())) ), valuePointer5);
	/* 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: */
	valuePointer6 = ((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
		 ? longAt(theFP + FoxMFReceiver)
		 : unsignedLongAt(theFP + FoxIFReceiver));
	assert(!(isOopForwarded(theContext)));
	longAtput((theContext + BaseHeaderSize) + ((sqInt) (((usqInt) ReceiverIndex ) << (shiftForWord())) ), valuePointer6);
	/* 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: */
		valuePointer2 = GIV(nilObj);
		assert(!(isOopForwarded(theContext)));
		longAtput((theContext + BaseHeaderSize) + ((sqInt) (((usqInt) (ReceiverIndex + i) ) << (shiftForWord())) ), valuePointer2);
		/* 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 offset1;
	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: */
		offset1 = (literalCountOf(methodObj)) - 2;
		/* begin fetchPointer:ofObject: */
		penultimateLiteral = unsignedLongAt((methodObj + BaseHeaderSize) + ((sqInt) (((usqInt) (offset1 + 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)));
	header = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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)
{
}
/*	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 l2;
		}
	}
	long64Atput(newObj, ((((usqLong) numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) objFormat ) << (formatShift())) )) + ClassLargePositiveIntegerCompactIndex);
	GIV(freeStart) += numBytes;
	newLargeInteger = newObj;
	/* end allocateSmallNewSpaceSlots:format:classIndex: */
	l2:
	;
	/* 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 oop1;
	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 l4;
	}
	/* 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 l4;
	}
	if (fmt <= (sixtyFourBitIndexableFormat())) {
		len1 = numBytes;
		goto l4;
	}
	if (fmt >= (firstShortFormat())) {
		len1 = numBytes - ((sqInt) (((usqInt) (fmt & 3) ) << 1) );
		goto l4;
	}
	len1 = numBytes - ((sqInt) (((usqInt) (fmt & 1) ) << 2) );
	/* end numBytesOf: */
	l4:
	;
	/* end byteSizeOf: */
	/* begin byteSizeOf: */
	if (arg2 & (tagMask())) {
		len2 = 0;
		goto l6;
	}
	/* 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 l6;
	}
	if (fmt2 <= (sixtyFourBitIndexableFormat())) {
		len2 = numBytes2;
		goto l6;
	}
	if (fmt2 >= (firstShortFormat())) {
		len2 = numBytes2 - ((sqInt) (((usqInt) (fmt2 & 3) ) << 1) );
		goto l6;
	}
	len2 = numBytes2 - ((sqInt) (((usqInt) (fmt2 & 1) ) << 2) );
	/* end numBytesOf: */
	l6:
	;
	/* end byteSizeOf: */
	if (!(len1 == len2)) {
		{
			/* begin pop:thenPush: */
			oop1 = GIV(falseObj);
			unsignedLongAtput((sp2 = GIV(stackPointer) + ((2 - 1) * BytesPerWord)), oop1);
			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 objOop1;
	sqInt oop;
	sqInt oop1;
	sqInt oop2;
	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: */
		objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		objOop = unsignedLongAt((objOop1 + 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)))) {
			int t0;
			int t1;

			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 l5;
		}
		if (activeProc & (tagMask())) {
			goto l5;
		}
		if (!(criticalSection >= 0x20000000000LL)) {
			goto l5;
		}
		if (activeProc >= 0x20000000000LL) {
			goto l5;
		}
		if ((activeProc >= GIV(nilObj)) && (activeProc <= GIV(trueObj))) {
			goto l5;
		}
		if (!(activeProc >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l5;
		}
		remember(getFromPermToNewSpaceRememberedSet(), criticalSection);
		l5:
		;
		/* 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: */
			oop1 = GIV(trueObj);
			unsignedLongAtput((sp2 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), oop1);
			GIV(stackPointer) = sp2;
			/* end pop:thenPush: */
			return;
		}
	}
	/* begin pop:thenPush: */
	oop2 = GIV(falseObj);
	unsignedLongAtput((sp3 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), oop2);
	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));
	header = unsignedLongAt((methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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)))) {
			int t0;
			int t1;

			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 l7;
		}
		if (myList & (tagMask())) {
			goto l7;
		}
		if (!(process >= 0x20000000000LL)) {
			goto l7;
		}
		if (myList >= 0x20000000000LL) {
			goto l7;
		}
		if ((myList >= GIV(nilObj)) && (myList <= GIV(trueObj))) {
			goto l7;
		}
		if (!(myList >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l7;
		}
		remember(getFromPermToNewSpaceRememberedSet(), process);
		l7:
		;
		/* 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)))) {
			int t0;
			int t1;

			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 l19;
		}
		if (nextLink & (tagMask())) {
			goto l19;
		}
		if (!(myList >= 0x20000000000LL)) {
			goto l19;
		}
		if (nextLink >= 0x20000000000LL) {
			goto l19;
		}
		if ((nextLink >= GIV(nilObj)) && (nextLink <= GIV(trueObj))) {
			goto l19;
		}
		if (!(nextLink >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l19;
		}
		remember(getFromPermToNewSpaceRememberedSet(), myList);
		l19:
		;
		/* 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 l26;
			}
			/* 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)))) {
			int t0;
			int t1;

			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 l12;
		}
		if (nextLink & (tagMask())) {
			goto l12;
		}
		if (!(tempLink >= 0x20000000000LL)) {
			goto l12;
		}
		if (nextLink >= 0x20000000000LL) {
			goto l12;
		}
		if ((nextLink >= GIV(nilObj)) && (nextLink <= GIV(trueObj))) {
			goto l12;
		}
		if (!(nextLink >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l12;
		}
		remember(getFromPermToNewSpaceRememberedSet(), tempLink);
		l12:
		;
		/* 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)))) {
				int t0;
				int t1;

				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 l16;
			}
			if (tempLink & (tagMask())) {
				goto l16;
			}
			if (!(myList >= 0x20000000000LL)) {
				goto l16;
			}
			if (tempLink >= 0x20000000000LL) {
				goto l16;
			}
			if ((tempLink >= GIV(nilObj)) && (tempLink <= GIV(trueObj))) {
				goto l16;
			}
			if (!(tempLink >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l16;
			}
			remember(getFromPermToNewSpaceRememberedSet(), myList);
			l16:
			;
			/* 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)))) {
		int t0;
		int t1;

		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 l14;
	}
	if (GIV(nilObj) & (tagMask())) {
		goto l14;
	}
	if (!(process >= 0x20000000000LL)) {
		goto l14;
	}
	if (GIV(nilObj) >= 0x20000000000LL) {
		goto l14;
	}
	if ((GIV(nilObj) >= GIV(nilObj)) && (GIV(nilObj) <= GIV(trueObj))) {
		goto l14;
	}
	if (!(GIV(nilObj) >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l14;
	}
	remember(getFromPermToNewSpaceRememberedSet(), process);
	l14:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((process + BaseHeaderSize) + ((sqInt) (((usqInt) NextLinkIndex ) << (shiftForWord())) ), GIV(nilObj));
	/* end storePointer:ofObject:withValue: */
	l26:
	;
	/* end removeProcess:fromList: */
	if (!GIV(primFailCode)) {
		/* begin storePointer:ofObject:withValue: */
		assert(!(isForwarded(process)));
		if (((process & (tagMask())) == 0) && ((process & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			int t0;
			int t1;

			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 l9;
		}
		if (GIV(nilObj) & (tagMask())) {
			goto l9;
		}
		if (!(process >= 0x20000000000LL)) {
			goto l9;
		}
		if (GIV(nilObj) >= 0x20000000000LL) {
			goto l9;
		}
		if ((GIV(nilObj) >= GIV(nilObj)) && (GIV(nilObj) <= GIV(trueObj))) {
			goto l9;
		}
		if (!(GIV(nilObj) >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l9;
		}
		remember(getFromPermToNewSpaceRememberedSet(), process);
		l9:
		;
		/* 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 class;
	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 l5;
				}
				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;
		}
		l5:
		;
		/* 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 l2;
		}
	}
	if (!((addressCouldBeObj(aMethod)) && (((((usqInt) (longAt(aMethod)) ) >> (formatShift())) & (formatMask())) >= (firstCompiledMethodFormat())))) {
		/* begin nilObject */
		methClass = GIV(nilObj);
		goto l2;
		/* end nilObject */
	}
	methClass = findClassContainingMethodstartingAt(aMethod, safeMethodClassOf(aMethod));
	l2:
	;
	/* 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 anOop;
	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 l5;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		currentObject = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l5:
		;
		/* 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 address1;
	sqInt classIdx;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	usqInt limit;
	sqInt limit1;
	sqInt mutexClass;
	usqInt numSlots;
	usqInt numSlots2;
	usqInt numSlots3;
	sqInt obj;
	sqInt objOop;
	sqInt objOop1;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	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: */
	objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	objOop2 = unsignedLongAt((objOop1 + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	proc = unsignedLongAt((objOop2 + 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: */
	objOop3 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	objOop = unsignedLongAt((objOop3 + 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l20;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l20:
		;
		/* 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 l19;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop5 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l19:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop5 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l16;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop5 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l16:
		;
		/* 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 l17;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l17:
		;
		/* 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 (isFree(thePage)) {
					{
						/* 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())) ));
		if ((((unsignedLongAt((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) {
			if ((assert(isNonImmediate(meth)), isCogMethodReference(unsignedLongAt((meth + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ))))) {
				{
					printHexnp(cogMethodOf(meth));
					/* begin space */
					printChar(' ');
					/* end space */
				}
			}
			shortPrintOop(meth);
		} else {
			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 (!(isFree(page))) {
			{
				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>>#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 (isFree(thePage)) {
			{
				/* 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 l4;
			}
			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 l4;
				}
			};
			frameAbove = null;
			l4:
			;
			/* 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 address1;
	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 limit1;
	sqInt methodClassAssociation;
	char *name;
	sqInt nameLen;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop23;
	sqInt objOop3;
	sqInt objOop4;
	sqInt offset;
	sqInt oop;
	sqInt prevObj;
	sqInt prevObj2;
	sqInt prevPrevObj;
	sqInt prevPrevObj2;
	sqInt tagBits;
	sqInt theClass2;

	/* 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 l17;
							}
							if (((oop & 7) == 1)) {
								{
									printNum(oop >> 3);
									printChar('(');
									printHexnp(oop >> 3);
									printChar(')');
								}
								goto l17;
							}
							if (oop & (smallFloatTag())) {
								{
									printFloat(dbgFloatValueOf(oop));
									printChar('(');
									printHexnp(oop);
									printChar(')');
								}
								goto l17;
							}
							{
								print("unknown immediate ");
								printHexnp(oop);
							}
							goto l17;
						}
						if (!(addressCouldBeObj(oop))) {
							print((((oop & (8 - 1)) != 0)
								 ? " is misaligned"
								 : whereIs(oop)));
							goto l17;
						}
						if (((longAt(oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
							print(" is a free chunk");
							goto l17;
						}
						if (((long64At(oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
							{
								print(" is a forwarder to ");
								printHexnp(followForwarded(oop));
							}
							goto l17;
						}
						if (((((tagBits = oop & (tagMask()))) != 0)
							 ? tagBits == (smallFloatTag())
							 : ((longAt(oop)) & (classIndexMask())) == ClassFloatCompactIndex)) {
							printFloat(dbgFloatValueOf(oop));
							goto l17;
						}
						classOop = fetchClassOfNonImm(oop);
						if (!(addressCouldBeObj(classOop))) {
							print("a ??");
							goto l17;
						}
						if ((numSlotsOf(classOop)) == GIV(metaclassNumSlots)) {
							printNameOfClasscount(oop, 5);
							goto l17;
						}
						if (oop == GIV(nilObj)) {
							print("nil");
							goto l17;
						}
						if (oop == GIV(trueObj)) {
							print("true");
							goto l17;
						}
						if (oop == GIV(falseObj)) {
							print("false");
							goto l17;
						}
						nameLen = lengthOfNameOfClass(classOop);
						if (nameLen == 0) {
							print("a ??");
							goto l17;
						}
						name = nameOfClass(classOop);
						if (nameLen == 10) {
							if ((strncmp(name, "ByteString", 10)) == 0) {
								{
									printChar('\'');
									printStringOf(oop);
									printChar('\'');
								}
								goto l17;
							}
							if ((strncmp(name, "ByteSymbol", 10)) == 0) {
								{
									printChar('#');
									printStringOf(oop);
								}
								goto l17;
							}
						}
						if ((nameLen == 9) && ((strncmp(name, "Character", 9)) == 0)) {
							{
								printChar('$');
								printChar((unsignedLongAt((oop + BaseHeaderSize) + (0U << (shiftForWord())))) >> 3);
							}
							goto l17;
						}
						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 l17;
								}
								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 l18;
							}
							theClass2 = classOop;
							while (1) {
								if (theClass2 == classLookupKey) {
									goto l19;
								}
								if (!(theClass2 != GIV(nilObj))) 
									break;
								/* begin followField:ofObject: */
								/* begin fetchPointer:ofObject: */
								objOop2 = unsignedLongAt((theClass2 + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								if (((objOop2 & (tagMask())) == 0) && (((long64At(objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
									objOop2 = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, theClass2, objOop2);
								}
								theClass2 = objOop2;
								/* end followField:ofObject: */
							};
							l19:
							;
							{
								/* begin space */
								printChar(' ');
								/* end space */
								printOopShort(unsignedLongAt((oop + BaseHeaderSize) + ((sqInt) (((usqInt) KeyIndex ) << (shiftForWord())) )));
								print(" -> ");
								printHexnp(unsignedLongAt((oop + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) )));
							}
							l18:
							;
						}
						l17:
						;
						/* 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 l15;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop23 = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l15:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop23 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l20;
							}
							if (((oop & 7) == 1)) {
								{
									printNum(oop >> 3);
									printChar('(');
									printHexnp(oop >> 3);
									printChar(')');
								}
								goto l20;
							}
							if (oop & (smallFloatTag())) {
								{
									printFloat(dbgFloatValueOf(oop));
									printChar('(');
									printHexnp(oop);
									printChar(')');
								}
								goto l20;
							}
							{
								print("unknown immediate ");
								printHexnp(oop);
							}
							goto l20;
						}
						if (!(addressCouldBeObj(oop))) {
							print((((oop & (8 - 1)) != 0)
								 ? " is misaligned"
								 : whereIs(oop)));
							goto l20;
						}
						if (((longAt(oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
							print(" is a free chunk");
							goto l20;
						}
						if (((long64At(oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
							{
								print(" is a forwarder to ");
								printHexnp(followForwarded(oop));
							}
							goto l20;
						}
						if (((((tagBits = oop & (tagMask()))) != 0)
							 ? tagBits == (smallFloatTag())
							 : ((longAt(oop)) & (classIndexMask())) == ClassFloatCompactIndex)) {
							printFloat(dbgFloatValueOf(oop));
							goto l20;
						}
						classOop = fetchClassOfNonImm(oop);
						if (!(addressCouldBeObj(classOop))) {
							print("a ??");
							goto l20;
						}
						if ((numSlotsOf(classOop)) == GIV(metaclassNumSlots)) {
							printNameOfClasscount(oop, 5);
							goto l20;
						}
						if (oop == GIV(nilObj)) {
							print("nil");
							goto l20;
						}
						if (oop == GIV(trueObj)) {
							print("true");
							goto l20;
						}
						if (oop == GIV(falseObj)) {
							print("false");
							goto l20;
						}
						nameLen = lengthOfNameOfClass(classOop);
						if (nameLen == 0) {
							print("a ??");
							goto l20;
						}
						name = nameOfClass(classOop);
						if (nameLen == 10) {
							if ((strncmp(name, "ByteString", 10)) == 0) {
								{
									printChar('\'');
									printStringOf(oop);
									printChar('\'');
								}
								goto l20;
							}
							if ((strncmp(name, "ByteSymbol", 10)) == 0) {
								{
									printChar('#');
									printStringOf(oop);
								}
								goto l20;
							}
						}
						if ((nameLen == 9) && ((strncmp(name, "Character", 9)) == 0)) {
							{
								printChar('$');
								printChar((unsignedLongAt((oop + BaseHeaderSize) + (0U << (shiftForWord())))) >> 3);
							}
							goto l20;
						}
						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 l20;
								}
								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;
							}
							theClass2 = classOop;
							while (1) {
								if (theClass2 == classLookupKey) {
									goto l22;
								}
								if (!(theClass2 != GIV(nilObj))) 
									break;
								/* begin followField:ofObject: */
								/* begin fetchPointer:ofObject: */
								objOop2 = unsignedLongAt((theClass2 + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								if (((objOop2 & (tagMask())) == 0) && (((long64At(objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
									objOop2 = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, theClass2, objOop2);
								}
								theClass2 = 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:
							;
						}
						l20:
						;
						/* 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 l12;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop23 = (((((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)) {
				{
					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 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 l24;
								}
								theClass2 = classOop;
								while (1) {
									if (theClass2 == classLookupKey) {
										goto l25;
									}
									if (!(theClass2 != GIV(nilObj))) 
										break;
									/* begin followField:ofObject: */
									/* begin fetchPointer:ofObject: */
									objOop2 = unsignedLongAt((theClass2 + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
									/* end fetchPointer:ofObject: */
									if (((objOop2 & (tagMask())) == 0) && (((long64At(objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
										objOop2 = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, theClass2, objOop2);
									}
									theClass2 = objOop2;
									/* end followField:ofObject: */
								};
								l25:
								;
								{
									/* begin space */
									printChar(' ');
									/* end space */
									printOopShort(unsignedLongAt((oop + BaseHeaderSize) + ((sqInt) (((usqInt) KeyIndex ) << (shiftForWord())) )));
									print(" -> ");
									printHexnp(unsignedLongAt((oop + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) )));
								}
								l24:
								;
							}
							l23:
							;
							/* end printOopShortInner: */
							/* begin cr */
							print("\n");
							/* end cr */
						}
					}
				}
			}
		}
		prevPrevObj2 = prevObj2;
		prevObj2 = objOop22;
		/* begin objectAfter:limit: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l16;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l16:
		;
		/* 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 l26;
							}
							if (((oop & 7) == 1)) {
								{
									printNum(oop >> 3);
									printChar('(');
									printHexnp(oop >> 3);
									printChar(')');
								}
								goto l26;
							}
							if (oop & (smallFloatTag())) {
								{
									printFloat(dbgFloatValueOf(oop));
									printChar('(');
									printHexnp(oop);
									printChar(')');
								}
								goto l26;
							}
							{
								print("unknown immediate ");
								printHexnp(oop);
							}
							goto l26;
						}
						if (!(addressCouldBeObj(oop))) {
							print((((oop & (8 - 1)) != 0)
								 ? " is misaligned"
								 : whereIs(oop)));
							goto l26;
						}
						if (((longAt(oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
							print(" is a free chunk");
							goto l26;
						}
						if (((long64At(oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
							{
								print(" is a forwarder to ");
								printHexnp(followForwarded(oop));
							}
							goto l26;
						}
						if (((((tagBits = oop & (tagMask()))) != 0)
							 ? tagBits == (smallFloatTag())
							 : ((longAt(oop)) & (classIndexMask())) == ClassFloatCompactIndex)) {
							printFloat(dbgFloatValueOf(oop));
							goto l26;
						}
						classOop = fetchClassOfNonImm(oop);
						if (!(addressCouldBeObj(classOop))) {
							print("a ??");
							goto l26;
						}
						if ((numSlotsOf(classOop)) == GIV(metaclassNumSlots)) {
							printNameOfClasscount(oop, 5);
							goto l26;
						}
						if (oop == GIV(nilObj)) {
							print("nil");
							goto l26;
						}
						if (oop == GIV(trueObj)) {
							print("true");
							goto l26;
						}
						if (oop == GIV(falseObj)) {
							print("false");
							goto l26;
						}
						nameLen = lengthOfNameOfClass(classOop);
						if (nameLen == 0) {
							print("a ??");
							goto l26;
						}
						name = nameOfClass(classOop);
						if (nameLen == 10) {
							if ((strncmp(name, "ByteString", 10)) == 0) {
								{
									printChar('\'');
									printStringOf(oop);
									printChar('\'');
								}
								goto l26;
							}
							if ((strncmp(name, "ByteSymbol", 10)) == 0) {
								{
									printChar('#');
									printStringOf(oop);
								}
								goto l26;
							}
						}
						if ((nameLen == 9) && ((strncmp(name, "Character", 9)) == 0)) {
							{
								printChar('$');
								printChar((unsignedLongAt((oop + BaseHeaderSize) + (0U << (shiftForWord())))) >> 3);
							}
							goto l26;
						}
						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 l26;
								}
								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;
							}
							theClass2 = classOop;
							while (1) {
								if (theClass2 == classLookupKey) {
									goto l28;
								}
								if (!(theClass2 != GIV(nilObj))) 
									break;
								/* begin followField:ofObject: */
								/* begin fetchPointer:ofObject: */
								objOop2 = unsignedLongAt((theClass2 + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
								/* end fetchPointer:ofObject: */
								if (((objOop2 & (tagMask())) == 0) && (((long64At(objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
									objOop2 = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, theClass2, objOop2);
								}
								theClass2 = 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:
							;
						}
						l26:
						;
						/* end printOopShortInner: */
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
			}
		}
		/* 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: */
}
/* 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 theClass2;

	/* begin printOopShortInner: */
	if (oop & (tagMask())) {
		if (oop & (characterTag())) {
			{
				printChar('$');
				printChar(((usqInt) ((usqInt) oop ) ) >> (numTagBits()));
				printChar('(');
				printHexnp(((usqInt) ((usqInt) oop ) ) >> (numTagBits()));
				printChar(')');
			}
			goto l7;
		}
		if (((oop & 7) == 1)) {
			{
				printNum(oop >> 3);
				printChar('(');
				printHexnp(oop >> 3);
				printChar(')');
			}
			goto l7;
		}
		if (oop & (smallFloatTag())) {
			{
				printFloat(dbgFloatValueOf(oop));
				printChar('(');
				printHexnp(oop);
				printChar(')');
			}
			goto l7;
		}
		{
			print("unknown immediate ");
			printHexnp(oop);
		}
		goto l7;
	}
	if (!(addressCouldBeObj(oop))) {
		print((((oop & (8 - 1)) != 0)
			 ? " is misaligned"
			 : whereIs(oop)));
		goto l7;
	}
	if (((longAt(oop)) & (classIndexMask())) == (isFreeObjectClassIndexPun())) {
		print(" is a free chunk");
		goto l7;
	}
	if (((long64At(oop)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0) {
		{
			print(" is a forwarder to ");
			printHexnp(followForwarded(oop));
		}
		goto l7;
	}
	if (((((tagBits = oop & (tagMask()))) != 0)
		 ? tagBits == (smallFloatTag())
		 : ((longAt(oop)) & (classIndexMask())) == ClassFloatCompactIndex)) {
		printFloat(dbgFloatValueOf(oop));
		goto l7;
	}
	classOop = fetchClassOfNonImm(oop);
	if (!(addressCouldBeObj(classOop))) {
		print("a ??");
		goto l7;
	}
	if ((numSlotsOf(classOop)) == GIV(metaclassNumSlots)) {
		printNameOfClasscount(oop, 5);
		goto l7;
	}
	if (oop == GIV(nilObj)) {
		print("nil");
		goto l7;
	}
	if (oop == GIV(trueObj)) {
		print("true");
		goto l7;
	}
	if (oop == GIV(falseObj)) {
		print("false");
		goto l7;
	}
	nameLen = lengthOfNameOfClass(classOop);
	if (nameLen == 0) {
		print("a ??");
		goto l7;
	}
	name = nameOfClass(classOop);
	if (nameLen == 10) {
		if ((strncmp(name, "ByteString", 10)) == 0) {
			{
				printChar('\'');
				printStringOf(oop);
				printChar('\'');
			}
			goto l7;
		}
		if ((strncmp(name, "ByteSymbol", 10)) == 0) {
			{
				printChar('#');
				printStringOf(oop);
			}
			goto l7;
		}
	}
	if ((nameLen == 9) && ((strncmp(name, "Character", 9)) == 0)) {
		{
			printChar('$');
			printChar((unsignedLongAt((oop + BaseHeaderSize) + (0U << (shiftForWord())))) >> 3);
		}
		goto l7;
	}
	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 l7;
			}
			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 l1;
		}
		theClass2 = classOop;
		while (1) {
			if (theClass2 == classLookupKey) {
				goto l2;
			}
			if (!(theClass2 != GIV(nilObj))) 
				break;
			/* begin followField:ofObject: */
			/* begin fetchPointer:ofObject: */
			objOop2 = unsignedLongAt((theClass2 + BaseHeaderSize) + ((sqInt) (((usqInt) SuperclassIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (((objOop2 & (tagMask())) == 0) && (((long64At(objOop2)) & ((classIndexMask()) - (isForwardedObjectClassIndexPun()))) == 0)) {
				objOop2 = fixFollowedFieldofObjectwithInitialValue(SuperclassIndex, theClass2, objOop2);
			}
			theClass2 = objOop2;
			/* end followField:ofObject: */
		};
		l2:
		;
		{
			/* begin space */
			printChar(' ');
			/* end space */
			printOopShort(unsignedLongAt((oop + BaseHeaderSize) + ((sqInt) (((usqInt) KeyIndex ) << (shiftForWord())) )));
			print(" -> ");
			printHexnp(unsignedLongAt((oop + BaseHeaderSize) + ((sqInt) (((usqInt) ValueIndex ) << (shiftForWord())) )));
		}
		l1:
		;
	}
	l7:
	;
	/* end printOopShortInner: */
	flush();
}
/* StackInterpreter>>#printOop: */
sqInt
printOop(sqInt oop)
{
	sqInt byte;
	int bytecodesPerLine;
	sqInt cls;
	int column;
	sqInt fmt;
	sqInt fmt1;
	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: */
		fmt1 = (((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 (fmt1 <= 5) {
			lastIndex = numSlots;
			goto l16;
		}
		if (fmt1 >= (firstByteFormat())) {
			lastIndex = (numSlots << (shiftForWord())) - (fmt1 & 7);
			goto l16;
		}
		if (fmt1 >= (firstShortFormat())) {
			lastIndex = (numSlots << ((shiftForWord()) - 1)) - (fmt1 & 3);
			goto l16;
		}
		if (fmt1 >= (firstLongFormat())) {
			lastIndex = (numSlots << ((shiftForWord()) - 2)) - (fmt1 & 1);
			goto l16;
		}
		if (fmt1 == (sixtyFourBitIndexableFormat())) {
			lastIndex = numSlots;
			goto l16;
		}
		lastIndex = 0;
		l16:
		;
		/* 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 address1;
	sqInt anOop;
	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 limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt objOop;
	sqInt objOop2;
	sqInt objOop22;
	sqInt objOop3;
	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: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop2 = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* 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 l7;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop2 = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l7:
		;
		/* 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: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop22);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop22 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop22 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* 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 (!(isFree(page))) {
			{
				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 *page;

	for (i = 0; i < GIV(numStackPages); i += 1) {
		/* begin printStackPage: */
		/* begin stackPageAt: */
		page = stackPageAtpages(i, GIV(pages));
		/* end stackPageAt: */
		printStackPageuseCount(page, -1);
		/* end printStackPage: */
		/* begin cr */
		print("\n");
		/* end cr */
	};
}
/* StackInterpreter>>#printStackPagesInUse */
void
printStackPagesInUse(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt i;
	int n;

	n = 0;
	for (i = 0; i < GIV(numStackPages); i += 1) {
		if (!(isFree(stackPageAt(i)))) {
			{
				printStackPageuseCount(stackPageAt(i), (n += 1));
				/* begin cr */
				print("\n");
				/* end cr */
			}
		}
	};
}
/* StackInterpreter>>#printStackPage:useCount: */
static void NoDbgRegParms
printStackPageuseCount(StackPage *page, sqInt n)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	void *p;
	void *p1;
	void *p2;
	void *p3;
	void *p4;
	void *p5;
	void *p6;
	void *p7;
	void *p8;

	{
		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 (isFree(page)) {
		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: */
		p1 = (page->realStackLimit);
		printHex(oopForPointer(p1));
		/* end printHexPtr: */
		print(" - sl-so: ");
		/* begin printHexPtr: */
		p2 = ((page->realStackLimit)) - ((IFrameSlots + 64) * BytesPerWord);
		printHex(oopForPointer(p2));
		/* end printHexPtr: */
		print(" - la:");
		/* begin printHexPtr: */
		p3 = (page->lastAddress);
		printHex(oopForPointer(p3));
		/* end printHexPtr: */
	}
	if (!(isFree(page))) {
		{
			/* begin cr */
			print("\n");
			/* end cr */
			/* begin tab */
			printChar('	');
			/* end tab */
			print("baseFP ");
			/* begin printHexPtr: */
			p4 = (page->baseFP);
			printHex(oopForPointer(p4));
			/* end printHexPtr: */
		}
		{
			/* begin tab */
			printChar('	');
			/* end tab */
			print("headFP ");
			/* begin printHexPtr: */
			p5 = (page->headFP);
			printHex(oopForPointer(p5));
			/* end printHexPtr: */
		}
		{
			/* begin tab */
			printChar('	');
			/* end tab */
			print("headSP ");
			/* begin printHexPtr: */
			p6 = (page->headSP);
			printHex(oopForPointer(p6));
			/* end printHexPtr: */
		}
	}
	{
		/* begin cr */
		print("\n");
		/* end cr */
		/* begin tab */
		printChar('	');
		/* end tab */
		print("prev ");
		/* begin printHexPtr: */
		p7 = ((void *) (page->prevPage) );
		printHex(oopForPointer(p7));
		/* 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: */
		p8 = ((void *) (page->nextPage) );
		printHex(oopForPointer(p8));
		/* 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 *thePage;
	char *theSP;

	for (i = 0; i < GIV(numStackPages); i += 1) {
		/* begin stackPageAt: */
		thePage = stackPageAtpages(i, GIV(pages));
		/* end stackPageAt: */
		if (!(((thePage->baseFP)) == 0)) {
			theSP = (thePage->headSP);
			theFP = (thePage->headFP);
			if (!(thePage == 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 <= ((thePage->baseAddress))) {
				if (oop == (unsignedLongAt(theSP))) {
					{
						print("FP: ");
						printHexnp(theFP);
						print(" @ ");
						printHexnp(theSP);
						/* begin cr */
						print("\n");
						/* end cr */
					}
				}
				theSP += BytesPerWord;
			};
		}
	};
}
/* 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 objOop1;
	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: */
	objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	objOop = unsignedLongAt((objOop1 + 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)))) {
			int t0;
			int t1;

			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 l6;
		}
		if (aProcess & (tagMask())) {
			goto l6;
		}
		if (!(processList >= 0x20000000000LL)) {
			goto l6;
		}
		if (aProcess >= 0x20000000000LL) {
			goto l6;
		}
		if ((aProcess >= GIV(nilObj)) && (aProcess <= GIV(trueObj))) {
			goto l6;
		}
		if (!(aProcess >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l6;
		}
		remember(getFromPermToNewSpaceRememberedSet(), processList);
		l6:
		;
		/* 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)))) {
				int t0;
				int t1;

				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 l10;
			}
			if (aProcess & (tagMask())) {
				goto l10;
			}
			if (!(processList >= 0x20000000000LL)) {
				goto l10;
			}
			if (aProcess >= 0x20000000000LL) {
				goto l10;
			}
			if ((aProcess >= GIV(nilObj)) && (aProcess <= GIV(trueObj))) {
				goto l10;
			}
			if (!(aProcess >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l10;
			}
			remember(getFromPermToNewSpaceRememberedSet(), processList);
			l10:
			;
			/* 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)))) {
				int t0;
				int t1;

				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 l4;
			}
			if (firstLink & (tagMask())) {
				goto l4;
			}
			if (!(aProcess >= 0x20000000000LL)) {
				goto l4;
			}
			if (firstLink >= 0x20000000000LL) {
				goto l4;
			}
			if ((firstLink >= GIV(nilObj)) && (firstLink <= GIV(trueObj))) {
				goto l4;
			}
			if (!(firstLink >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l4;
			}
			remember(getFromPermToNewSpaceRememberedSet(), aProcess);
			l4:
			;
			/* 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)))) {
			int t0;
			int t1;

			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 l8;
		}
		if (processList & (tagMask())) {
			goto l8;
		}
		if (!(aProcess >= 0x20000000000LL)) {
			goto l8;
		}
		if (processList >= 0x20000000000LL) {
			goto l8;
		}
		if ((processList >= GIV(nilObj)) && (processList <= GIV(trueObj))) {
			goto l8;
		}
		if (!(processList >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l8;
		}
		remember(getFromPermToNewSpaceRememberedSet(), aProcess);
		l8:
		;
		/* 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 valuePointer1;
	sqInt valuePointer2;
	sqInt valuePointer3;

	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 l5;
						}
					}
					long64Atput(newObj, ((((usqLong) numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) objFormat ) << (formatShift())) )) + classIndex);
					GIV(freeStart) += numBytes;
					clone = newObj;
					/* end allocateSmallNewSpaceSlots:format:classIndex: */
					/* end eeInstantiateSmallClassIndex:format:numSlots: */
					l5:
					;
					/* 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: */
						valuePointer1 = positive64BitIntegerFor(((usqLong) GIV(osErrorCode) ));
						assert(!(isOopForwarded(clone)));
						longAtput((clone + BaseHeaderSize) + (1U << (shiftForWord())), valuePointer1);
						/* end storePointerUnchecked:ofObject:withValue: */
						/* begin storePointerUnchecked:ofObject:withValue: */
						valuePointer2 = positiveMachineIntegerFor(GIV(exceptionPC));
						assert(!(isOopForwarded(clone)));
						longAtput((clone + BaseHeaderSize) + (2U << (shiftForWord())), valuePointer2);
						/* end storePointerUnchecked:ofObject:withValue: */
					} else {
						/* begin storePointerUnchecked:ofObject:withValue: */
						valuePointer3 = signed64BitIntegerFor(GIV(osErrorCode));
						assert(!(isOopForwarded(clone)));
						longAtput((clone + BaseHeaderSize) + (1U << (shiftForWord())), valuePointer3);
						/* end storePointerUnchecked:ofObject:withValue: */
					}
					errObj = clone;
					/* end cloneOSErrorObj:numSlots: */
				}
				valueOop = errObj;
				goto l12;
			}
		}
		valueOop = ((((usqInt) GIV(primFailCode) ) << 3) | 1);
		l12:
		;
		/* 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;
}
/*	callbackContext is an activation of 
	invokeCallback:[stack:registers:jmpbuf:]. Its sender is the VM's state 
	prior to the callback. Reestablish that state, 
	and mark calloutContext as dead. */
/* StackInterpreter>>#reestablishContextPriorToCallback: */
EXPORT(sqInt)
reestablishContextPriorToCallback(sqInt callbackContext)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt calloutContext;
	sqInt senderOop;
	sqInt senderOop2;
	char *sp;
	char *theFP;
	StackPage *thePage;
	char *theSP;
	sqInt top;
	sqInt valuePointer;
	sqInt valuePointer1;
	sqInt valuePointer11;
	sqInt valuePointer2;

	flag("obsolete");
	if (!(isLiveContext(callbackContext))) {
		return 0;
	}
	calloutContext = instVarofContext(SenderIndex, callbackContext);
	if (!(isLiveContext(calloutContext))) {
		return 0;
	}
	/* 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: */
	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 (isSingleContext(callbackContext)) {
		/* begin markContextAsDead: */
		assert(isContext(callbackContext));
		{
			/* begin storePointerUnchecked:ofObject:withValue: */
			valuePointer = GIV(nilObj);
			assert(!(isOopForwarded(callbackContext)));
			longAtput((callbackContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), valuePointer);
			/* end storePointerUnchecked:ofObject:withValue: */
			/* begin storePointerUnchecked:ofObject:withValue: */
			valuePointer1 = GIV(nilObj);
			assert(!(isOopForwarded(callbackContext)));
			longAtput((callbackContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), valuePointer1);
			/* end storePointerUnchecked:ofObject:withValue: */
		}
		/* end markContextAsDead: */
	} else {
		/* begin frameOfMarriedContext: */
		/* begin fetchPointer:ofObject: */
		senderOop = unsignedLongAt((callbackContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		{
			assert(((senderOop & 7) == 1));
			theFP = pointerForOop(senderOop - 1);
		}
		/* end frameOfMarriedContext: */
		if (GIV(framePointer) == theFP) {
			if ((unsignedLongAt(theFP + FoxSavedFP)) == 0) {
				freeStackPage(GIV(stackPage));
			} else {
				GIV(instructionPointer) = ((usqInt) (pointerForOop(unsignedLongAt(GIV(framePointer) + FoxCallerSavedIP))) );
				GIV(stackPointer) = (GIV(framePointer) + (frameStackedReceiverOffset(GIV(framePointer)))) + BytesPerWord;
				/* begin frameCallerFP: */
				GIV(framePointer) = pointerForOop(unsignedLongAt(GIV(framePointer) + FoxSavedFP));
				/* end frameCallerFP: */
				return 1;
			}
		} else {
			divorceFrameandContext(theFP, callbackContext);
			/* begin markContextAsDead: */
			assert(isContext(callbackContext));
			{
				/* begin storePointerUnchecked:ofObject:withValue: */
				valuePointer2 = GIV(nilObj);
				assert(!(isOopForwarded(callbackContext)));
				longAtput((callbackContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ), valuePointer2);
				/* end storePointerUnchecked:ofObject:withValue: */
				/* begin storePointerUnchecked:ofObject:withValue: */
				valuePointer11 = GIV(nilObj);
				assert(!(isOopForwarded(callbackContext)));
				longAtput((callbackContext + BaseHeaderSize) + ((sqInt) (((usqInt) InstructionPointerIndex ) << (shiftForWord())) ), valuePointer11);
				/* end storePointerUnchecked:ofObject:withValue: */
			}
			/* end markContextAsDead: */
		}
	}
	if (((((unsignedLongAt((calloutContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(calloutContext)))) {
		/* begin frameOfMarriedContext: */
		/* begin fetchPointer:ofObject: */
		senderOop2 = unsignedLongAt((calloutContext + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		{
			assert(((senderOop2 & 7) == 1));
			theFP = pointerForOop(senderOop2 - 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: */
		assert(thePage != GIV(stackPage));
		GIV(stackPointer) = (findSPOfon(theFP, thePage)) - BytesPerWord;
		GIV(framePointer) = theFP;
		assert(GIV(stackPointer) < GIV(framePointer));
	} else {
		thePage = makeBaseFrameFor(calloutContext);
		/* begin setStackPointersFromPage: */
		GIV(stackPointer) = (thePage->headSP);
		GIV(framePointer) = (thePage->headFP);
		/* end setStackPointersFromPage: */
	}
	/* begin popStack */
	top = unsignedLongAt(GIV(stackPointer));
	GIV(stackPointer) += BytesPerWord;
	GIV(instructionPointer) = top;
	/* end popStack */
	/* begin setStackPageAndLimit: */
	assert(thePage != 0);
	GIV(stackPage) = thePage;
	if (GIV(stackLimit) != ((char *) ((usqInt) -1 ) )) {
		GIV(stackLimit) = (GIV(stackPage)->stackLimit);
	}
	markStackPageMostRecentlyUsed(thePage);
	/* end setStackPageAndLimit: */
	return 1;
}
/*	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 valuePointer1;
	sqInt valuePointer2;

	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: */
			valuePointer1 = GIV(nilObj);
			assert(!(isOopForwarded(aList)));
			longAtput((aList + BaseHeaderSize) + ((sqInt) (((usqInt) LastLinkIndex ) << (shiftForWord())) ), valuePointer1);
			/* 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)))) {
			int t0;
			int t1;

			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 l7;
		}
		if (next & (tagMask())) {
			goto l7;
		}
		if (!(aList >= 0x20000000000LL)) {
			goto l7;
		}
		if (next >= 0x20000000000LL) {
			goto l7;
		}
		if ((next >= GIV(nilObj)) && (next <= GIV(trueObj))) {
			goto l7;
		}
		if (!(next >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l7;
		}
		remember(getFromPermToNewSpaceRememberedSet(), aList);
		l7:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((aList + BaseHeaderSize) + ((sqInt) (((usqInt) FirstLinkIndex ) << (shiftForWord())) ), next);
		/* end storePointer:ofObject:withValue: */
	}
	/* begin storePointerUnchecked:ofObject:withValue: */
	valuePointer2 = GIV(nilObj);
	assert(!(isOopForwarded(first)));
	longAtput((first + BaseHeaderSize) + ((sqInt) (((usqInt) NextLinkIndex ) << (shiftForWord())) ), valuePointer2);
	/* 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 objOop1;
	sqInt oop;
	sqInt oop2;

	/* begin memoryActiveProcess */
	/* begin fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	objOop = unsignedLongAt((objOop1 + 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)));
					header = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
					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((GIV(argumentCount) == (argumentCountOf(GIV(newMethod)))) || (isMetaPrimitiveIndex(primIndex)));
					/* 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);
	sqInt theClass;

	/* begin functionPointerFor:inClass: */
	theClass = GIV(nilObj);
	basePrimitive = ((void (*)(void)) (((primIndex > MaxPrimitiveIndex)
		 ? 0
		 : primitiveTable[primIndex])) );
	/* end functionPointerFor:inClass: */
	return (primitiveFunctionPointer == basePrimitive) || (((basePrimitive == primitiveExternalCall) && (!(((usqIntptr_t) primitiveFunctionPointer ) <= MaxQuickPrimitiveIndex))) || (((primIndex == PrimNumberDoPrimitive) || (primIndex == PrimNumberDoExternalCall)) && (GIV(metaAccessorDepth) > -2)));
}
/* StackInterpreter>>#setBreakMNUSelector: */
void
setBreakMNUSelector(char *aString)
{
	if (((breakSelector = aString)) == null) {
		breakSelectorLength = MinSmallInteger;
	} else {
		breakSelectorLength = -(strlen(aString));
	}
}
/* StackInterpreter>>#setBreakSelector: */
void
setBreakSelector(char *aString)
{
	if (((breakSelector = aString)) == null) {
		breakSelectorLength = MinSmallInteger;
	} else {
		breakSelectorLength = strlen(aString);
	}
}
/* StackInterpreter>>#setDesiredEdenBytes: */
sqInt
setDesiredEdenBytes(usqLong bytes)
{
	desiredEdenBytes = bytes;
	return 0;
}
/* 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 objOop1;

	;
	/* 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: */
		objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		/* end splObj: */
		objOop = unsignedLongAt((objOop1 + 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)))) {
			int t0;
			int t1;

			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 l7;
		}
		if (activeProc & (tagMask())) {
			goto l7;
		}
		if (!(GIV(specialObjectsOop) >= 0x20000000000LL)) {
			goto l7;
		}
		if (activeProc >= 0x20000000000LL) {
			goto l7;
		}
		if ((activeProc >= GIV(nilObj)) && (activeProc <= GIV(trueObj))) {
			goto l7;
		}
		if (!(activeProc >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l7;
		}
		remember(getFromPermToNewSpaceRememberedSet(), GIV(specialObjectsOop));
		l7:
		;
		/* 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 (!(isFree(page))) {
			{
				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: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;
}
/*	Repaint the portion of the Smalltalk screen bounded by the affected 
	rectangle. Used to synchronize the screen after a Bitblt to the Smalltalk 
	Display object. */
/* StackInterpreter>>#showDisplayBits:Left:Top:Right:Bottom: */
void
showDisplayBitsLeftTopRightBottom(sqInt aForm, sqInt l, sqInt t, sqInt r, sqInt b)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt bottom;
	sqInt left;
	sqInt right;
	sqInt surfaceHandle;
	sqInt top;

	/* begin updateDisplayLeft:Top:Right:Bottom: */
	left = ((l < 0) ? 0 : l);
	right = ((r < displayWidth) ? r : displayWidth);
	top = ((t < 0) ? 0 : t);
	bottom = ((b < displayHeight) ? b : displayHeight);
	if (!((left <= right) && (top <= bottom))) {
		goto l1;
	}
	if ((((((sqInt) displayBits )) & 7) == 1)) {
		surfaceHandle = ((sqInt) displayBits ) >> 3;
		if (showSurfaceFn == 0) {
			showSurfaceFn = ioLoadFunctionFrom("ioShowSurface", "SurfacePlugin");
			if (showSurfaceFn == 0) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrNotFound;
				goto l1;
				/* end primitiveFailFor: */
			}
		}
		showSurfaceFn(surfaceHandle, left, top, right - left, bottom - top);
	} else {
		assert(isNonImmediate(((sqInt) displayBits )));
		ioShowDisplay(((sqInt) displayBits ), displayWidth, displayHeight, displayDepth, left, right, top, bottom);
	}
	l1:
	;
	/* end updateDisplayLeft:Top:Right:Bottom: */
}
/*	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 l2;
		}
	}
	long64Atput(newObj, ((((usqLong) numSlots ) << (numSlotsFullShift())) + ((sqInt) (((usqInt) objFormat ) << (formatShift())) )) + largeClass);
	GIV(freeStart) += numBytes;
	newLargeInteger = newObj;
	/* end allocateSmallNewSpaceSlots:format:classIndex: */
	l2:
	;
	/* 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)
{
	return (((256 * BytesPerWord) < (((stackPageByteSize()) - ((IFrameSlots + 64) * BytesPerWord)) - (osCogStackPageHeadroom()))) ? 256 * BytesPerWord : ((stackPageByteSize()) - ((IFrameSlots + 64) * BytesPerWord)) - (osCogStackPageHeadroom()));
}
/*	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)
{
	int largeSize;
	sqInt pageBytes;
	int smallSize;

	pageBytes = ((256 * BytesPerWord) + ((IFrameSlots + 64) * BytesPerWord)) + (osCogStackPageHeadroom());
	if ((pageBytes & (pageBytes - 1)) == 0) {
		return pageBytes;
	}
	largeSize = 1ULL << (highBit(pageBytes));
	smallSize = 1ULL << ((highBit(pageBytes)) - 1);
	assert((largeSize > pageBytes) && (pageBytes > smallSize));
	return (((pageBytes - smallSize) <= (smallSize / 8))
		 ? smallSize
		 : largeSize);
}
/*	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 l2;
	}
	l2:
	;
	/* 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;
	usqLong fmt;
	sqLong hdr;
	unsigned int integerValue;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt reasonCode;
	sqInt sp;
	sqInt sp2;
	sqInt stSize;
	sqInt totalLength;

	/* begin baseHeader: */
	hdr = long64At(array);
	/* end baseHeader: */
	fmt = (((unsigned sqLong) hdr ) >> (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())) && ((hdr & (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;
	usqLong fmt;
	sqLong hdr;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt reasonCode;
	sqInt signedValueToStore;
	sqInt stSize;
	sqInt totalLength;
	usqLong unsigned64BitValueToStore;
	unsigned int unsignedValueToStore;

	/* begin baseHeader: */
	hdr = long64At(array);
	/* end baseHeader: */
	if ((hdr & (classIndexMask())) == ClassMethodContextCompactIndex) {
		/* begin primitiveFailFor: */
		return (GIV(primFailCode) = PrimErrBadReceiver);
		/* end primitiveFailFor: */
	}
	fmt = (((unsigned sqLong) hdr ) >> (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)))) {
				int t0;
				int t1;

				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 l9;
			}
			if (value & (tagMask())) {
				goto l9;
			}
			if (!(array >= 0x20000000000LL)) {
				goto l9;
			}
			if (value >= 0x20000000000LL) {
				goto l9;
			}
			if ((value >= GIV(nilObj)) && (value <= GIV(trueObj))) {
				goto l9;
			}
			if (!(value >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l9;
			}
			remember(getFromPermToNewSpaceRememberedSet(), array);
			l9:
			;
			/* 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 l4;
		/* 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 l4;
	}
	marryFrameSP(callerFP, (assert(!(isBaseFrame(theFP))), (theFP + (frameStackedReceiverOffset(theFP))) + BytesPerWord));
	/* end ensureFrameIsMarried:SP: */
	l4:
	;
	/* 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 l1;
	}
	divorceFramesIn(lruOrFree);
	newPage = lruOrFree;
	l1:
	;
	/* 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 l3;
	}
	if (fmt >= (firstByteFormat())) {
		totalLength = (numSlots << (shiftForWord())) - (fmt & 7);
		goto l3;
	}
	if (fmt >= (firstShortFormat())) {
		totalLength = (numSlots << ((shiftForWord()) - 1)) - (fmt & 3);
		goto l3;
	}
	if (fmt >= (firstLongFormat())) {
		totalLength = (numSlots << ((shiftForWord()) - 2)) - (fmt & 1);
		goto l3;
	}
	if (fmt == (sixtyFourBitIndexableFormat())) {
		totalLength = numSlots;
		goto l3;
	}
	totalLength = 0;
	l3:
	;
	/* end lengthOf:format: */
	/* begin fixedFieldsOf:format:length: */
	if ((fmt >= (sixtyFourBitIndexableFormat())) || (fmt == 2)) {
		fixedFields = 0;
		goto l4;
	}
	if (fmt < 2) {
		fixedFields = totalLength;
		goto l4;
	}
	class = fetchClassOfNonImm(oop);
	/* begin fixedFieldsOfClassFormat: */
	classFormat = (unsignedLongAt((class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	fixedFields = classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	/* end fixedFieldsOfClassFormat: */
	l4:
	;
	/* 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 objOop1;

	/* begin memoryActiveProcess */
	/* begin fetchPointer:ofObject: */
	/* begin fetchPointer:ofObject: */
	/* begin splObj: */
	/* begin fetchPointer:ofObject: */
	objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	objOop = unsignedLongAt((objOop1 + 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)))) {
			int t0;
			int t1;

			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 l4;
		}
		if (ctxt & (tagMask())) {
			goto l4;
		}
		if (!(proc >= 0x20000000000LL)) {
			goto l4;
		}
		if (ctxt >= 0x20000000000LL) {
			goto l4;
		}
		if ((ctxt >= GIV(nilObj)) && (ctxt <= GIV(trueObj))) {
			goto l4;
		}
		if (!(ctxt >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l4;
		}
		remember(getFromPermToNewSpaceRememberedSet(), proc);
		l4:
		;
		/* 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));
	header2 = unsignedLongAt((methodPointer + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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 *theSP1;
	sqInt top;
	sqInt valuePointer;
	sqInt valuePointer1;

	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: */
	theSP1 = GIV(stackPointer);
	assert(theSP1 < GIV(framePointer));
	assert((theSP1 < ((GIV(stackPage)->baseAddress))) && (theSP1 > (((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 = theSP1);
	}
	/* 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 l5;
	}
	activeContext = marryFrameSP(theFP, theSP);
	l5:
	;
	/* end ensureFrameIsMarried:SP: */
	/* begin storePointer:ofObject:withValue: */
	assert(!(isForwarded(oldProc)));
	if (((oldProc & (tagMask())) == 0) && ((oldProc & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		int t0;
		int t1;

		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 l6;
	}
	if (activeContext & (tagMask())) {
		goto l6;
	}
	if (!(oldProc >= 0x20000000000LL)) {
		goto l6;
	}
	if (activeContext >= 0x20000000000LL) {
		goto l6;
	}
	if ((activeContext >= GIV(nilObj)) && (activeContext <= GIV(trueObj))) {
		goto l6;
	}
	if (!(activeContext >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l6;
	}
	remember(getFromPermToNewSpaceRememberedSet(), oldProc);
	l6:
	;
	/* 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)))) {
		int t0;
		int t1;

		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 l8;
	}
	if (newProc & (tagMask())) {
		goto l8;
	}
	if (!(sched >= 0x20000000000LL)) {
		goto l8;
	}
	if (newProc >= 0x20000000000LL) {
		goto l8;
	}
	if ((newProc >= GIV(nilObj)) && (newProc <= GIV(trueObj))) {
		goto l8;
	}
	if (!(newProc >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l8;
	}
	remember(getFromPermToNewSpaceRememberedSet(), sched);
	l8:
	;
	/* 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: */
	valuePointer1 = GIV(nilObj);
	assert(!(isOopForwarded(newProc)));
	longAtput((newProc + BaseHeaderSize) + ((sqInt) (((usqInt) SuspendedContextIndex ) << (shiftForWord())) ), valuePointer1);
	/* 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 l17;
			}
			divorceFramesIn(lruOrFree);
			newPage = lruOrFree;
			l17:
			;
			/* 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 l12;
			}
			(((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());
			l12:
			;
			/* 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)))) {
			int t0;
			int t1;

			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 l1;
		}
		if (aValue & (tagMask())) {
			goto l1;
		}
		if (!(aMethodOop >= 0x20000000000LL)) {
			goto l1;
		}
		if (aValue >= 0x20000000000LL) {
			goto l1;
		}
		if ((aValue >= GIV(nilObj)) && (aValue <= GIV(trueObj))) {
			goto l1;
		}
		if (!(aValue >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l1;
		}
		remember(getFromPermToNewSpaceRememberedSet(), aMethodOop);
		l1:
		;
		/* 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)))) {
		int t0;
		int t1;

		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 l5;
	}
	if (followed & (tagMask())) {
		goto l5;
	}
	if (!(GIV(method) >= 0x20000000000LL)) {
		goto l5;
	}
	if (followed >= 0x20000000000LL) {
		goto l5;
	}
	if ((followed >= GIV(nilObj)) && (followed <= GIV(trueObj))) {
		goto l5;
	}
	if (!(followed >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l5;
	}
	remember(getFromPermToNewSpaceRememberedSet(), GIV(method));
	l5:
	;
	/* 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 valuePointer1;

	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)))) {
			int t0;
			int t1;

			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 l3;
		}
		if (valuePointer & (tagMask())) {
			goto l3;
		}
		if (!(theContext >= 0x20000000000LL)) {
			goto l3;
		}
		if (valuePointer >= 0x20000000000LL) {
			goto l3;
		}
		if ((valuePointer >= GIV(nilObj)) && (valuePointer <= GIV(trueObj))) {
			goto l3;
		}
		if (!(valuePointer >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l3;
		}
		remember(getFromPermToNewSpaceRememberedSet(), theContext);
		l3:
		;
		/* 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: */
		valuePointer1 = longAt(pointer);
		assert(!(isForwarded(theContext)));
		if (((theContext & (tagMask())) == 0) && ((theContext & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
			int t0;
			int t1;

			if (((valuePointer1 & (tagMask())) == 0) && (((valuePointer1 & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (valuePointer1 >= ((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 (valuePointer1 & (tagMask())) {
			goto l5;
		}
		if (!(theContext >= 0x20000000000LL)) {
			goto l5;
		}
		if (valuePointer1 >= 0x20000000000LL) {
			goto l5;
		}
		if ((valuePointer1 >= GIV(nilObj)) && (valuePointer1 <= GIV(trueObj))) {
			goto l5;
		}
		if (!(valuePointer1 >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l5;
		}
		remember(getFromPermToNewSpaceRememberedSet(), theContext);
		l5:
		;
		/* end possiblePermObjectStoreInto:value: */
		unsignedLongAtput((theContext + BaseHeaderSize) + ((sqInt) (((usqInt) (ReceiverIndex + tempIndex) ) << (shiftForWord())) ), valuePointer1);
		/* 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;
	StackPage *aPage;
	sqInt i;

	for (i = 0; i < GIV(numStackPages); i += 1) {
		/* begin stackPageAt: */
		aPage = stackPageAtpages(i, GIV(pages));
		/* end stackPageAt: */
		if (!(isFree(aPage))) {
			if (!(validStackPageBaseFrame(aPage))) {
				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 objOop1;
	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: */
	objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	objOop = unsignedLongAt((objOop1 + 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 valuePointer1;
	sqInt valuePointer2;
	sqInt valuePointer3;

	/* 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: */
			valuePointer1 = unsignedLongAt((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) i ) << (shiftForWord())) ));
			assert(!(isOopForwarded(cloned)));
			longAtput((cloned + BaseHeaderSize) + ((sqInt) (((usqInt) i ) << (shiftForWord())) ), valuePointer1);
			/* 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)) ))) {
					valuePointer2 = ((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 {
					valuePointer2 = ((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())) ), valuePointer2);
				/* end storePointerUnchecked:ofObject:withValue: */
			};
		} else {
			sp = (fetchStackPointerOf(aContext)) - 1;
			for (i = 0; i <= sp; i += 1) {
				/* begin storePointerUnchecked:ofObject:withValue: */
				valuePointer3 = unsignedLongAt((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) (i + CtxtTempFrameStart) ) << (shiftForWord())) ));
				assert(!(isOopForwarded(cloned)));
				longAtput((cloned + BaseHeaderSize) + ((sqInt) (((usqInt) (i + CtxtTempFrameStart) ) << (shiftForWord())) ), valuePointer3);
				/* 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 anOop1;
	sqInt anOop2;
	sqInt argHolder;
	ffi_type * argType;
	usqInt argumentSize;
	sqInt argumentsArrayOop;
	sqInt aSize;
	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 l5;
	}
	/* begin readAddress: */
	anOop1 = unsignedLongAt((anOop + BaseHeaderSize) + (0U << (shiftForWord())));
	if (!(isKindOfClass(anOop1, unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ))))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		externalFunction = null;
		goto l5;
	}
	/* begin fetchPointer:ofObject: */
	externalFunction = unsignedLongAt((anOop1 + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	/* end readAddress: */
	l5:
	;
	/* 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));
	anOop2 = unsignedLongAt((objOop + BaseHeaderSize) + (1U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	cif = ((ffi_cif *) (getHandler(anOop2)) );
	/* 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 l3;
	}
	{
		parameters = alloca((sizeof(void*)) * argumentSize);
	}
	l3:
	;
	/* 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 anOop1;
	sqInt anOop2;
	sqInt aPointer;
	sqInt aPtr;
	sqInt argHolder;
	ffi_type * argType;
	usqInt argumentSize;
	sqInt argumentsArrayOop;
	sqInt aSize;
	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 l8;
	}
	/* begin readAddress: */
	anOop1 = unsignedLongAt((anOop + BaseHeaderSize) + (0U << (shiftForWord())));
	if (!(isKindOfClass(anOop1, unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassExternalAddress ) << (shiftForWord())) ))))) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		externalFunction = null;
		goto l8;
	}
	/* begin fetchPointer:ofObject: */
	externalFunction = unsignedLongAt((anOop1 + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	/* end readAddress: */
	l8:
	;
	/* 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));
	anOop2 = unsignedLongAt((objOop + BaseHeaderSize) + (1U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	cif = ((ffi_cif *) (getHandler(anOop2)) );
	/* 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 l6;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		semaphoreIndex = 0;
		goto l6;
	}
	/* end checkedIntegerValueOf: */
	l6:
	;
	/* 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 l4;
	}
	{
		parameters = calloc(argumentSize, sizeof(void*));
	}
	l4:
	;
	/* 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;
	Worker *worker;

	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 l5;
	}
	/* begin fetchPointer:ofObject: */
	taskAddress = unsignedLongAt((anOop + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	l5:
	;
	/* end readAddress: */
	/* 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 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 *//*	Arrange to answer naked frame pointers for unmarried 
	senders to avoid reifying contexts in the search. */
/* StackInterpreterPrimitives>>#fieldOrSenderFP:ofContext: */
static sqInt NoDbgRegParms
fieldOrSenderFPofContext(sqInt index, sqInt contextObj)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt senderOop;
	char *spouseFP;
	sqInt tempIndex;

	tempIndex = index - CtxtTempFrameStart;
	if (!(((((unsignedLongAt((contextObj + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ))) & 7) == 1)) && (!(isWidowedContext(contextObj))))) {
		return ((tempIndex >= (fetchStackPointerOf(contextObj)))
			 ? (/* begin nilObject */ GIV(nilObj) /* end nilObject */)
			 : (/* begin fetchPointer:ofObject: */ unsignedLongAt((contextObj + BaseHeaderSize) + ((sqInt) (((usqInt) index ) << (shiftForWord())) )) /* end fetchPointer:ofObject: */));
	}
	/* begin frameOfMarriedContext: */
	/* begin fetchPointer:ofObject: */
	senderOop = unsignedLongAt((contextObj + BaseHeaderSize) + ((sqInt) (((usqInt) SenderIndex ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	{
		assert(((senderOop & 7) == 1));
		spouseFP = pointerForOop(senderOop - 1);
	}
	/* end frameOfMarriedContext: */
	if (tempIndex >= (stackPointerIndexForFrame(spouseFP))) {
		/* begin nilObject */
		return GIV(nilObj);
		/* end nilObject */
	}
	return fieldofFrame(index, spouseFP);
}
/*	Arrange to answer naked frame pointers for unmarried 
	senders to avoid reifying contexts in the search. */
/* StackInterpreterPrimitives>>#field:ofFrame: */
static sqInt NoDbgRegParms
fieldofFrame(sqInt index, char *theFP)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt callerContextOrNil;
	char *callerFP;
	sqInt frameNumArgs;
	sqInt frameNumArgs2;
	sqInt numArgs;
	StackPage *thePage;

	switch (index) {
		case SenderIndex:
		{
			/* begin frameCallerFP: */
			callerFP = pointerForOop(unsignedLongAt(theFP + FoxSavedFP));
			/* end frameCallerFP: */
			return ((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))), callerContextOrNil /* end frameCallerContext: */)
				 : ((((isMachineCodeIP(((usqInt) (unsignedLongAt(callerFP + FoxMethod)) )))
					 ? ((unsignedLongAt(callerFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
					 : (byteAt((callerFP + FoxIFrameFlags) + 2)) != 0))
					 ? (assert(checkIsStillMarriedContextcurrentFP(frameContext(callerFP), null)), /* begin frameContext: */ unsignedLongAt(callerFP + FoxThisContext) /* end frameContext: */)
					 : ((sqInt) callerFP )));
		}
		case StackPointerIndex:
		case InstructionPointerIndex:
		{
			return ConstZero;
		}
		case MethodIndex:
		{
			return ((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
				 ? ((mframeHomeMethod(theFP))->methodObject)
				 : unsignedLongAt(theFP + FoxMethod));
		}
		case ClosureIndex:
		{
			return ((((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
				 ? ((unsignedLongAt(theFP + FoxMethod)) & MFMethodFlagIsBlockFlag) != 0
				 : (byteAt((theFP + FoxIFrameFlags) + 3)) != 0))
				 ? (/* begin frameStackedReceiver:numArgs: */ (numArgs = ((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
					 ? ((((CogMethod *) ((unsignedLongAt(theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
					 : byteAt((theFP + FoxIFrameFlags) + 1))), unsignedLongAt(theFP + ((FoxCallerSavedIP + BytesPerWord) + ((sqInt) (((usqInt) numArgs ) << (shiftForWord())) ))) /* end frameStackedReceiver:numArgs: */)
				 : (/* begin nilObject */ GIV(nilObj) /* end nilObject */));
		}
		case ReceiverIndex:
		{
			return ((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
				 ? longAt(theFP + FoxMFReceiver)
				 : unsignedLongAt(theFP + FoxIFReceiver));
		}
		default:
		{
			assert(((index - CtxtTempFrameStart) >= 0) && ((index - CtxtTempFrameStart) <= (stackPointerIndexForFrame(theFP))));
			return ((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
				 ? (((index - CtxtTempFrameStart) < ((frameNumArgs = ((((CogMethod *) ((unsignedLongAt(theFP + FoxMethod)) & MFMethodMask) ))->cmNumArgs))))
					 ? unsignedLongAt((theFP + FoxCallerSavedIP) + ((frameNumArgs - (index - CtxtTempFrameStart)) * BytesPerWord))
					 : unsignedLongAt(((((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
						 ? theFP + FoxMFReceiver
						 : theFP + FoxIFReceiver)) - BytesPerWord) + ((frameNumArgs - (index - CtxtTempFrameStart)) * BytesPerWord)))
				 : (((index - CtxtTempFrameStart) < ((frameNumArgs2 = byteAt((theFP + FoxIFrameFlags) + 1))))
					 ? unsignedLongAt((theFP + FoxCallerSavedIP) + ((frameNumArgs2 - (index - CtxtTempFrameStart)) * BytesPerWord))
					 : unsignedLongAt(((theFP + FoxIFReceiver) - BytesPerWord) + ((frameNumArgs2 - (index - CtxtTempFrameStart)) * BytesPerWord))));
		}
	}
}
/* StackInterpreterPrimitives>>#getHandler: */
void *
getHandler(sqInt anOop)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt anOop1;

	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: */
	anOop1 = unsignedLongAt((anOop + BaseHeaderSize) + (0U << (shiftForWord())));
	if (!(isKindOfClass(anOop1, 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((anOop1 + 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 classObj1;
	double f;
	double f1;
	float * floatPtr;
	double * floatPtr2;
	sqInt integerVal;
	sqInt integerVal1;
	sqInt integerVal2;
	sqInt integerVal3;
	sqInt integerValue;
	unsigned int integerValue1;
	sqInt nElements;
	sqInt oop;
	sqInt oop1;
	sqInt oop2;
	sqInt oop3;
	sqInt oop4;
	sqInt oop5;
	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: */
			integerVal1 = ((sqInt) (readSINT16AtPointer(returnHolder)) );
			unsignedLongAtput((sp10 = GIV(stackPointer) + ((argumentsAndReceiverCount - 1) * BytesPerWord)), ((((usqInt) integerVal1 ) << 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 l3;
			}
			l3:
			;
			/* end signed32BitIntegerFor: */
			unsignedLongAtput((sp = GIV(stackPointer) + ((argumentsAndReceiverCount - 1) * BytesPerWord)), oop);
			GIV(stackPointer) = sp;
			/* end pop:thenPush: */
		}
		break;
		case FFI_TYPE_SINT64:
		{
			/* begin pop:thenPush: */
			oop1 = signed64BitIntegerFor(readSINT64AtPointer(returnHolder));
			unsignedLongAtput((sp2 = GIV(stackPointer) + ((argumentsAndReceiverCount - 1) * BytesPerWord)), oop1);
			GIV(stackPointer) = sp2;
			/* end pop:thenPush: */
		}
		break;
		case FFI_TYPE_UINT8:
		{
			/* begin pop:thenPushInteger: */
			integerVal2 = ((sqInt) (readUINT8AtPointer(returnHolder)) );
			unsignedLongAtput((sp11 = GIV(stackPointer) + ((argumentsAndReceiverCount - 1) * BytesPerWord)), ((((usqInt) integerVal2 ) << 3) | 1));
			GIV(stackPointer) = sp11;
			/* end pop:thenPushInteger: */
		}
		break;
		case FFI_TYPE_UINT16:
		{
			/* begin pop:thenPushInteger: */
			integerVal3 = ((sqInt) (readUINT16AtPointer(returnHolder)) );
			unsignedLongAtput((sp12 = GIV(stackPointer) + ((argumentsAndReceiverCount - 1) * BytesPerWord)), ((((usqInt) integerVal3 ) << 3) | 1));
			GIV(stackPointer) = sp12;
			/* end pop:thenPushInteger: */
		}
		break;
		case FFI_TYPE_UINT32:
		{
			/* begin pop:thenPush: */
			/* begin positive32BitIntegerFor: */
			integerValue1 = ((unsigned int) (readUINT32AtPointer(returnHolder)) );
			{
				oop2 = (((((usqInt) integerValue1 ) & 0xFFFFFFFFU) << 3) | 1);
				goto l4;
			}
			l4:
			;
			/* end positive32BitIntegerFor: */
			unsignedLongAtput((sp3 = GIV(stackPointer) + ((argumentsAndReceiverCount - 1) * BytesPerWord)), oop2);
			GIV(stackPointer) = sp3;
			/* end pop:thenPush: */
		}
		break;
		case FFI_TYPE_UINT64:
		{
			/* begin pop:thenPush: */
			oop3 = positive64BitIntegerFor(readUINT64AtPointer(returnHolder));
			unsignedLongAtput((sp4 = GIV(stackPointer) + ((argumentsAndReceiverCount - 1) * BytesPerWord)), oop3);
			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 );
			oop4 = oop7;
			/* end newExternalAddressWithValue: */
			unsignedLongAtput((sp5 = GIV(stackPointer) + ((argumentsAndReceiverCount - 1) * BytesPerWord)), oop4);
			GIV(stackPointer) = sp5;
			/* end pop:thenPush: */
		}
		break;
		case FFI_TYPE_STRUCT:
		{
			/* begin pop:thenPush: */
			/* begin newByteArrayWithStructContent:size: */
			sizeToCopy = (ffiType->size);
			/* begin instantiateClass:indexableSize: */
			classObj1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) ClassByteArray ) << (shiftForWord())) ));
			oop8 = instantiateClassindexableSizeisPinnedisOldSpace(classObj1, sizeToCopy, 0, 0);
			/* end instantiateClass:indexableSize: */
			targetPointer = firstIndexableField(oop8);
			memcpy(targetPointer, returnHolder, sizeToCopy);
			oop5 = oop8;
			/* end newByteArrayWithStructContent:size: */
			unsignedLongAtput((sp6 = GIV(stackPointer) + ((argumentsAndReceiverCount - 1) * BytesPerWord)), oop5);
			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 );
			f1 = floatPtr2[0];
			/* end readFloat64AtPointer: */
			unsignedLongAtput((sp8 = GIV(stackPointer) + ((argumentsAndReceiverCount - 1) * BytesPerWord)), floatObjectOf(f1));
			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 l10;
				}
				/* begin fetchPointer:ofObject: */
				address = unsignedLongAt((oop2 + BaseHeaderSize) + (0U << (shiftForWord())));
				/* end fetchPointer:ofObject: */
				l10:
				;
				/* end readAddress: */
				if (address == 0) {
					/* begin primitiveFailFor: */
					GIV(primFailCode) = PrimErrBadArgument;
					goto l12;
					/* 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 l12;
					/* end primitiveFailFor: */
				}
				address = firstIndexableField(oop2);
			}
			srcPtr = ((void *) address );
			memcpy(argHolder, srcPtr, argTypeSize);
			l12:
			;
			/* 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 l2;
				/* end primitiveFailFor: */
			}
			if (value < INT8_MIN) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l2;
				/* end primitiveFailFor: */
			}
			intHolder = ((int8_t *) argHolder );
			intHolder[0] = fetchIntegerofObject(i, argumentsArrayOop);
			l2:
			;
			/* 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 l8;
				/* end primitiveFailFor: */
			}
			if (value5 > UINT8_MAX) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l8;
				/* end primitiveFailFor: */
			}
			intHolder5 = ((uint8_t *) argHolder );
			intHolder5[0] = value5;
			l8:
			;
			/* 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 l3;
				/* end primitiveFailFor: */
			}
			if (value2 < INT16_MIN) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l3;
				/* end primitiveFailFor: */
			}
			intHolder2 = ((int16_t *) argHolder );
			intHolder2[0] = value2;
			l3:
			;
			/* 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 l4;
				/* end primitiveFailFor: */
			}
			if (value3 > UINT16_MAX) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l4;
				/* end primitiveFailFor: */
			}
			intHolder3 = ((uint16_t *) argHolder );
			intHolder3[0] = value3;
			l4:
			;
			/* 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 l13;
				/* end primitiveFailFor: */
			}
			intHolder6 = ((int32_t *) argHolder );
			intHolder6[0] = value6;
			l13:
			;
			/* 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 l14;
				/* end primitiveFailFor: */
			}
			intHolder7 = ((uint32_t *) argHolder );
			intHolder7[0] = value7;
			l14:
			;
			/* 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 l5;
			}
			intHolder4 = ((int64_t *) argHolder );
			intHolder4[0] = value4;
			l5:
			;
			/* 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 l15;
			}
			intHolder8 = ((uint64_t *) argHolder );
			intHolder8[0] = value8;
			l15:
			;
			/* 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 l4;
	}
	/* 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 l4;
	}
	if (fmt <= (sixtyFourBitIndexableFormat())) {
		rcvrSize = numBytes;
		goto l4;
	}
	if (fmt >= (firstShortFormat())) {
		rcvrSize = numBytes - ((sqInt) (((usqInt) (fmt & 3) ) << 1) );
		goto l4;
	}
	rcvrSize = numBytes - ((sqInt) (((usqInt) (fmt & 1) ) << 2) );
	/* end numBytesOf: */
	l4:
	;
	/* 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;

	result = 0;
	value = 0;
	/* begin loadFloatOrIntFrom: */
	if (((tagBits = floatOrInt & (tagMask()))) != 0) {
		int t1;
		int t2;

		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;
		}
	}
	/* 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 classFormat1;
	sqInt fixedFields;
	sqInt fixedFields2;
	usqLong fmt;
	usqLong fmt2;
	sqInt frameNumArgs;
	sqInt frameNumArgs2;
	sqLong hdr;
	sqLong hdr2;
	sqInt index;
	unsigned int integerValue;
	unsigned int integerValue1;
	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: */
		/* begin baseHeader: */
		hdr2 = long64At(aContext);
		/* end baseHeader: */
		fmt2 = (((unsigned sqLong) hdr2 ) >> (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 l15;
		}
		if (fmt2 >= (firstByteFormat())) {
			totalLength2 = (numSlots3 << (shiftForWord())) - (fmt2 & 7);
			goto l15;
		}
		if (fmt2 >= (firstShortFormat())) {
			totalLength2 = (numSlots3 << ((shiftForWord()) - 1)) - (fmt2 & 3);
			goto l15;
		}
		if (fmt2 >= (firstLongFormat())) {
			totalLength2 = (numSlots3 << ((shiftForWord()) - 2)) - (fmt2 & 1);
			goto l15;
		}
		if (fmt2 == (sixtyFourBitIndexableFormat())) {
			totalLength2 = numSlots3;
			goto l15;
		}
		totalLength2 = 0;
		l15:
		;
		/* end lengthOf:format: */
		/* begin fixedFieldsOf:format:length: */
		if ((fmt2 >= (sixtyFourBitIndexableFormat())) || (fmt2 == 2)) {
			fixedFields2 = 0;
			goto l18;
		}
		if (fmt2 < 2) {
			fixedFields2 = totalLength2;
			goto l18;
		}
		class2 = fetchClassOfNonImm(aContext);
		/* begin fixedFieldsOfClassFormat: */
		classFormat1 = (unsignedLongAt((class2 + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
		fixedFields2 = classFormat1 & ((1U << (fixedFieldsFieldWidth())) - 1);
		/* end fixedFieldsOfClassFormat: */
		l18:
		;
		/* end fixedFieldsOf:format:length: */
		if ((fmt2 == (indexablePointersFormat())) && ((hdr2 & (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 l17;
			}
			/* begin fetchStackPointerOf: */
			/* begin fetchPointer:ofObject: */
			sp22 = unsignedLongAt((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
			/* end fetchPointer:ofObject: */
			if (!(((sp22 & 7) == 1))) {
				stSize2 = 0;
				goto l17;
			}
			assert((ReceiverIndex + (sp22 >> 3)) < (lengthOf(aContext)));
			stSize2 = sp22 >> 3;
			/* end fetchStackPointerOf: */
			l17:
			;
			/* 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: */
			integerValue1 = long32At((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((index + fixedFields2) - 1) ) << 2) ));
			{
				value = (((((usqInt) integerValue1 ) & 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 l10;
		}
		if (fmt >= (firstByteFormat())) {
			totalLength = (numSlots << (shiftForWord())) - (fmt & 7);
			goto l10;
		}
		if (fmt >= (firstShortFormat())) {
			totalLength = (numSlots << ((shiftForWord()) - 1)) - (fmt & 3);
			goto l10;
		}
		if (fmt >= (firstLongFormat())) {
			totalLength = (numSlots << ((shiftForWord()) - 2)) - (fmt & 1);
			goto l10;
		}
		if (fmt == (sixtyFourBitIndexableFormat())) {
			totalLength = numSlots;
			goto l10;
		}
		totalLength = 0;
		l10:
		;
		/* end lengthOf:format: */
		/* begin fixedFieldsOf:format:length: */
		if ((fmt >= (sixtyFourBitIndexableFormat())) || (fmt == 2)) {
			fixedFields = 0;
			goto l11;
		}
		if (fmt < 2) {
			fixedFields = totalLength;
			goto l11;
		}
		class = fetchClassOfNonImm(aContext);
		/* begin fixedFieldsOfClassFormat: */
		classFormat = (unsignedLongAt((class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
		fixedFields = classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
		/* end fixedFieldsOfClassFormat: */
		l11:
		;
		/* 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 l13;
		}
		assert((ReceiverIndex + (sp4 >> 3)) < (lengthOf(aContext)));
		stSize = sp4 >> 3;
		l13:
		;
		/* 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 l14;
			/* end fetchPointer:ofObject: */
		}
		if (fmt >= (firstByteFormat())) {
			value = ((((usqInt) (byteAt((aContext + BaseHeaderSize) + ((index + fixedFields) - 1))) ) << 3) | 1);
			goto l14;
		}
		if (fmt >= (firstShortFormat())) {
			value = ((((usqInt) ((unsigned short) (shortAt((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((index + fixedFields) - 1) ) << 1) ))) ) ) << 3) | 1);
			goto l14;
		}
		if (fmt == (sixtyFourBitIndexableFormat())) {
			value = positive64BitIntegerFor(long64At((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((index + fixedFields) - 1) ) << 3) )));
			goto l14;
		}
		/* begin positive32BitIntegerFor: */
		integerValue = long32At((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((index + fixedFields) - 1) ) << 2) ));
		{
			value = (((((usqInt) integerValue ) & 0xFFFFFFFFU) << 3) | 1);
			goto l14;
		}
		/* end positive32BitIntegerFor: */
		l14:
		;
		/* 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 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: */
		sp3 = unsignedLongAt((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (!(((sp3 & 7) == 1))) {
			stSize = 0;
			goto l14;
		}
		assert((ReceiverIndex + (sp3 >> 3)) < (lengthOf(aContext)));
		stSize = sp3 >> 3;
		l14:
		;
		/* 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)))) {
				int t0;
				int t1;

				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 l17;
			}
			if (value & (tagMask())) {
				goto l17;
			}
			if (!(aContext >= 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(), aContext);
			l17:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((index + fixedFields) - 1) ) << (shiftForWord())) ), value);
			/* end storePointer:ofObject:withValue: */
			goto l21;
		}
		if (fmt >= (firstByteFormat())) {
			if (!(((value & 7) == 1))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l21;
			}
			signedValueToStore = value >> 3;
			if (!((signedValueToStore >= 0) && (signedValueToStore <= 0xFF))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l21;
			}
			/* begin storeByte:ofObject:withValue: */
			byteAtput((aContext + BaseHeaderSize) + ((index + fixedFields) - 1), signedValueToStore);
			/* end storeByte:ofObject:withValue: */
			goto l21;
		}
		if (fmt >= (firstShortFormat())) {
			if (!(((value & 7) == 1))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l21;
			}
			signedValueToStore = value >> 3;
			if (!((signedValueToStore >= 0) && (signedValueToStore <= 0xFFFF))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l21;
			}
			/* begin storeShort16:ofObject:withValue: */
			shortAtput((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((index + fixedFields) - 1) ) << 1) ), signedValueToStore);
			/* end storeShort16:ofObject:withValue: */
			goto l21;
		}
		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 l21;
		}
		unsignedValueToStore = positive32BitValueOf(value);
		if (!GIV(primFailCode)) {
			/* begin storeLong32:ofObject:withValue: */
			uint32AtPointerput((aContext + BaseHeaderSize) + ((sqInt) (((usqInt) ((index + fixedFields) - 1) ) << 2) ), unsignedValueToStore);
			/* end storeLong32:ofObject:withValue: */
		}
		l21:
		;
		/* 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 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 ((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 l7;
		}
		/* begin fetchStackPointerOf: */
		/* begin fetchPointer:ofObject: */
		sp2 = unsignedLongAt((rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) StackPointerIndex ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (!(((sp2 & 7) == 1))) {
			sz = 0;
			goto l7;
		}
		assert((ReceiverIndex + (sp2 >> 3)) < (lengthOf(rcvr)));
		sz = sp2 >> 3;
		/* end fetchStackPointerOf: */
		l7:
		;
		/* 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 fmt1;
	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 object1;
	sqInt object2;
	sqInt object3;
	sqInt object4;
	sqInt primRcvr;
	char *sp;
	char *sp2;
	char *sp3;
	char *sp4;
	char *sp5;
	char *sp6;
	sqInt spec;
	sqInt successBoolean;
	sqInt successBoolean1;
	sqInt top;
	sqInt top2;
	sqInt val;
	sqInt valuePointer;
	sqInt valuePointer1;
	sqInt valuePointer2;
	sqInt valuePointer3;

	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));
	header = unsignedLongAt((methodArg + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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 l17;
	}
	/* begin isClassOfNonImm:equalTo:compactClassIndex: */
	assert(!(isImmediate(spec)));
	/* begin classIndexOf: */
	ccIndex = (longAt(spec)) & (classIndexMask());
	/* end classIndexOf: */
	{
		isArray = ClassArrayCompactIndex == ccIndex;
		goto l17;
	}
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	l17:
	;
	/* 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 l13;
		}
		if (fmt >= (firstByteFormat())) {
			moduleLength = (numSlots3 << (shiftForWord())) - (fmt & 7);
			goto l13;
		}
		if (fmt >= (firstShortFormat())) {
			moduleLength = (numSlots3 << ((shiftForWord()) - 1)) - (fmt & 3);
			goto l13;
		}
		if (fmt >= (firstLongFormat())) {
			moduleLength = (numSlots3 << ((shiftForWord()) - 2)) - (fmt & 1);
			goto l13;
		}
		if (fmt == (sixtyFourBitIndexableFormat())) {
			moduleLength = numSlots3;
			goto l13;
		}
		moduleLength = 0;
		l13:
		;
		/* end lengthOf:format: */
	}
	/* begin fetchPointer:ofObject: */
	functionName = unsignedLongAt((spec + BaseHeaderSize) + (1U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	/* begin success: */
	successBoolean1 = ((functionName & (tagMask())) == 0) && (((((usqInt) (longAt(functionName)) ) >> (formatShift())) & (formatMask())) >= (firstByteFormat()));
	if (!successBoolean1) {
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
	}
	/* end success: */
	/* begin lengthOf:format: */
	fmt1 = (((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 (fmt1 <= 5) {
		functionLength = numSlots4;
		goto l19;
	}
	if (fmt1 >= (firstByteFormat())) {
		functionLength = (numSlots4 << (shiftForWord())) - (fmt1 & 7);
		goto l19;
	}
	if (fmt1 >= (firstShortFormat())) {
		functionLength = (numSlots4 << ((shiftForWord()) - 1)) - (fmt1 & 3);
		goto l19;
	}
	if (fmt1 >= (firstLongFormat())) {
		functionLength = (numSlots4 << ((shiftForWord()) - 2)) - (fmt1 & 1);
		goto l19;
	}
	if (fmt1 == (sixtyFourBitIndexableFormat())) {
		functionLength = numSlots4;
		goto l19;
	}
	functionLength = 0;
	l19:
	;
	/* 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: */
		valuePointer1 = (primRcvr = popStack());
		assert(!(isOopForwarded(GIV(tempOop))));
		longAtput((GIV(tempOop) + BaseHeaderSize) + (1U << (shiftForWord())), valuePointer1);
		/* end storePointerUnchecked:ofObject:withValue: */
		/* begin storePointerUnchecked:ofObject:withValue: */
		/* begin popStack */
		top = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		valuePointer2 = top;
		/* end popStack */
		assert(!(isOopForwarded(GIV(tempOop))));
		longAtput((GIV(tempOop) + BaseHeaderSize) + (2U << (shiftForWord())), valuePointer2);
		/* end storePointerUnchecked:ofObject:withValue: */
		/* begin storePointerUnchecked:ofObject:withValue: */
		/* begin popStack */
		top2 = unsignedLongAt(GIV(stackPointer));
		GIV(stackPointer) += BytesPerWord;
		valuePointer3 = top2;
		/* end popStack */
		assert(!(isOopForwarded(GIV(tempOop))));
		longAtput((GIV(tempOop) + BaseHeaderSize) + (3U << (shiftForWord())), valuePointer3);
		/* 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) {
		int t0;
		int t1;

		if (((freeStart()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart())) != (freeStart()))) {
			/* 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: */
		object1 = unsignedLongAt((GIV(tempOop) + BaseHeaderSize) + (3U << (shiftForWord())));
		unsignedLongAtput((sp2 = GIV(stackPointer) - BytesPerWord), object1);
		GIV(stackPointer) = sp2;
		/* end push: */
		/* begin push: */
		object2 = unsignedLongAt((GIV(tempOop) + BaseHeaderSize) + (2U << (shiftForWord())));
		unsignedLongAtput((sp3 = GIV(stackPointer) - BytesPerWord), object2);
		GIV(stackPointer) = sp3;
		/* end push: */
		/* begin push: */
		object3 = unsignedLongAt((GIV(tempOop) + BaseHeaderSize) + (1U << (shiftForWord())));
		unsignedLongAtput((sp4 = GIV(stackPointer) - BytesPerWord), object3);
		GIV(stackPointer) = sp4;
		/* end push: */
		/* begin push: */
		object4 = unsignedLongAt((GIV(tempOop) + BaseHeaderSize) + (0U << (shiftForWord())));
		unsignedLongAtput((sp5 = GIV(stackPointer) - BytesPerWord), object4);
		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;
	char *sp;
	char *sp2;
	char *sp3;
	char *sp4;
	char *sp5;

	nArgs = 0;
	savedFramePointer = ((char *) 0 );
	savedStackPointer = ((char *) 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:inClass: */
	primitiveFunctionPointer = ((void (*)(void)) (((primIdx > MaxPrimitiveIndex)
		 ? 0
		 : primitiveTable[primIdx])) );
	/* end functionPointerFor:inClass: */
	if (primitiveFunctionPointer == 0) {
		primitiveFunctionPointer = primitiveDoPrimitiveWithArgs;
		/* begin primitiveFailFor: */
		GIV(primFailCode) = -PrimErrBadIndex;
		return;
		/* end primitiveFailFor: */
	}
	if (((savedNumArgs = GIV(argumentCount))) == 3) {
		/* begin stackValue: */
		GIV(tempOop2) = unsignedLongAt(GIV(stackPointer) + (4 * BytesPerWord));
		/* end stackValue: */
		/* begin stackValue: */
		rcvr = unsignedLongAt(GIV(stackPointer) + (3 * 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) = 0;
		return;
	}
	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) {
		int t0;
		int t1;

		if (((freeStart()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart())) != (freeStart()))) {
			/* 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));
	}
	!GIV(primFailCode);
	goto l17;
	l17:
	;
	/* 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: */
			/* 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) = (GIV(tempOop2) = 0);
}
/*	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;

	nArgs = 0;
	savedFramePointer = ((char *) 0 );
	savedStackPointer = ((char *) 0 );
	/* begin stackTop */
	methodArgument = unsignedLongAt(GIV(stackPointer));
	/* 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)));
	header = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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:inClass: */
	primitiveFunctionPointer = ((void (*)(void)) (((primitiveIndex > MaxPrimitiveIndex)
		 ? 0
		 : primitiveTable[primitiveIndex])) );
	/* end functionPointerFor:inClass: */
	GIV(argumentCount) -= 1;
	/* begin executeNewMethod */
	/* begin executeNewMethod: */
	inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	/* begin executePrimitiveFromInterpreter:ifFail: */
	if (primitiveFunctionPointer != 0) {
		int t18;

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

			executeQuickPrimitive();
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), inInterpreter);
			/* end returnToExecutive: */
			goto l8;
		}
		/* 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) {
			int t0;
			int t1;

			if (((freeStart()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart())) != (freeStart()))) {
				/* 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) {
			sqInt t1;

			/* begin returnToExecutive: */
			returntoExecutive(popStack(), inInterpreter);
			/* end returnToExecutive: */
			goto l8;
		}
	}
	{
		{
			/* 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();
	}
	l8:
	;
	/* 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;

	nArgs = 0;
	savedFramePointer = ((char *) 0 );
	savedStackPointer = ((char *) 0 );
	/* begin stackTop */
	methodArgument = unsignedLongAt(GIV(stackPointer));
	/* 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));
	header2 = unsignedLongAt((methodArgument + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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)));
	header3 = unsignedLongAt((GIV(newMethod) + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
	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:inClass: */
	primitiveFunctionPointer = ((void (*)(void)) (((primitiveIndex > MaxPrimitiveIndex)
		 ? 0
		 : primitiveTable[primitiveIndex])) );
	/* end functionPointerFor:inClass: */
	GIV(argumentCount) = argCnt;
	/* begin executeNewMethod */
	/* begin executeNewMethod: */
	inInterpreter = !(((usqInt) ((usqInt) GIV(instructionPointer) ) ) < (startOfObjectMemory(getMemoryMap())));
	/* begin executePrimitiveFromInterpreter:ifFail: */
	if (primitiveFunctionPointer != 0) {
		int t18;

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

			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) {
			int t0;
			int t1;

			if (((freeStart()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart())) != (freeStart()))) {
				/* 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) {
			sqInt t1;

			/* begin returnToExecutive: */
			returntoExecutive(popStack(), inInterpreter);
			/* end returnToExecutive: */
			goto l13;
		}
	}
	{
		{
			/* 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();
	}
	l13:
	;
	/* 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 fmt1;
	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) {
				int t0;
				int t1;

				if (((freeStart()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart())) != (freeStart()))) {
					/* 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 l13;
		}
		if (fmt >= (firstByteFormat())) {
			moduleLength = (numSlots << (shiftForWord())) - (fmt & 7);
			goto l13;
		}
		if (fmt >= (firstShortFormat())) {
			moduleLength = (numSlots << ((shiftForWord()) - 1)) - (fmt & 3);
			goto l13;
		}
		if (fmt >= (firstLongFormat())) {
			moduleLength = (numSlots << ((shiftForWord()) - 2)) - (fmt & 1);
			goto l13;
		}
		if (fmt == (sixtyFourBitIndexableFormat())) {
			moduleLength = numSlots;
			goto l13;
		}
		moduleLength = 0;
		l13:
		;
		/* 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: */
	fmt1 = (((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 (fmt1 <= 5) {
		functionLength = numSlots3;
		goto l16;
	}
	if (fmt1 >= (firstByteFormat())) {
		functionLength = (numSlots3 << (shiftForWord())) - (fmt1 & 7);
		goto l16;
	}
	if (fmt1 >= (firstShortFormat())) {
		functionLength = (numSlots3 << ((shiftForWord()) - 1)) - (fmt1 & 3);
		goto l16;
	}
	if (fmt1 >= (firstLongFormat())) {
		functionLength = (numSlots3 << ((shiftForWord()) - 2)) - (fmt1 & 1);
		goto l16;
	}
	if (fmt1 == (sixtyFourBitIndexableFormat())) {
		functionLength = numSlots3;
		goto l16;
	}
	functionLength = 0;
	l16:
	;
	/* 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 l3;
			}
		};
		index = 0;
		l3:
		;
		/* 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) {
			int t0;
			int t1;

			if (((freeStart()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart())) != (freeStart()))) {
				/* 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 l2;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		byteSize = 0;
		goto l2;
	}
	/* end checkedIntegerValueOf: */
	l2:
	;
	/* 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 l1;
	}
	oop = oop2;
	l1:
	;
	/* 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 l3;
	}
	/* begin fetchPointer:ofObject: */
	addr = unsignedLongAt((oop + BaseHeaderSize) + (0U << (shiftForWord())));
	/* end fetchPointer:ofObject: */
	l3:
	;
	/* 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 l5;
	}
	/* begin storePointer:ofObject:withValue: */
	valuePointer = ((sqInt) 0 );
	assert(!(isForwarded(oop)));
	if (((oop & (tagMask())) == 0) && ((oop & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
		int t0;
		int t1;

		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 l4;
	}
	if (valuePointer & (tagMask())) {
		goto l4;
	}
	if (!(oop >= 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(), oop);
	l4:
	;
	/* end possiblePermObjectStoreInto:value: */
	unsignedLongAtput((oop + BaseHeaderSize) + (0U << (shiftForWord())), valuePointer);
	/* end storePointer:ofObject:withValue: */
	l5:
	;
	/* 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 l1;
	}
	if (obj == GIV(falseObj)) {
		isSigned = 0;
		goto l1;
	}
	/* begin success: */
	{
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
	}
	/* end success: */
	isSigned = null;
	l1:
	;
	/* end booleanValueOf: */
	/* begin stackIntegerValue: */
	integerPointer = unsignedLongAt(GIV(stackPointer) + (1 * 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: */
	/* begin stackIntegerValue: */
	integerPointer2 = unsignedLongAt(GIV(stackPointer) + (2 * BytesPerWord));
	/* begin checkedIntegerValueOf: */
	if (((integerPointer2 & 7) == 1)) {
		byteOffset = integerPointer2 >> 3;
		goto l4;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		byteOffset = 0;
		goto l4;
	}
	/* end checkedIntegerValueOf: */
	l4:
	;
	/* 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 l2;
	}
	rcvr = oop;
	l2:
	;
	/* 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 l1;
	}
	if (obj == GIV(falseObj)) {
		isSigned = 0;
		goto l1;
	}
	/* begin success: */
	{
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
	}
	/* end success: */
	isSigned = null;
	l1:
	;
	/* 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 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 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) + (4 * 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: */
	}
	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 l9;
				}
				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 l9;
						}
						handlerOrNilOrZero = marryFrameSP(theFP2, theSP2);
						goto l9;
						/* 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 l9;
				/* end nilObject */
			}
			handlerOrNilOrZero = findMethodWithPrimitiveFromContextUpToContext(198, senderContext, stopContext);
			l9:
			;
			/* 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(statAverageLivePagesWhenMapping());
		}
		case 69:
		{
			return ((((usqInt) (statMaxPageCountWhenMapping()) ) << 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 l6;
	}
	if (fmt >= (firstByteFormat())) {
		totalLength = (numSlots << (shiftForWord())) - (fmt & 7);
		goto l6;
	}
	if (fmt >= (firstShortFormat())) {
		totalLength = (numSlots << ((shiftForWord()) - 1)) - (fmt & 3);
		goto l6;
	}
	if (fmt >= (firstLongFormat())) {
		totalLength = (numSlots << ((shiftForWord()) - 2)) - (fmt & 1);
		goto l6;
	}
	if (fmt == (sixtyFourBitIndexableFormat())) {
		totalLength = numSlots;
		goto l6;
	}
	totalLength = 0;
	l6:
	;
	/* end lengthOf:format: */
	/* begin fixedFieldsOf:format:length: */
	if ((fmt >= (sixtyFourBitIndexableFormat())) || (fmt == 2)) {
		fixedFields = 0;
		goto l7;
	}
	if (fmt < 2) {
		fixedFields = totalLength;
		goto l7;
	}
	class = fetchClassOfNonImm(rcvr);
	/* begin fixedFieldsOfClassFormat: */
	classFormat = (unsignedLongAt((class + BaseHeaderSize) + ((sqInt) (((usqInt) InstanceSpecificationIndex ) << (shiftForWord())) ))) >> 3;
	fixedFields = classFormat & ((1U << (fixedFieldsFieldWidth())) - 1);
	/* end fixedFieldsOfClassFormat: */
	l7:
	;
	/* 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 l4;
			/* end fetchPointer:ofObject: */
		}
		if (fmt >= (firstByteFormat())) {
			value = ((((usqInt) (byteAt((rcvr + BaseHeaderSize) + (index - 1))) ) << 3) | 1);
			goto l4;
		}
		if (fmt >= (firstShortFormat())) {
			value = ((((usqInt) ((unsigned short) (shortAt((rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (index - 1) ) << 1) ))) ) ) << 3) | 1);
			goto l4;
		}
		if (fmt == (sixtyFourBitIndexableFormat())) {
			value = positive64BitIntegerFor(long64At((rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (index - 1) ) << 3) )));
			goto l4;
		}
		/* begin positive32BitIntegerFor: */
		integerValue = long32At((rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (index - 1) ) << 2) ));
		{
			value = (((((usqInt) integerValue ) & 0xFFFFFFFFU) << 3) | 1);
			goto l4;
		}
		/* end positive32BitIntegerFor: */
		l4:
		;
		/* 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 *thePage1;
	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 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)) {
		/* begin instVar:ofContext:put: */
		assert(isMarriedOrWidowedContext(rcvr));
		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))))) {
			int t10;
			int t11;
			int t2;
			int t3;

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

				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 l20;
			}
			if (newValue & (tagMask())) {
				goto l20;
			}
			if (!(rcvr >= 0x20000000000LL)) {
				goto l20;
			}
			if (newValue >= 0x20000000000LL) {
				goto l20;
			}
			if ((newValue >= GIV(nilObj)) && (newValue <= GIV(trueObj))) {
				goto l20;
			}
			if (!(newValue >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l20;
			}
			remember(getFromPermToNewSpaceRememberedSet(), rcvr);
			l20:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (index - 1) ) << (shiftForWord())) ), newValue);
			/* end storePointer:ofObject:withValue: */
			if ((index - 1) == StackPointerIndex) {
				ensureContextIsExecutionSafeAfterAssignToStackPointer(rcvr);
			}
			goto l23;
		}
		/* 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: */
				thePage1 = GIV(stackPage);
				GIV(stackPointer) = (thePage1->headSP);
				GIV(framePointer) = (thePage1->headFP);
				/* end setStackPointersFromPage: */
			} else {
				markStackPageMostRecentlyUsed(GIV(stackPage));
			}
			goto l23;
		}
		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)))) {
			int t0;
			int t1;

			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 l19;
		}
		if (newValue & (tagMask())) {
			goto l19;
		}
		if (!(rcvr >= 0x20000000000LL)) {
			goto l19;
		}
		if (newValue >= 0x20000000000LL) {
			goto l19;
		}
		if ((newValue >= GIV(nilObj)) && (newValue <= GIV(trueObj))) {
			goto l19;
		}
		if (!(newValue >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l19;
		}
		remember(getFromPermToNewSpaceRememberedSet(), rcvr);
		l19:
		;
		/* 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));
		assertValidExecutionPointersimbarline(((usqInt) GIV(instructionPointer) ), GIV(framePointer), GIV(stackPointer), 1, __LINE__);
		l23:
		;
		/* 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)))) {
				int t0;
				int t1;

				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 - 1) ) << (shiftForWord())) ), newValue);
			/* end storePointer:ofObject:withValue: */
			goto l15;
		}
		if (fmt >= (firstByteFormat())) {
			if (!(((newValue & 7) == 1))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l15;
			}
			signedValueToStore = newValue >> 3;
			if (!((signedValueToStore >= 0) && (signedValueToStore <= 0xFF))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l15;
			}
			/* begin storeByte:ofObject:withValue: */
			byteAtput((rcvr + BaseHeaderSize) + (index - 1), signedValueToStore);
			/* end storeByte:ofObject:withValue: */
			goto l15;
		}
		if (fmt >= (firstShortFormat())) {
			if (!(((newValue & 7) == 1))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l15;
			}
			signedValueToStore = newValue >> 3;
			if (!((signedValueToStore >= 0) && (signedValueToStore <= 0xFFFF))) {
				GIV(primFailCode) = PrimErrBadArgument;
				goto l15;
			}
			/* begin storeShort16:ofObject:withValue: */
			shortAtput((rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (index - 1) ) << 1) ), signedValueToStore);
			/* end storeShort16:ofObject:withValue: */
			goto l15;
		}
		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 l15;
		}
		unsignedValueToStore = positive32BitValueOf(newValue);
		if (!GIV(primFailCode)) {
			/* begin storeLong32:ofObject:withValue: */
			uint32AtPointerput((rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) (index - 1) ) << 2) ), unsignedValueToStore);
			/* end storeLong32:ofObject:withValue: */
		}
		l15:
		;
		/* 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 l3;
	}
	/* begin firstFixedField: */
	bytes = ((void *) (pointerForOop(rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l3:
	;
	/* 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 l5;
	}
	if (fmt2 <= (sixtyFourBitIndexableFormat())) {
		byteSize = numBytes;
		goto l5;
	}
	if (fmt2 >= (firstShortFormat())) {
		byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 3) ) << 1) );
		goto l5;
	}
	byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 1) ) << 2) );
	l5:
	;
	/* 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 l3;
	}
	/* begin firstFixedField: */
	bytes = ((void *) (pointerForOop(rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l3:
	;
	/* 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 l5;
	}
	if (fmt2 <= (sixtyFourBitIndexableFormat())) {
		byteSize = numBytes;
		goto l5;
	}
	if (fmt2 >= (firstShortFormat())) {
		byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 3) ) << 1) );
		goto l5;
	}
	byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 1) ) << 2) );
	l5:
	;
	/* 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 l3;
	}
	/* begin firstFixedField: */
	bytes = ((void *) (pointerForOop(rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l3:
	;
	/* 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 l5;
	}
	if (fmt2 <= (sixtyFourBitIndexableFormat())) {
		byteSize = numBytes;
		goto l5;
	}
	if (fmt2 >= (firstShortFormat())) {
		byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 3) ) << 1) );
		goto l5;
	}
	byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 1) ) << 2) );
	l5:
	;
	/* 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 l3;
	}
	/* begin firstFixedField: */
	bytes = ((void *) (pointerForOop(rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l3:
	;
	/* 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 l5;
	}
	if (fmt2 <= (sixtyFourBitIndexableFormat())) {
		byteSize = numBytes;
		goto l5;
	}
	if (fmt2 >= (firstShortFormat())) {
		byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 3) ) << 1) );
		goto l5;
	}
	byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 1) ) << 2) );
	l5:
	;
	/* 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 l3;
	}
	/* begin firstFixedField: */
	bytes = ((void *) (pointerForOop(rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l3:
	;
	/* 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 l5;
	}
	if (fmt2 <= (sixtyFourBitIndexableFormat())) {
		byteSize = numBytes;
		goto l5;
	}
	if (fmt2 >= (firstShortFormat())) {
		byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 3) ) << 1) );
		goto l5;
	}
	byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 1) ) << 2) );
	l5:
	;
	/* 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 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: */
	}
	/* 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 l3;
	}
	/* begin firstFixedField: */
	bytes = ((void *) (pointerForOop(rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l3:
	;
	/* 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 l5;
	}
	if (fmt2 <= (sixtyFourBitIndexableFormat())) {
		byteSize = numBytes;
		goto l5;
	}
	if (fmt2 >= (firstShortFormat())) {
		byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 3) ) << 1) );
		goto l5;
	}
	byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 1) ) << 2) );
	l5:
	;
	/* 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 l3;
	}
	/* begin firstFixedField: */
	bytes = ((void *) (pointerForOop(rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l3:
	;
	/* 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 l5;
	}
	if (fmt2 <= (sixtyFourBitIndexableFormat())) {
		byteSize = numBytes;
		goto l5;
	}
	if (fmt2 >= (firstShortFormat())) {
		byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 3) ) << 1) );
		goto l5;
	}
	byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 1) ) << 2) );
	l5:
	;
	/* 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 l6;
	}
	l6:
	;
	/* 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 l3;
	}
	l3:
	;
	/* 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 l3;
	}
	/* begin firstFixedField: */
	bytes = ((void *) (pointerForOop(rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l3:
	;
	/* 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 l5;
	}
	if (fmt2 <= (sixtyFourBitIndexableFormat())) {
		byteSize = numBytes;
		goto l5;
	}
	if (fmt2 >= (firstShortFormat())) {
		byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 3) ) << 1) );
		goto l5;
	}
	byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 1) ) << 2) );
	l5:
	;
	/* 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 l3;
	}
	/* begin firstFixedField: */
	bytes = ((void *) (pointerForOop(rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l3:
	;
	/* 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 l5;
	}
	if (fmt2 <= (sixtyFourBitIndexableFormat())) {
		byteSize = numBytes;
		goto l5;
	}
	if (fmt2 >= (firstShortFormat())) {
		byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 3) ) << 1) );
		goto l5;
	}
	byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 1) ) << 2) );
	l5:
	;
	/* 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 l3;
	}
	/* begin firstFixedField: */
	bytes = ((void *) (pointerForOop(rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l3:
	;
	/* 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 l5;
	}
	if (fmt2 <= (sixtyFourBitIndexableFormat())) {
		byteSize = numBytes;
		goto l5;
	}
	if (fmt2 >= (firstShortFormat())) {
		byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 3) ) << 1) );
		goto l5;
	}
	byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 1) ) << 2) );
	l5:
	;
	/* 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 l3;
		}
		/* 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 l3;
		}
		if (fmt <= (sixtyFourBitIndexableFormat())) {
			moduleNameStringSize = numBytes;
			goto l3;
		}
		if (fmt >= (firstShortFormat())) {
			moduleNameStringSize = numBytes - ((sqInt) (((usqInt) (fmt & 3) ) << 1) );
			goto l3;
		}
		moduleNameStringSize = numBytes - ((sqInt) (((usqInt) (fmt & 1) ) << 2) );
		/* end numBytesOf: */
		l3:
		;
		/* 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 l7;
	}
	/* 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 l7;
	}
	if (fmt2 <= (sixtyFourBitIndexableFormat())) {
		symbolStringSize = numBytes2;
		goto l7;
	}
	if (fmt2 >= (firstShortFormat())) {
		symbolStringSize = numBytes2 - ((sqInt) (((usqInt) (fmt2 & 3) ) << 1) );
		goto l7;
	}
	symbolStringSize = numBytes2 - ((sqInt) (((usqInt) (fmt2 & 1) ) << 2) );
	/* end numBytesOf: */
	l7:
	;
	/* 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 l3;
	}
	/* begin firstFixedField: */
	bytes = ((void *) (pointerForOop(rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l3:
	;
	/* 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 l5;
	}
	if (fmt2 <= (sixtyFourBitIndexableFormat())) {
		byteSize = numBytes;
		goto l5;
	}
	if (fmt2 >= (firstShortFormat())) {
		byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 3) ) << 1) );
		goto l5;
	}
	byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 1) ) << 2) );
	l5:
	;
	/* 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 l3;
	}
	/* begin firstFixedField: */
	bytes = ((void *) (pointerForOop(rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l3:
	;
	/* 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 l5;
	}
	if (fmt2 <= (sixtyFourBitIndexableFormat())) {
		byteSize = numBytes;
		goto l5;
	}
	if (fmt2 >= (firstShortFormat())) {
		byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 3) ) << 1) );
		goto l5;
	}
	byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 1) ) << 2) );
	l5:
	;
	/* 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 l6;
	}
	l6:
	;
	/* 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 l3;
	}
	l3:
	;
	/* 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 l3;
	}
	/* begin firstFixedField: */
	bytes = ((void *) (pointerForOop(rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l3:
	;
	/* 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 l5;
	}
	if (fmt2 <= (sixtyFourBitIndexableFormat())) {
		byteSize = numBytes;
		goto l5;
	}
	if (fmt2 >= (firstShortFormat())) {
		byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 3) ) << 1) );
		goto l5;
	}
	byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 1) ) << 2) );
	l5:
	;
	/* 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 l3;
	}
	/* begin firstFixedField: */
	bytes = ((void *) (pointerForOop(rcvr + BaseHeaderSize)) );
	/* end firstFixedField: */
	l3:
	;
	/* 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 l5;
	}
	if (fmt2 <= (sixtyFourBitIndexableFormat())) {
		byteSize = numBytes;
		goto l5;
	}
	if (fmt2 >= (firstShortFormat())) {
		byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 3) ) << 1) );
		goto l5;
	}
	byteSize = numBytes - ((sqInt) (((usqInt) (fmt2 & 1) ) << 2) );
	l5:
	;
	/* 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)))) {
			int t0;
			int t1;

			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 l4;
		}
		if (lrpcm & (tagMask())) {
			goto l4;
		}
		if (!(result >= 0x20000000000LL)) {
			goto l4;
		}
		if (lrpcm >= 0x20000000000LL) {
			goto l4;
		}
		if ((lrpcm >= GIV(nilObj)) && (lrpcm <= GIV(trueObj))) {
			goto l4;
		}
		if (!(lrpcm >= (startOfObjectMemory(GIV(memoryMap))))) {
			goto l4;
		}
		remember(getFromPermToNewSpaceRememberedSet(), result);
		l4:
		;
		/* 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));
		header2 = unsignedLongAt((rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) HeaderIndex ) << (shiftForWord())) ));
		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) {
		int t18;

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

			executeQuickPrimitive();
			/* begin returnToExecutive: */
			returntoExecutive(popStack(), inInterpreter);
			/* end returnToExecutive: */
			goto l8;
		}
		/* 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) {
			int t0;
			int t1;

			if (((freeStart()) < GIV(scavengeThreshold)) && ((unsignedLongAt(freeStart())) != (freeStart()))) {
				/* 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) {
			sqInt t1;

			/* begin returnToExecutive: */
			returntoExecutive(popStack(), inInterpreter);
			/* end returnToExecutive: */
			goto l8;
		}
	}
	{
		{
			/* 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();
	}
	l8:
	;
	/* 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 l2;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		index = 0;
		goto l2;
	}
	/* end checkedIntegerValueOf: */
	l2:
	;
	/* 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)))) {
				int t0;
				int t1;

				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 l7;
			}
			if (sema & (tagMask())) {
				goto l7;
			}
			if (!(GIV(specialObjectsOop) >= 0x20000000000LL)) {
				goto l7;
			}
			if (sema >= 0x20000000000LL) {
				goto l7;
			}
			if ((sema >= GIV(nilObj)) && (sema <= GIV(trueObj))) {
				goto l7;
			}
			if (!(sema >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l7;
			}
			remember(getFromPermToNewSpaceRememberedSet(), GIV(specialObjectsOop));
			l7:
			;
			/* 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)))) {
				int t0;
				int t1;

				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 l4;
			}
			if (GIV(nilObj) & (tagMask())) {
				goto l4;
			}
			if (!(GIV(specialObjectsOop) >= 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(), GIV(specialObjectsOop));
			l4:
			;
			/* 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)))) {
				int t0;
				int t1;

				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 l7;
			}
			if (sema & (tagMask())) {
				goto l7;
			}
			if (!(GIV(specialObjectsOop) >= 0x20000000000LL)) {
				goto l7;
			}
			if (sema >= 0x20000000000LL) {
				goto l7;
			}
			if ((sema >= GIV(nilObj)) && (sema <= GIV(trueObj))) {
				goto l7;
			}
			if (!(sema >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l7;
			}
			remember(getFromPermToNewSpaceRememberedSet(), GIV(specialObjectsOop));
			l7:
			;
			/* 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)))) {
				int t0;
				int t1;

				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 l4;
			}
			if (GIV(nilObj) & (tagMask())) {
				goto l4;
			}
			if (!(GIV(specialObjectsOop) >= 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(), GIV(specialObjectsOop));
			l4:
			;
			/* 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 oop1;
	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) ));
			{
				oop1 = (((((usqInt) integerValue ) & 0xFFFFFFFFU) << 3) | 1);
				goto l7;
			}
			l7:
			;
			/* end positive32BitIntegerFor: */
			unsignedLongAtput((sp3 = GIV(stackPointer) + (((GIV(argumentCount) + 1) - 1) * BytesPerWord)), oop1);
			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 *thePage1;
	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(isMarriedOrWidowedContext(rcvr));
				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))))) {
					int t10;
					int t11;
					int t2;
					int t3;

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

						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 l21;
					}
					if (newValue & (tagMask())) {
						goto l21;
					}
					if (!(rcvr >= 0x20000000000LL)) {
						goto l21;
					}
					if (newValue >= 0x20000000000LL) {
						goto l21;
					}
					if ((newValue >= GIV(nilObj)) && (newValue <= GIV(trueObj))) {
						goto l21;
					}
					if (!(newValue >= (startOfObjectMemory(GIV(memoryMap))))) {
						goto l21;
					}
					remember(getFromPermToNewSpaceRememberedSet(), rcvr);
					l21:
					;
					/* end possiblePermObjectStoreInto:value: */
					unsignedLongAtput((rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) index ) << (shiftForWord())) ), newValue);
					/* end storePointer:ofObject:withValue: */
					if (index == 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 == 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: */
						thePage1 = GIV(stackPage);
						GIV(stackPointer) = (thePage1->headSP);
						GIV(framePointer) = (thePage1->headFP);
						/* end setStackPointersFromPage: */
					} else {
						markStackPageMostRecentlyUsed(GIV(stackPage));
					}
					goto l24;
				}
				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)))) {
					int t0;
					int t1;

					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 l20;
				}
				if (newValue & (tagMask())) {
					goto l20;
				}
				if (!(rcvr >= 0x20000000000LL)) {
					goto l20;
				}
				if (newValue >= 0x20000000000LL) {
					goto l20;
				}
				if ((newValue >= GIV(nilObj)) && (newValue <= GIV(trueObj))) {
					goto l20;
				}
				if (!(newValue >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l20;
				}
				remember(getFromPermToNewSpaceRememberedSet(), rcvr);
				l20:
				;
				/* end possiblePermObjectStoreInto:value: */
				unsignedLongAtput((rcvr + BaseHeaderSize) + ((sqInt) (((usqInt) index ) << (shiftForWord())) ), newValue);
				/* end storePointer:ofObject:withValue: */
				if (index == StackPointerIndex) {
					ensureContextIsExecutionSafeAfterAssignToStackPointer(rcvr);
				}
				markStackPageMostRecentlyUsed(GIV(stackPage));
				assertValidExecutionPointersimbarline(((usqInt) GIV(instructionPointer) ), GIV(framePointer), GIV(stackPointer), 1, __LINE__);
				l24:
				;
				/* end instVar:ofContext:put: */
			} else {
				/* begin storePointer:ofObject:withValue: */
				assert(!(isForwarded(rcvr)));
				if (((rcvr & (tagMask())) == 0) && ((rcvr & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
					int t0;
					int t1;

					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 l10;
				}
				if (newValue & (tagMask())) {
					goto l10;
				}
				if (!(rcvr >= 0x20000000000LL)) {
					goto l10;
				}
				if (newValue >= 0x20000000000LL) {
					goto l10;
				}
				if ((newValue >= GIV(nilObj)) && (newValue <= GIV(trueObj))) {
					goto l10;
				}
				if (!(newValue >= (startOfObjectMemory(GIV(memoryMap))))) {
					goto l10;
				}
				remember(getFromPermToNewSpaceRememberedSet(), rcvr);
				l10:
				;
				/* 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 l16;
			/* end primitiveFail */
		}
		value = value2;
		goto l16;
	}
	if (newValue & (tagMask())) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		value = 0;
		goto l16;
	}
	/* 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 l13;
	}
	l13:
	;
	/* end isClassOfNonImm:equalTo:compactClassIndex: */
	if (!ok) {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		value = 0;
		goto l16;
	}
	/* 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 l16;
	}
	if (((sizeof(usqIntptr_t)) == 8) && (bs > 4)) {
		value = SQ_SWAP_8_BYTES_IF_BIGENDIAN(long64At((newValue + BaseHeaderSize) + (0U << 3)));
		goto l16;
	} else {
		value = ((unsigned int) (SQ_SWAP_4_BYTES_IF_BIGENDIAN(long32At((newValue + BaseHeaderSize) + (0U << 2)))) );
		goto l16;
	}
	l16:
	;
	/* 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;

	value = 0;
	/* 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(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: */
	}
	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 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: */
	}
	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;

	value = 0;
	/* 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;
	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 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>>#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 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>>#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 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>>#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 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: */
	}
	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 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: */
	}
	/* 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 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: */
	}
	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 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: */
	}
	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 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: */
	}
	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 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: */
	}
	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 l4;
	}
	/* begin firstFixedField: */
	valueBytes = ((void *) (pointerForOop(valueObject + BaseHeaderSize)) );
	/* end firstFixedField: */
	l4:
	;
	/* 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 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: */
	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 l7;
	}
	if (fmt3 <= (sixtyFourBitIndexableFormat())) {
		byteSize = numBytes;
		goto l7;
	}
	if (fmt3 >= (firstShortFormat())) {
		byteSize = numBytes - ((sqInt) (((usqInt) (fmt3 & 3) ) << 1) );
		goto l7;
	}
	byteSize = numBytes - ((sqInt) (((usqInt) (fmt3 & 1) ) << 2) );
	l7:
	;
	/* 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 l4;
	}
	/* begin firstFixedField: */
	valueBytes = ((void *) (pointerForOop(valueObject + BaseHeaderSize)) );
	/* end firstFixedField: */
	l4:
	;
	/* 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 *thePage1;
	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 l6;
	} else {
		/* begin primitiveFail */
		if (!GIV(primFailCode)) {
			GIV(primFailCode) = 1;
		}
		/* end primitiveFail */
		newStackp = 0;
		goto l6;
	}
	/* end checkedIntegerValueOf: */
	l6:
	;
	/* 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: */
			thePage1 = GIV(stackPage);
			GIV(stackPointer) = (thePage1->headSP);
			GIV(framePointer) = (thePage1->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 l8;
	}
	assert((ReceiverIndex + (sp >> 3)) < (lengthOf(ctxt)));
	stackp = sp >> 3;
	l8:
	;
	/* 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 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: */
	}
	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 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: */
	}
	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 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: */
	}
	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 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: */
	}
	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: */
		/* end methodReturnValue: */
		return;
		/* 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 l15;
				/* end primitiveFailFor: */
			}
		}
		break;
		case 86:
		{
			if (!((argOop == GIV(trueObj)) || (argOop == GIV(falseObj)))) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l15;
				/* end primitiveFailFor: */
			}
			/* begin booleanValueOf: */
			if (argOop == GIV(trueObj)) {
				arg = 1;
				goto l14;
			}
			if (argOop == GIV(falseObj)) {
				arg = 0;
				goto l14;
			}
			/* begin success: */
			{
				if (!GIV(primFailCode)) {
					GIV(primFailCode) = 1;
				}
			}
			/* end success: */
			arg = null;
			l14:
			;
			/* end booleanValueOf: */
		}
		break;
		default:
		{
			if (!(((argOop & 7) == 1))) {
				/* begin primitiveFailFor: */
				GIV(primFailCode) = PrimErrBadArgument;
				goto l15;
				/* end primitiveFailFor: */
			}
			arg = argOop >> 3;
		}
	}
	/* begin primitiveFailFor: */
	GIV(primFailCode) = PrimErrBadArgument;
	/* end primitiveFailFor: */
	switch (index) {
		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 l10;
			}
			/* 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;
			l10:
			;
			/* 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 l3;
				}
				GIV(flagInterpretedMethods) = arg & 2;
				GIV(preemptionYields) = (arg & 4) == 0;
				l3:
				;
				/* 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(statAverageLivePagesWhenMapping());
			/* 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) (statMaxPageCountWhenMapping()) ) << 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: */
	}
	l15:
	;
	/* 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 */
}
/*	Prune the stack to contain only the path, removing stacked indices 
	and mapping frame pointers to contexts The issue here is that a 
	GC can occur during ensureFrameIsMarried:SP:, but frame pointers 
	are not valid objects. So first prune back to objects and framePointers 
	as integers, and then replace frame pointers as integers by contexts. */
/* StackInterpreterPrimitives>>#pruneStack:stackp: */
static void NoDbgRegParms
pruneStackstackp(sqInt anArray, sqInt stackp)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	char *callerFP;
	int finger;
	char *fp;
	sqInt i;
	sqInt iLimiT;
	sqInt objOrFP;
	sqInt oop;
	sqInt oop2;
	char *theFP;
	char *theFPAbove;
	StackPage *thePage;
	sqInt theStack;
	sqInt valuePointer;

	finger = 1;
	for (i = 2; i < stackp; i += 2) {
		/* begin fetchPointer:ofObject: */
		objOrFP = unsignedLongAt((anArray + BaseHeaderSize) + ((sqInt) (((usqInt) i ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((((usqInt) ((char *) objOrFP ) ) & (BytesPerWord - 1)) == 0) && ((((usqInt) ((char *) objOrFP ) ) >= ((usqInt) (GIV(stackBasePlus1) - 1) )) && (((usqInt) ((char *) objOrFP ) ) <= ((usqInt) GIV(pages) )))) {
			/* begin withSmallIntegerTags: */
			assert(((oopForPointer(((char *) objOrFP ))) & (BytesPerWord - 1)) == 0);
			objOrFP = (oopForPointer(((char *) objOrFP ))) + (smallIntegerTag());
			/* end withSmallIntegerTags: */
		}
		/* begin storePointerUnchecked:ofObject:withValue: */
		assert(!(isOopForwarded(anArray)));
		longAtput((anArray + BaseHeaderSize) + ((sqInt) (((usqInt) finger ) << (shiftForWord())) ), objOrFP);
		/* end storePointerUnchecked:ofObject:withValue: */
		finger += 1;
	};
	for (i = finger, iLimiT = (lengthOfformat(anArray, (((usqInt) (longAt(anArray)) ) >> (formatShift())) & (formatMask()))) - 1; i <= iLimiT; i += 1) {
		/* begin storePointerUnchecked:ofObject:withValue: */
		valuePointer = GIV(nilObj);
		assert(!(isOopForwarded(anArray)));
		longAtput((anArray + BaseHeaderSize) + ((sqInt) (((usqInt) i ) << (shiftForWord())) ), valuePointer);
		/* end storePointerUnchecked:ofObject:withValue: */
	};
	/* begin pushRemappableOop: */
	oop = (theStack = anArray);
	assert(addressCouldBeOop(oop));
	GIV(remapBuffer)[(GIV(remapBufferCount) += 1)] = oop;
	if (!(GIV(remapBufferCount) <= RemapBufferSize)) {
		error("remapBuffer overflow");
	}
	/* end pushRemappableOop: */
	for (i = 1; i < finger; i += 1) {
		/* begin fetchPointer:ofObject: */
		objOrFP = unsignedLongAt((theStack + BaseHeaderSize) + ((sqInt) (((usqInt) i ) << (shiftForWord())) ));
		/* end fetchPointer:ofObject: */
		if (((objOrFP & 7) == 1)) {
			/* begin withoutSmallIntegerTags: */
			assert(((objOrFP & 7) == 1));
			theFP = pointerForOop(objOrFP - 1);
			/* end withoutSmallIntegerTags: */
			/* 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 findFrameAbove:inPage: */
			fp = (thePage->headFP);
			if (fp == theFP) {
				theFPAbove = 0;
				goto l9;
			}
			while (((callerFP = pointerForOop(unsignedLongAt(fp + FoxSavedFP)))) != 0) {
				if (callerFP == theFP) {
					theFPAbove = fp;
					goto l9;
				}
				fp = callerFP;
			};
			error("did not find theFP in stack page");
			theFPAbove = 0;
			l9:
			;
			/* end findFrameAbove:inPage: */
			/* begin ensureFrameIsMarried:SP: */
			if (((isMachineCodeIP(((usqInt) (unsignedLongAt(theFP + FoxMethod)) )))
				 ? ((unsignedLongAt(theFP + FoxMethod)) & MFMethodFlagHasContextFlag) != 0
				 : (byteAt((theFP + FoxIFrameFlags) + 2)) != 0)) {
				assert(isContext(frameContext(theFP)));
				objOrFP = unsignedLongAt(theFP + FoxThisContext);
				goto l10;
			}
			objOrFP = marryFrameSP(theFP, (assert(!(isBaseFrame(theFPAbove))), (theFPAbove + (frameStackedReceiverOffsetNumArgs(((isMachineCodeIP(((usqInt) (unsignedLongAt(theFPAbove + FoxMethod)) )))
				 ? ((((CogMethod *) ((unsignedLongAt(theFPAbove + FoxMethod)) & MFMethodMask) ))->cmNumArgs)
				 : byteAt((theFPAbove + FoxIFrameFlags) + 1))))) + BytesPerWord));
			l10:
			;
			/* end ensureFrameIsMarried:SP: */
			/* begin topRemappableOop */
			theStack = GIV(remapBuffer)[GIV(remapBufferCount)];
			/* end topRemappableOop */
			/* begin storePointer:ofObject:withValue: */
			assert(!(isForwarded(theStack)));
			if (((theStack & (tagMask())) == 0) && ((theStack & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->oldSpaceMask)))) {
				int t0;
				int t1;

				if (((objOrFP & (tagMask())) == 0) && (((objOrFP & ((GIV(memoryMap)->spaceMaskToUse))) == ((GIV(memoryMap)->newSpaceMask))) && (objOrFP >= ((GIV(memoryMap)->newSpaceStart))))) {
					/* begin possibleOldObjectStoreInto: */
					if (!(((((usqInt) (long64At(theStack)) ) >> (rememberedBitShift())) & 1) != 0)) {
						remember(GIV(fromOldSpaceRememberedSet), theStack);
					}
					/* end possibleOldObjectStoreInto: */
				}
			}
			/* begin possiblePermObjectStoreInto:value: */
			if (((((usqInt) (long64At(theStack)) ) >> (rememberedBitShift())) & 1) != 0) {
				goto l11;
			}
			if (objOrFP & (tagMask())) {
				goto l11;
			}
			if (!(theStack >= 0x20000000000LL)) {
				goto l11;
			}
			if (objOrFP >= 0x20000000000LL) {
				goto l11;
			}
			if ((objOrFP >= GIV(nilObj)) && (objOrFP <= GIV(trueObj))) {
				goto l11;
			}
			if (!(objOrFP >= (startOfObjectMemory(GIV(memoryMap))))) {
				goto l11;
			}
			remember(getFromPermToNewSpaceRememberedSet(), theStack);
			l11:
			;
			/* end possiblePermObjectStoreInto:value: */
			unsignedLongAtput((theStack + BaseHeaderSize) + ((sqInt) (((usqInt) finger ) << (shiftForWord())) ), objOrFP);
			/* end storePointer:ofObject:withValue: */
		}
	};
	/* begin popRemappableOop */
	oop2 = GIV(remapBuffer)[GIV(remapBufferCount)];
	GIV(remapBufferCount) -= 1;
	/* end popRemappableOop */
}
/*	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 objOop1;
	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: */
	objOop1 = unsignedLongAt((GIV(specialObjectsOop) + BaseHeaderSize) + ((sqInt) (((usqInt) SchedulerAssociation ) << (shiftForWord())) ));
	/* end fetchPointer:ofObject: */
	/* end splObj: */
	objOop = unsignedLongAt((objOop1 + 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)))) {
		int t0;
		int t1;

		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 l1;
	}
	if (valuePointer & (tagMask())) {
		goto l1;
	}
	if (!(suspendedProcess >= 0x20000000000LL)) {
		goto l1;
	}
	if (valuePointer >= 0x20000000000LL) {
		goto l1;
	}
	if ((valuePointer >= GIV(nilObj)) && (valuePointer <= GIV(trueObj))) {
		goto l1;
	}
	if (!(valuePointer >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l1;
	}
	remember(getFromPermToNewSpaceRememberedSet(), suspendedProcess);
	l1:
	;
	/* 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)))) {
		int t0;
		int t1;

		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 l5;
	}
	if (suspendedProcess & (tagMask())) {
		goto l5;
	}
	if (!(GIV(specialObjectsOop) >= 0x20000000000LL)) {
		goto l5;
	}
	if (suspendedProcess >= 0x20000000000LL) {
		goto l5;
	}
	if ((suspendedProcess >= GIV(nilObj)) && (suspendedProcess <= GIV(trueObj))) {
		goto l5;
	}
	if (!(suspendedProcess >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l5;
	}
	remember(getFromPermToNewSpaceRememberedSet(), GIV(specialObjectsOop));
	l5:
	;
	/* 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)))) {
		int t0;
		int t1;

		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 l5;
	}
	if (anObject & (tagMask())) {
		goto l5;
	}
	if (!(GIV(specialObjectsOop) >= 0x20000000000LL)) {
		goto l5;
	}
	if (anObject >= 0x20000000000LL) {
		goto l5;
	}
	if ((anObject >= GIV(nilObj)) && (anObject <= GIV(trueObj))) {
		goto l5;
	}
	if (!(anObject >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l5;
	}
	remember(getFromPermToNewSpaceRememberedSet(), GIV(specialObjectsOop));
	l5:
	;
	/* 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)))) {
		int t0;
		int t1;

		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 l2;
	}
	if (GIV(nilObj) & (tagMask())) {
		goto l2;
	}
	if (!(aProcess >= 0x20000000000LL)) {
		goto l2;
	}
	if (GIV(nilObj) >= 0x20000000000LL) {
		goto l2;
	}
	if ((GIV(nilObj) >= GIV(nilObj)) && (GIV(nilObj) <= GIV(trueObj))) {
		goto l2;
	}
	if (!(GIV(nilObj) >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l2;
	}
	remember(getFromPermToNewSpaceRememberedSet(), aProcess);
	l2:
	;
	/* 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>>#unmarkAfterPathTo */
static void
unmarkAfterPathTo(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;
	sqInt address;
	sqInt address1;
	sqInt currentObject;
	sqInt followingWord;
	sqInt followingWord2;
	sqInt followingWord3;
	sqInt followingWord4;
	usqInt followingWordAddress;
	usqInt followingWordAddress2;
	usqInt followingWordAddress3;
	usqInt followingWordAddress4;
	usqInt limit;
	sqInt limit1;
	usqInt numSlots;
	usqInt numSlots2;
	sqInt obj;
	sqInt objOop;
	sqInt objOop2;
	sqInt prevObj;
	sqInt prevObj2;
	sqInt prevPrevObj;
	sqInt prevPrevObj2;

	unmarkAllFrames();
	/* begin unmarkAllObjects */
	/* 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 (((((usqInt) (longAt(objOop2)) ) >> (markedBitFullShift())) & 1) != 0) {
				if (((longAt(objOop2)) & (classIndexMask())) > (lastClassIndexPun())) {
					/* begin setIsMarkedOf:to: */
					assert(!(isFreeObject(objOop2)));
					unsignedLongAtput(objOop2, (unsignedLongAt(objOop2)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
					/* end setIsMarkedOf:to: */
				} else {
					if (!(((longAt(objOop2)) & (classIndexMask())) == (segmentBridgePun()))) {
						/* begin setIsMarkedOf:to: */
						assert(!(isFreeObject(objOop2)));
						unsignedLongAtput(objOop2, (unsignedLongAt(objOop2)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
						/* end setIsMarkedOf:to: */
					}
				}
			}
		}
		prevPrevObj2 = prevObj2;
		prevObj2 = objOop2;
		/* begin objectAfter:limit: */
		limit1 = ((sqInt) ((GIV(memoryMap)->oldSpaceEnd)) );
		followingWordAddress4 = addressAfter(objOop2);
		if (oopisGreaterThanOrEqualTo(followingWordAddress4, limit1)) {
			objOop2 = limit1;
			goto l6;
		}
		flag("endianness");
		followingWord4 = unsignedLongAt(followingWordAddress4);
		objOop2 = (((((usqInt) followingWord4 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress4 + BaseHeaderSize
			 : followingWordAddress4);
		l6:
		;
		/* 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 (((((usqInt) (longAt(objOop)) ) >> (markedBitFullShift())) & 1) != 0) {
				if (((longAt(objOop)) & (classIndexMask())) > (lastClassIndexPun())) {
					/* begin setIsMarkedOf:to: */
					assert(!(isFreeObject(objOop)));
					unsignedLongAtput(objOop, (unsignedLongAt(objOop)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
					/* end setIsMarkedOf:to: */
				} else {
					if (!(((longAt(objOop)) & (classIndexMask())) == (segmentBridgePun()))) {
						/* begin setIsMarkedOf:to: */
						assert(!(isFreeObject(objOop)));
						unsignedLongAtput(objOop, (unsignedLongAt(objOop)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
						/* end setIsMarkedOf:to: */
					}
				}
			}
		}
		prevPrevObj = prevObj;
		prevObj = objOop;
		/* begin objectAfter:limit: */
		followingWordAddress = addressAfter(objOop);
		if (oopisGreaterThanOrEqualTo(followingWordAddress, limit)) {
			objOop = limit;
			goto l1;
		}
		flag("endianness");
		followingWord = unsignedLongAt(followingWordAddress);
		objOop = (((((usqInt) followingWord ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress + BaseHeaderSize
			 : followingWordAddress);
		l1:
		;
		/* end objectAfter:limit: */
	};
	/* begin objectStartingAt: */
	address1 = ((eden()).start);
	numSlots2 = byteAt(address1 + 7);
	objOop = ((numSlots2 == (numSlotsMask()))
		 ? address1 + BaseHeaderSize
		 : address1);
	/* end objectStartingAt: */
	while (oopisLessThan(objOop, GIV(freeStart))) {
		{
			if (((((usqInt) (longAt(objOop)) ) >> (markedBitFullShift())) & 1) != 0) {
				if (((longAt(objOop)) & (classIndexMask())) > (lastClassIndexPun())) {
					/* begin setIsMarkedOf:to: */
					assert(!(isFreeObject(objOop)));
					unsignedLongAtput(objOop, (unsignedLongAt(objOop)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
					/* end setIsMarkedOf:to: */
				} else {
					if (!(((longAt(objOop)) & (classIndexMask())) == (segmentBridgePun()))) {
						/* begin setIsMarkedOf:to: */
						assert(!(isFreeObject(objOop)));
						unsignedLongAtput(objOop, (unsignedLongAt(objOop)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
						/* end setIsMarkedOf:to: */
					}
				}
			}
		}
		prevPrevObj = prevObj;
		prevObj = objOop;
		/* begin objectAfter:limit: */
		followingWordAddress2 = addressAfter(objOop);
		if (oopisGreaterThanOrEqualTo(followingWordAddress2, GIV(freeStart))) {
			objOop = GIV(freeStart);
			goto l2;
		}
		flag("endianness");
		followingWord2 = unsignedLongAt(followingWordAddress2);
		objOop = (((((usqInt) followingWord2 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress2 + BaseHeaderSize
			 : followingWordAddress2);
		l2:
		;
		/* end objectAfter:limit: */
	};
	;
	;
	/* end allNewSpaceEntitiesDo: */
	/* begin allPermSpaceObjectsDo: */
	currentObject = (GIV(memoryMap)->permSpaceStart);
	while (!(currentObject == GIV(permSpaceFreeStart))) {
		if (!(((longAt(currentObject)) & (classIndexMask())) == (isFreeObjectClassIndexPun()))) {
			{
				if (((((usqInt) (longAt(currentObject)) ) >> (markedBitFullShift())) & 1) != 0) {
					if (((longAt(currentObject)) & (classIndexMask())) > (lastClassIndexPun())) {
						/* begin setIsMarkedOf:to: */
						assert(!(isFreeObject(currentObject)));
						unsignedLongAtput(currentObject, (unsignedLongAt(currentObject)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
						/* end setIsMarkedOf:to: */
					} else {
						if (!(((longAt(currentObject)) & (classIndexMask())) == (segmentBridgePun()))) {
							/* begin setIsMarkedOf:to: */
							assert(!(isFreeObject(currentObject)));
							unsignedLongAtput(currentObject, (unsignedLongAt(currentObject)) & (~((usqIntptr_t) (1ULL << (markedBitFullShift())) )));
							/* end setIsMarkedOf:to: */
						}
					}
				}
			}
		}
		/* begin objectAfter:limit: */
		followingWordAddress3 = addressAfter(currentObject);
		if (oopisGreaterThanOrEqualTo(followingWordAddress3, GIV(permSpaceFreeStart))) {
			currentObject = GIV(permSpaceFreeStart);
			goto l5;
		}
		flag("endianness");
		followingWord3 = unsignedLongAt(followingWordAddress3);
		currentObject = (((((usqInt) followingWord3 ) >> (numSlotsFullShift())) == (numSlotsMask()))
			 ? followingWordAddress3 + BaseHeaderSize
			 : followingWordAddress3);
		l5:
		;
		/* end objectAfter:limit: */
	};
	/* end allPermSpaceObjectsDo: */
	/* end allHeapEntitiesDo: */
	/* end unmarkAllObjects */
}
/* 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)))) {
		int t0;
		int t1;

		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 l1;
	}
	if (valuePointer & (tagMask())) {
		goto l1;
	}
	if (!(anOop >= 0x20000000000LL)) {
		goto l1;
	}
	if (valuePointer >= 0x20000000000LL) {
		goto l1;
	}
	if ((valuePointer >= GIV(nilObj)) && (valuePointer <= GIV(trueObj))) {
		goto l1;
	}
	if (!(valuePointer >= (startOfObjectMemory(GIV(memoryMap))))) {
		goto l1;
	}
	remember(getFromPermToNewSpaceRememberedSet(), anOop);
	l1:
	;
	/* 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;
	sqInt fv;
	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;

	fieldValue = 0;
	fn = 0;
	/* 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;
		}
	}
	/* 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 l14;
			/* 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);
		l14:
		;
		/* 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 l1;
	}
	(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)));
	l1:
	;
	/* 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 nSlots1;
	sqInt nSlots2;
	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: */
	nSlots2 = numSlots * 2;
	obj4 = allocateSlotsForPinningInOldSpacebytesformatclassIndex(nSlots2, ((nSlots2 == 0)
		 ? 8 + BaseHeaderSize
		 : ((sqInt) (((usqInt) nSlots2 ) << (shiftForWord())) ) + (((nSlots2 >= (numSlotsMask()))
			 ? BaseHeaderSize + BaseHeaderSize
			 : BaseHeaderSize))), sixtyFourBitIndexableFormat(), sixtyFourBitLongsClassIndexPun());
	if (obj4) {
		/* begin fillObj:numSlots:with: */
		assert(oopisLessThan(((obj4 + BaseHeaderSize) + (nSlots2 * BytesPerOop)) - 1, addressAfter(obj4)));
		for (p3 = ((usqInt) (obj4 + BaseHeaderSize) ); p3 <= ((usqInt) (((obj4 + BaseHeaderSize) + (nSlots2 * BytesPerOop)) - 1) ); p3 += 8) {
			longAtput(p3, 0);
		};
		/* end fillObj:numSlots:with: */
	}
	newObj = obj4;
	/* end allocatePinnedSlots: */
	if (!newObj) {
		/* begin allocatePinnedSlots: */
		nSlots1 = numSlots + 1024;
		obj3 = allocateSlotsForPinningInOldSpacebytesformatclassIndex(nSlots1, ((nSlots1 == 0)
			 ? 8 + BaseHeaderSize
			 : ((sqInt) (((usqInt) nSlots1 ) << (shiftForWord())) ) + (((nSlots1 >= (numSlotsMask()))
				 ? BaseHeaderSize + BaseHeaderSize
				 : BaseHeaderSize))), sixtyFourBitIndexableFormat(), sixtyFourBitLongsClassIndexPun());
		if (obj3) {
			/* begin fillObj:numSlots:with: */
			assert(oopisLessThan(((obj3 + BaseHeaderSize) + (nSlots1 * BytesPerOop)) - 1, addressAfter(obj3)));
			for (p2 = ((usqInt) (obj3 + BaseHeaderSize) ); p2 <= ((usqInt) (((obj3 + BaseHeaderSize) + (nSlots1 * 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 = ((usqInt *) (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 (!(oopisGreaterThanOrEqualToandLessThan(obj, (GIV(memoryMap)->oldSpaceStart), (GIV(memoryMap)->oldSpaceEnd)))) {
		logWarn("Remembered Set is in an invalid position %p. Signal of a corrupted root table.", obj);
		if (shouldStartEmpty) {
			/* begin nilObject */
			obj = GIV(nilObj);
			/* end nilObject */
			logWarn("As it starts empty, we can ignore it");
		}
	}
	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 = ((usqInt *) (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 usqInt * NoDbgRegParms
rememberedSetArrayPointerFromObject(VMRememberedSet * self_in_rememberedSetArrayPointerFromObject, sqInt anOop)
{
	return ((usqInt *) (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 = ((usqInt *) (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
statAverageLivePagesWhenMapping(void)
{
	DECL_MAYBE_SQ_GLOBAL_STRUCT;

	return ((GIV(statNumMaps) == 0)
		 ? 0.0
		 : ((double) GIV(statPageCountWhenMappingSum) ) / GIV(statNumMaps));
}


static char _m[] = "";
void* vm_exports[][3] = {
	{(void*)_m, "callbackLeave", (void*)callbackLeave},
#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, "primitiveClockLogAddresses\000\377", (void*)primitiveClockLogAddresses},
	{(void*)_m, "primitiveCompareBytes\000\377", (void*)primitiveCompareBytes},
	{(void*)_m, "primitiveCrashVM\000\377", (void*)primitiveCrashVM},
	{(void*)_m, "primitiveDisablePowerManager\000\377", (void*)primitiveDisablePowerManager},
	{(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, "primitiveGetLogDirectory\000\377", (void*)primitiveGetLogDirectory},
	{(void*)_m, "primitiveGetWindowLabel\000\377", (void*)primitiveGetWindowLabel},
	{(void*)_m, "primitiveGetWindowSize\000\377", (void*)primitiveGetWindowSize},
	{(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, "primitiveIsWindowObscured\000\377", (void*)primitiveIsWindowObscured},
	{(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, "primitivePathToUsing\000\377", (void*)primitivePathToUsing},
	{(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, "primitiveScreenDepth\000\377", (void*)primitiveScreenDepth},
	{(void*)_m, "primitiveScreenScaleFactor\000\377", (void*)primitiveScreenScaleFactor},
	{(void*)_m, "primitiveSetGCSemaphore\000\377", (void*)primitiveSetGCSemaphore},
	{(void*)_m, "primitiveSetLogDirectory\000\377", (void*)primitiveSetLogDirectory},
	{(void*)_m, "primitiveSetWindowLabel\000\377", (void*)primitiveSetWindowLabel},
	{(void*)_m, "primitiveSetWindowSize\000\377", (void*)primitiveSetWindowSize},
	{(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, "reestablishContextPriorToCallback", (void*)reestablishContextPriorToCallback},
	{(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
}
