/* Automatically generated by
	MLVMCCodeGenerator Melchor-tonel.1 uuid: 4909ba91-6b01-0e00-8bf8-451809d8a11a
   from
	StackToRegisterMappingCogit VMMaker-tonel.1 uuid: fde3f291-6b01-0e00-8bfd-32e209d8a11a
 */
static char __buildInfo[] = "StackToRegisterMappingCogit VMMaker-tonel.1 uuid: fde3f291-6b01-0e00-8bfd-32e209d8a11a " __DATE__ ;
char *__cogitBuildInfo = __buildInfo;



#include <stddef.h>
#include <stdint.h>
#include <pthread.h>
#include "sq.h"
#include "jit/jit.h"
#include "debug.h"
#include "cogStackAlignment.h"
#include "dispdbg.h"
#include "cogmethod.h"
#include "vmMemoryMap.h"
#include "vmRememberedSet.h"
#include "cointerp.h"
#include "cogit.h"



/*** Constants ***/
#define AddCqR 102
#define AddCwR 110
#define AddOpcode 4
#define AddRdRd 121
#define AddRR 96
#define AL 14
#define AlignmentNops 3
#define AndCqR 104
#define AndCqRR 119
#define AndCwR 112
#define AndOpcode 0
#define AndRR 98
#define AnnotationShift 5
#define Arg0Reg 3
#define Arg1Reg 4
#define ArithmeticShiftRightCqR 87
#define ArithmeticShiftRightRR 88
#define BadRegisterSet 1
#define BytecodeSetHasDirectedSuperSend 1
#define CArg0Reg 0
#define CArg1Reg 1
#define CArg2Reg 2
#define CArg3Reg 3
#define Call 6
#define CallerSavedRegisterMask 0x18
#define CallFull 7
#define CC 3
#define CheckAllocationFillerAfterPrimCall 32
#if !defined(CheckRememberedInTrampoline) /* Allow this to be overridden on the compiler command line */
# define CheckRememberedInTrampoline 0
#endif /* !defined(CheckRememberedInTrampoline) */
#define ClassArray 7
#define ClassArrayCompactIndex 51
#define ClassFloatCompactIndex 34
#define ClassFullBlockClosureCompactIndex 38
#define ClassLargeNegativeIntegerCompactIndex 32
#define ClassLargePositiveIntegerCompactIndex 33
#define ClassMethodContextCompactIndex 36
#define ClassReg 22
#define ClosureIndex 4
#define CMFree 1
#define CMMaxUsageCount 7
#define CMMegamorphicIC 4
#define CMMethod 2
#define CMPMULOverflow 154
#define CMPolymorphicIC 3
#define CmpC32R 109
#define CmpCqR 101
#define CmpCwR 108
#define CmpRdRd 120
#define CmpRR 95
#define CompletePrimitive 4
#define ConcreteIPReg 16
#define ConcreteIPReg2 17
#define ConcreteVarBaseReg 24
#define ConstZero 1
#define ConvertRdRs 137
#define ConvertRRd 134
#define ConvertRsRd 136
#define CS 2
#define Debug DEBUGVM
#define DisplacementMask 0x1F
#define DisplacementX2N 0
#define DivRdRd 124
#define DPFPReg0 0
#define DPFPReg1 1
#define DPFPReg2 2
#define DupRVr 146
#define EncounteredUnknownBytecode -6
#define EQ 0
#define Extra0Reg 19
#define Extra1Reg 20
#define Extra2Reg 21
#define FaddSRvRvRv 150
#if !defined(FEATURE_JIT_SIMD) /* Allow this to be overridden on the compiler command line */
# define FEATURE_JIT_SIMD 1
#endif /* !defined(FEATURE_JIT_SIMD) */
#define Fill32 4
#define FirstAnnotation 64
#define FirstJump 12
#define FirstSpecialSelector 96
#define FoxCallerSavedIP 8
#define FoxMethod -8
#define FoxMFReceiver -24
#define FoxSavedFP 0
#define FoxThisContext -16
#define FPReg 29
#define FsubSRvRvRv 151
#define FullClosureCompiledBlockIndex 1
#define FullClosureFirstCopiedValueIndex 4
#define FullClosureNumArgsIndex 2
#define FullClosureOuterContextIndex 0
#define FullClosureReceiverIndex 3
#define GCModeBecome 8
#define GCModeFull 1
#define GCModeNewSpace 2
#define GE 10
#define GT 12
#define HasBytecodePC 5
#define HashMultiplyConstant 1664525
#define HashMultiplyMask 0xFFFFFFF
#define HeaderIndex 0
#define HI 8
#if !defined(IMMUTABILITY) /* Allow this to be overridden on the compiler command line */
# define IMMUTABILITY 1
#endif /* !defined(IMMUTABILITY) */
#define InFullBlock 2
#define InstanceSpecificationIndex 2
#define InstructionPointerIndex 1
#define InsufficientCodeSpace -2
#define IsAbsPCReference 3
#define IsAnnotationExtension 1
#define IsDirectedSuperBindingSend 10
#define IsDirectedSuperSend 9
#define IsDisplacementX2N 0
#define IsObjectReference 2
#define IsRelativeCall 4
#define IsSendCall 7
#define IsSuperSend 8
#define Jump 16
#define JumpAbove 31
#define JumpAboveOrEqual 30
#define JumpBelow 29
#define JumpBelowOrEqual 32
#define JumpCarry 23
#define JumpFPEqual 33
#define JumpFPGreater 37
#define JumpFPGreaterOrEqual 38
#define JumpFPLess 35
#define JumpFPLessOrEqual 36
#define JumpFPNotEqual 34
#define JumpFPOrdered 39
#define JumpFPUnordered 40
#define JumpFull 12
#define JumpGreater 27
#define JumpGreaterOrEqual 26
#define JumpLess 25
#define JumpLessOrEqual 28
#define JumpLong 13
#define JumpLongNonZero 15
#define JumpLongZero 14
#define JumpNegative 19
#define JumpNoCarry 24
#define JumpNonNegative 20
#define JumpNonZero 18
#define JumpNoOverflow 22
#define JumpOverflow 21
#define JumpR 10
#define JumpZero 17
#define Label 1
#define LargeContextSlots 62
#define LastJump 40
#define Ld1VrRMw 149
#define LE 13
#define LinkReg 30
#define Literal 2
#define LiteralStart 1
#define LoadEffectiveAddressMwrR 84
#define LogicalShiftLeftCqR 91
#define LogicalShiftLeftRR 92
#define LogicalShiftRightCqR 89
#define LogicalShiftRightRR 90
#define LR 30
#define LS 9
#define LT 11
#define MapEnd 0
#define MaxCompiledPrimitiveIndex 659
#define MaxCPICCases 6
#define MaxMethodSize 65535
#define MaxNegativeErrorCode -8
#define MaxNumArgs 15
#define MaxNumberOfAbstractOpcodes 0x8000
#define MaxStackCheckOffset 0xFFF
#define MaxX2NDisplacement 992
#define MethodCacheClass 2
#define MethodCacheMask 0xFFC
#define MethodCacheMethod 3
#define MethodCacheSelector 1
#define MethodIndex 3
#define MethodTooBig -4
#define MFMethodFlagHasContextFlag 1
#define MFMethodFlagIsBlockFlag 2
#define MI 4
#define MoveAbR 46
#define MoveAwR 42
#define MoveC32R 69
#define MoveCqR 67
#define MoveCwR 68
#define MoveM16rR 55
#define MoveM32rR 59
#define MoveM32rRs 76
#define MoveM64rRd 73
#define MoveMbrR 63
#define MoveMwrR 48
#define MovePatcheableC32R 83
#define MoveRAb 47
#define MoveRAw 44
#define MoveRdM64r 74
#define MoveRdR 71
#define MoveRdRd 72
#define MoveRM16r 56
#define MoveRM32r 60
#define MoveRM8r 54
#define MoveRMbr 64
#define MoveRMwr 49
#define MoveRR 41
#define MoveRRd 70
#define MoveRsM32r 77
#define MoveRX32rR 62
#define MoveRXbrR 66
#define MoveRXwrR 51
#define MoveX32rRR 61
#define MoveXbrRR 65
#define MoveXwrRR 50
#define MSUB 162
#define MUL 152
#define MulRdRd 123
#define NE 1
#define NeedsMergeFixupFlag 2
#define NeedsNonMergeFixupFlag 1
#define NegateR 85
#define Nop 5
#define NoReg -1
#define NumObjRefsInRuntime 0
#define NumSendTrampolines 4
#define NumSpecialSelectors 32
#define NumStoreTrampolines 5
#define NumTrampolines 74
#define OrCqR 105
#define OrCwR 113
#define OrOpcode 12
#define OrRR 99
#define PCReg 15
#define PL 5
#define PopR 78
#define PrefetchAw 82
#define PrimCallCollectsProfileSamples 16
#define PrimCallDoNotJIT 64
#define PrimCallMayCallBack 4
#define PrimCallNeedsNewMethod 1
#define PrimCallNeedsPrimitiveFunction 2
#define PrimCallOnSmalltalkStack 8
#define PrimErrNoMemory 9
#define PrimErrWritePastObject 17
#define PrimNumberHashMultiply 159
#define PushCq 80
#define PushCw 81
#define PushR 79
#define R0 0
#define R1 1
#define R12 12
#define ReceiverIndex 5
#define ReceiverResultReg 23
#define RetN 9
#define RISCTempReg 16
#define RotateLeftCqR 93
#define RotateRightCqR 94
#define SDIV 161
#define SelectorCannotInterpret 34
#define SelectorDoesNotUnderstand 20
#define SenderIndex 0
#define SendNumArgsReg 25
#define ShouldNotJIT -8
#define SignExtend16RR 141
#define SignExtend32RR 142
#define SignExtend8RR 140
#define SistaVM 0
#define SMULH 153
#define SmallContextSlots 22
#define SP 31
#define SPReg 28
#define SpecialSelectors 23
#define SqrtRd 125
#define SSBaseOffset 1
#define SSConstant 2
#define SSRegister 3
#define SSSpill 4
#define SSVectorRegister 18
#define St1VrRMw 147
#define StackPointerIndex 2
#define Stop 11
#define SubCqR 103
#define SubCwR 111
#define SubOpcode 2
#define SubRdRd 122
#define SubRR 97
#define TempReg 1
#define TempVectReadBarrier 0
#define TstCqR 106
#define UnfailingPrimitive 3
#define UnimplementedPrimitive -7
#define ValueIndex 1
#define VarBaseReg 24
#define VC 7
#define VReg0 0
#define VReg1 1
#define VReg2 2
#define VReg3 3
#define VReg4 4
#define VReg5 5
#define VReg6 6
#define VReg7 7
#define VS 6
#define XorCqR 107
#define XorCwR 114
#define XorOpcode 1
#define XorRdRd 126
#define XorRR 100
#define YoungSelectorInPIC -5
#define ZeroExtend16RR 144
#define ZeroExtend32RR 145
#define ZeroExtend8RR 143

typedef struct _AbstractInstruction {
	unsigned char	opcode;
	unsigned char	machineCodeSize;
	unsigned char	maxSize;
	unsigned char	annotation;
	unsigned char	conditionOrNil;
	unsigned int		machineCode [5];
	usqInt		operands [4];
	usqInt	address;
	struct _AbstractInstruction *dependent;
 } AbstractInstruction;

#define CogOutOfLineLiteralsARMv8Compiler AbstractInstruction
#define CogARMv8Compiler AbstractInstruction
#define CogAbstractInstruction AbstractInstruction


typedef struct _BytecodeDescriptor {
	sqInt (*generator )(void);
	sqInt NoDbgRegParms (*spanFunction )(struct _BytecodeDescriptor *,sqInt,sqInt,sqInt);
	sqInt NoDbgRegParms (*needsFrameFunction )(sqInt);
	signed char	stackDelta;
	unsigned char	opcode;
	unsigned char	numBytes;
	unsigned		isBranchTrue : 1;
	unsigned		isBranchFalse : 1;
	unsigned		isReturn : 1;
	unsigned		isMapped : 1;
	unsigned		isMappedInBlock : 1;
	unsigned		isExtension : 1;
	unsigned		isInstVarRef : 1;
	unsigned		is1ByteInstVarStore : 1;
	unsigned		hasUnsafeJump : 1;
 } BytecodeDescriptor;

#define CogBytecodeDescriptor BytecodeDescriptor


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

#define CogPrimitiveDescriptor PrimitiveDescriptor


typedef struct {
	AbstractInstruction *jmpToFallbackCode;
	AbstractInstruction *jmpSamplePrim;
	AbstractInstruction *continuePostSamplePrim;
	AbstractInstruction *jmpSampleNonPrim;
	AbstractInstruction *continuePostSampleNonPrim;
 } CogPrimitiveCallState;


typedef struct {
	char	type;
	char	spilled;
	signed char	liveRegister;
	signed char	registerr;
	sqInt	offset;
	sqInt	constant;
	sqInt	bcptr;
 } SimStackEntry;

#define CogSimStackEntry SimStackEntry


typedef struct {
	AbstractInstruction *targetInstruction;
	unsigned char	simStackPtr;
	char	isTargetOfBackwardBranch;
	unsigned short	instructionIndex;
	short	simNativeStackPtr;
	unsigned short	simNativeStackSize;
 } BytecodeFixup;

#define CogSSBytecodeFixup BytecodeFixup
#define CogBytecodeFixup BytecodeFixup


typedef struct {
	sqInt	isReceiverResultRegLive;
	CogSimStackEntry *ssEntry;
 } CogSSOptStatus;



/*** Function Prototypes ***/


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

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



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

static AbstractInstruction * NoDbgRegParms addDependent(AbstractInstruction * self_in_addDependent, AbstractInstruction *_anInstruction);
static sqInt NoDbgRegParms availableVectorRegisterOrNoneFor(AbstractInstruction * self_in_availableVectorRegisterOrNoneFor, sqInt _liveRegsMask);
static AbstractInstruction * NoDbgRegParms cloneLiteralFrom(AbstractInstruction * self_in_cloneLiteralFrom, AbstractInstruction *_existingLiteral);
static AbstractInstruction * NoDbgRegParms genMoveM32rR(AbstractInstruction * self_in_genMoveM32rR, sqInt _offset, sqInt _baseReg, sqInt _destReg);
static AbstractInstruction * NoDbgRegParms genWriteCResultIntoReg(AbstractInstruction * self_in_genWriteCResultIntoReg, sqInt _abstractRegister);
static AbstractInstruction * NoDbgRegParms initializeSharableLiteral(AbstractInstruction * self_in_initializeSharableLiteral, sqInt _literal);
static AbstractInstruction * NoDbgRegParms initializeUniqueLiteral(AbstractInstruction * self_in_initializeUniqueLiteral, sqInt _literal);
static sqInt NoDbgRegParms isJump(AbstractInstruction * self_in_isJump);
static sqInt NoDbgRegParms isWithinMwOffsetRange(AbstractInstruction * self_in_isWithinMwOffsetRange, sqInt anAddress);
static AbstractInstruction * NoDbgRegParms jmpTarget(AbstractInstruction * self_in_jmpTarget, AbstractInstruction *_anAbstractInstruction);
static sqInt NoDbgRegParms literal32BeforeFollowingAddress(AbstractInstruction * self_in_literal32BeforeFollowingAddress, sqInt _followingAddress);
static AbstractInstruction * NoDbgRegParms relocateJumpLongBeforeFollowingAddressby(AbstractInstruction * self_in_relocateJumpLongBeforeFollowingAddressby, sqInt _pc, sqInt _delta);
static AbstractInstruction * NoDbgRegParms relocateJumpLongConditionalBeforeFollowingAddressby(AbstractInstruction * self_in_relocateJumpLongConditionalBeforeFollowingAddressby, sqInt _pc, sqInt _delta);
static AbstractInstruction * NoDbgRegParms resolveJumpTarget(AbstractInstruction * self_in_resolveJumpTarget);
static sqInt NoDbgRegParms addSizesourceRegistershiftimmediate12destinationRegister(AbstractInstruction * self_in_addSizesourceRegistershiftimmediate12destinationRegister, sqInt _is64Bits, sqInt _sourceRegister, sqInt _shift, sqInt _immediate12bitValue, sqInt _destinationRegister);
static sqInt NoDbgRegParms addsExtendedSizeleftRegisterMaybeSPshiftedRightRegisteroptionshiftOffsetdestinationRegister(AbstractInstruction * self_in_addsExtendedSizeleftRegisterMaybeSPshiftedRightRegisteroptionshiftOffsetdestinationRegister, sqInt _is64Bits, sqInt _leftRegister, sqInt _rightRegister, sqInt _option, sqInt _immediate3bitValue, sqInt _destinationRegister);
static sqInt NoDbgRegParms addsSizeleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister(AbstractInstruction * self_in_addsSizeleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister, sqInt _is64Bits, sqInt _leftRegister, sqInt _rightRegister, sqInt _shiftType, sqInt _immediate6bitValue, sqInt _destinationRegister);
static sqInt NoDbgRegParms addsSizesourceRegisterimmediate12BitValueshifteddestinationRegister(AbstractInstruction * self_in_addsSizesourceRegisterimmediate12BitValueshifteddestinationRegister, sqInt _is64Bits, sqInt _leftRegister, sqInt _immediate12BitValue, sqInt _shiftedFlag, sqInt _destinationRegister);
static sqInt NoDbgRegParms addTqterm1term2dest(AbstractInstruction * self_in_addTqterm1term2dest, sqInt _t, sqInt _q, sqInt _vectorReg1, sqInt _vectorReg2, sqInt _vectorRegSum);
static sqInt NoDbgRegParms addrnimmror(AbstractInstruction * self_in_addrnimmror, sqInt _destReg, sqInt _srcReg, sqInt _immediate, sqInt _rot);
static sqInt NoDbgRegParms adrSignedImmediate21BitsValuedestinationRegister(AbstractInstruction * self_in_adrSignedImmediate21BitsValuedestinationRegister, sqInt _signedImmediate21bitValue, sqInt _destinationRegister);
static sqInt NoDbgRegParms andSetFlagsSizeimmediate13bitValuesourceRegisterdestinationRegister(AbstractInstruction * self_in_andSetFlagsSizeimmediate13bitValuesourceRegisterdestinationRegister, sqInt _is64Bits, sqInt _logicalEncodedImmediate13BitValue, sqInt _sourceRegister, sqInt _destinationRegister);
static sqInt NoDbgRegParms andSetFlagsSizeshiftedRegistershiftTypeshiftValuewithRegisterdestinationRegister(AbstractInstruction * self_in_andSetFlagsSizeshiftedRegistershiftTypeshiftValuewithRegisterdestinationRegister, sqInt _is64Bits, sqInt _shiftedRegister, sqInt _shiftType, sqInt _immediate6bitValue, sqInt _sourceRegister2, sqInt _destinationRegister);
static sqInt NoDbgRegParms arithmeticImmediateSizeisSubstractionsetFlagssourceRegisterimmediate12BitValueshifteddestinationRegister(AbstractInstruction * self_in_arithmeticImmediateSizeisSubstractionsetFlagssourceRegisterimmediate12BitValueshifteddestinationRegister, sqInt _is64Bits, sqInt _substractionFlag, sqInt _setFlagsFlag, sqInt _sourceRegister, sqInt _immediate12BitValue, sqInt _shiftedFlag, sqInt _destinationRegister);
static sqInt NoDbgRegParms arithmeticShiftedRegisterSizeisSubstractionsetFlagsleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister(AbstractInstruction * self_in_arithmeticShiftedRegisterSizeisSubstractionsetFlagsleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister, sqInt _is64Bits, sqInt _substractionFlag, sqInt _setFlagsFlag, sqInt _leftRegister, sqInt _rightRegister, sqInt _shiftType, sqInt _immediate6bitValue, sqInt _destinationRegister);
static sqInt NoDbgRegParms arithmeticShiftRightSizesourceRegistershiftRegisterdestinationRegister(AbstractInstruction * self_in_arithmeticShiftRightSizesourceRegistershiftRegisterdestinationRegister, sqInt _is64bits, sqInt _sourceRegister, sqInt _shiftRegister, sqInt _destinationRegister);
static sqInt NoDbgRegParms arithmeticShiftRightSizesourceRegistershiftValuedestinationRegister(AbstractInstruction * self_in_arithmeticShiftRightSizesourceRegistershiftValuedestinationRegister, sqInt _is64Bits, sqInt _sourceRegister, sqInt _shiftValue, sqInt _destinationRegister);
static usqInt NoDbgRegParms assembleSubCqR(AbstractInstruction * self_in_assembleSubCqR, sqInt _quickValue, sqInt registerToUse);
static sqInt NoDbgRegParms availableRegisterOrNoneFor(AbstractInstruction * self_in_availableRegisterOrNoneFor, sqInt _liveRegsMask);
static sqInt NoDbgRegParms blr(AbstractInstruction * self_in_blr, sqInt _registerToUse);
static sqInt NoDbgRegParms bl(AbstractInstruction * self_in_bl, sqInt _immediate26bitValue);
static sqInt NoDbgRegParms branchConditionoffset(AbstractInstruction * self_in_branchConditionoffset, sqInt _condition, sqInt _immediate19bitValue);
static sqInt NoDbgRegParms br(AbstractInstruction * self_in_br, sqInt _registerToUse);
static sqInt NoDbgRegParms brwithLink(AbstractInstruction * self_in_brwithLink, sqInt _registerToUse, sqInt _withLink);
static sqInt NoDbgRegParms b(AbstractInstruction * self_in_b, sqInt _immediate26bitValue);
static sqInt NoDbgRegParms bwithLink(AbstractInstruction * self_in_bwithLink, sqInt _immediate26bitValue, sqInt _aBoolean);
static sqInt NoDbgRegParms callInstructionByteSize(AbstractInstruction * self_in_callInstructionByteSize);
static sqInt NoDbgRegParms callTargetFromReturnAddress(AbstractInstruction * self_in_callTargetFromReturnAddress, sqInt _callSiteReturnAddress);
static sqInt NoDbgRegParms cmnSizeimmediate12BitValueshiftFlagregister(AbstractInstruction * self_in_cmnSizeimmediate12BitValueshiftFlagregister, sqInt _is64bits, sqInt _immediate12BitValue, sqInt _shiftFlag, sqInt _registerToUse);
static sqInt NoDbgRegParms cmpSizeimmediate12BitValueshiftFlagregister(AbstractInstruction * self_in_cmpSizeimmediate12BitValueshiftFlagregister, sqInt _is64bits, sqInt _immediate12BitValue, sqInt _shiftFlag, sqInt _registerToUse);
static sqInt NoDbgRegParms cmpSizeshiftedRegistershiftTypeshiftValuesecondRegister(AbstractInstruction * self_in_cmpSizeshiftedRegistershiftTypeshiftValuesecondRegister, sqInt _is64bits, sqInt _register1, sqInt _shiftType, sqInt _immediate6BitShiftValue, sqInt _register2);
static sqInt NoDbgRegParms computeMaximumSize(AbstractInstruction * self_in_computeMaximumSize);
static usqInt NoDbgRegParms concretizeAddCwR(AbstractInstruction * self_in_concretizeAddCwR);
static usqInt NoDbgRegParms concretizeAddRR(AbstractInstruction * self_in_concretizeAddRR);
static usqInt NoDbgRegParms concretizeAndRR(AbstractInstruction * self_in_concretizeAndRR);
static usqInt NoDbgRegParms concretizeArithmeticShiftRightRR(AbstractInstruction * self_in_concretizeArithmeticShiftRightRR);
static sqInt NoDbgRegParms concretizeAt(AbstractInstruction * self_in_concretizeAt, sqInt _actualAddress);
static usqInt NoDbgRegParms concretizeCMPMULOverflow(AbstractInstruction * self_in_concretizeCMPMULOverflow);
static usqInt NoDbgRegParms concretizeCmpCwR(AbstractInstruction * self_in_concretizeCmpCwR);
static sqInt NoDbgRegParms concretizeDataOperationCwR(AbstractInstruction * self_in_concretizeDataOperationCwR, sqInt armOpcode);
static usqInt NoDbgRegParms concretizeFill32(AbstractInstruction * self_in_concretizeFill32);
static sqInt NoDbgRegParms concretizeInvertibleDataOperationCqR(AbstractInstruction * self_in_concretizeInvertibleDataOperationCqR, sqInt armOpcode);
static usqInt NoDbgRegParms concretizeJumpLong(AbstractInstruction * self_in_concretizeJumpLong);
static sqInt NoDbgRegParms concretizeJumpLongNonZero(AbstractInstruction * self_in_concretizeJumpLongNonZero);
static usqInt NoDbgRegParms concretizeJumpLongZero(AbstractInstruction * self_in_concretizeJumpLongZero);
static usqInt NoDbgRegParms concretizeLogicalShiftLeftRR(AbstractInstruction * self_in_concretizeLogicalShiftLeftRR);
static sqInt NoDbgRegParms concretizeLogicalShiftRightRR(AbstractInstruction * self_in_concretizeLogicalShiftRightRR);
static usqInt NoDbgRegParms concretizeMUL(AbstractInstruction * self_in_concretizeMUL);
static usqInt NoDbgRegParms concretizeOrRR(AbstractInstruction * self_in_concretizeOrRR);
static usqInt NoDbgRegParms concretizeSMULH(AbstractInstruction * self_in_concretizeSMULH);
static usqInt NoDbgRegParms concretizeSubRR(AbstractInstruction * self_in_concretizeSubRR);
static usqInt NoDbgRegParms concretizeXorCwR(AbstractInstruction * self_in_concretizeXorCwR);
static usqInt NoDbgRegParms concretizeXorRR(AbstractInstruction * self_in_concretizeXorRR);
static sqInt NoDbgRegParms conditionIsNotNever(AbstractInstruction * self_in_conditionIsNotNever, sqInt _instr);
static sqInt NoDbgRegParms cStackPointer(AbstractInstruction * self_in_cStackPointer);
static void NoDbgRegParms dispatchConcretize(AbstractInstruction * self_in_dispatchConcretize);
static sqInt NoDbgRegParms dupTqsourcedest(AbstractInstruction * self_in_dupTqsourcedest, sqInt _t, sqInt _q, sqInt _src, sqInt _dest);
static sqInt NoDbgRegParms exclusiveOrSizefirstRegistersecondRegisterdestinationRegister(AbstractInstruction * self_in_exclusiveOrSizefirstRegistersecondRegisterdestinationRegister, sqInt _is64Bits, sqInt _firstRegister, sqInt _secondRegister, sqInt _destinationRegister);
static sqInt NoDbgRegParms extractConditionFromB(AbstractInstruction * self_in_extractConditionFromB, sqInt _instruction);
static sqInt NoDbgRegParms extractOffsetFromConditionalBranch(AbstractInstruction * self_in_extractOffsetFromConditionalBranch, sqInt _instruction);
static sqInt NoDbgRegParms faddSizefirstSourceRegistersecondSourceRegisterdestinationRegister(AbstractInstruction * self_in_faddSizefirstSourceRegistersecondSourceRegisterdestinationRegister, sqInt _precision, sqInt _registerA, sqInt _registerB, sqInt _destinationRegister);
static sqInt NoDbgRegParms fConvertSourceRegistertoRegistersourcePrecisiontoPrecision(AbstractInstruction * self_in_fConvertSourceRegistertoRegistersourcePrecisiontoPrecision, sqInt _sourceRegister, sqInt _destRegister, sqInt _ftype, sqInt _opc);
static sqInt NoDbgRegParms fcmpFTypeleftRegisterrightRegister(AbstractInstruction * self_in_fcmpFTypeleftRegisterrightRegister, sqInt _ftype, sqInt _firstRegister, sqInt _secondRegister);
static sqInt NoDbgRegParms fDivFirstRegistersecondRegisterdestinationRegister(AbstractInstruction * self_in_fDivFirstRegistersecondRegisterdestinationRegister, sqInt _registerA, sqInt _registerB, sqInt _destinationRegister);
static sqInt NoDbgRegParms fEorFirstRegistersecondRegisterdestinationRegister(AbstractInstruction * self_in_fEorFirstRegistersecondRegisterdestinationRegister, sqInt _registerA, sqInt _registerB, sqInt _destinationRegister);
static sqInt NoDbgRegParms fMoveSizefromDoublePrecisionFloatRegistertoScalarRegister(AbstractInstruction * self_in_fMoveSizefromDoublePrecisionFloatRegistertoScalarRegister, sqInt _is64Bits, sqInt _sourceDoublePrecisionFloatRegister, sqInt _destinationScalarRegister);
static sqInt NoDbgRegParms fMoveSizefromScalarRegistertoDoublePrecisionFloatRegister(AbstractInstruction * self_in_fMoveSizefromScalarRegistertoDoublePrecisionFloatRegister, sqInt _is64Bits, sqInt _sourceScalarRegister, sqInt _destinationDoublePrecisionFloatRegister);
static sqInt NoDbgRegParms fMoveSizefromScalarToDoublePrecisionsourceRegisterdestinationRegister(AbstractInstruction * self_in_fMoveSizefromScalarToDoublePrecisionsourceRegisterdestinationRegister, sqInt _is64Bits, sqInt _fromScalarToDoublePrecision, sqInt _sourceRegister, sqInt _destinationRegister);
static sqInt NoDbgRegParms fMulFirstRegistersecondRegisterdestinationRegister(AbstractInstruction * self_in_fMulFirstRegistersecondRegisterdestinationRegister, sqInt _registerA, sqInt _registerB, sqInt _destinationRegister);
static sqInt NoDbgRegParms fSqrtddestinationRegister(AbstractInstruction * self_in_fSqrtddestinationRegister, sqInt _sourceRegister, sqInt _destinationRegister);
static sqInt NoDbgRegParms fSubFirstRegistersecondRegisterdestinationRegister(AbstractInstruction * self_in_fSubFirstRegistersecondRegisterdestinationRegister, sqInt _registerA, sqInt _registerB, sqInt _destinationRegister);
static AbstractInstruction * NoDbgRegParms genCaptureCStackPointers(AbstractInstruction * self_in_genCaptureCStackPointers, sqInt _captureFramePointer);
static AbstractInstruction * NoDbgRegParms genDivRRQuoRem(AbstractInstruction * self_in_genDivRRQuoRem, sqInt _abstractRegDenominator, sqInt _abstractRegNumerator, sqInt _abstractRegQuotient, sqInt _abstractRegRemainder);
static sqInt NoDbgRegParms genLoadCStackPointer(AbstractInstruction * self_in_genLoadCStackPointer);
static sqInt NoDbgRegParms genLoadCStackPointers(AbstractInstruction * self_in_genLoadCStackPointers);
static sqInt NoDbgRegParms genLoadStackPointers(AbstractInstruction * self_in_genLoadStackPointers);
static AbstractInstruction * NoDbgRegParms genMulRR(AbstractInstruction * self_in_genMulRR, sqInt _regSource, sqInt _regDest);
static AbstractInstruction * NoDbgRegParms genPushRegisterArgsForAbortMissNumArgs(AbstractInstruction * self_in_genPushRegisterArgsForAbortMissNumArgs, sqInt _numArgs);
static AbstractInstruction * NoDbgRegParms genPushRegisterArgsForNumArgsscratchReg(AbstractInstruction * self_in_genPushRegisterArgsForNumArgsscratchReg, sqInt _numArgs, sqInt ignored);
static sqInt NoDbgRegParms genSaveStackPointers(AbstractInstruction * self_in_genSaveStackPointers);
static sqInt NoDbgRegParms inclusiveOrSizefirstRegistersecondRegisterdestinationRegister(AbstractInstruction * self_in_inclusiveOrSizefirstRegistersecondRegisterdestinationRegister, sqInt _is64Bits, sqInt _firstRegister, sqInt _secondRegister, sqInt _destinationRegister);
static uint32_t NoDbgRegParms instructionBeforeAddress(AbstractInstruction * self_in_instructionBeforeAddress, sqInt _followingAddress);
static sqInt NoDbgRegParms instructionIsBLX(AbstractInstruction * self_in_instructionIsBLX, sqInt _instr);
static sqInt NoDbgRegParms instructionIsBL(AbstractInstruction * self_in_instructionIsBL, sqInt _instr);
static sqInt NoDbgRegParms instructionIsB(AbstractInstruction * self_in_instructionIsB, sqInt _instr);
static sqInt NoDbgRegParms instructionIsConditionalBranch(AbstractInstruction * self_in_instructionIsConditionalBranch, sqInt _instruction);
static sqInt NoDbgRegParms instructionIsLDR(AbstractInstruction * self_in_instructionIsLDR, sqInt _instr);
static sqInt NoDbgRegParms instructionIsPush(AbstractInstruction * self_in_instructionIsPush, uint32_t _instr);
static sqInt NoDbgRegParms is64bitMask64(AbstractInstruction * self_in_is64bitMask64, sqInt _aMask);
static sqInt NoDbgRegParms isCallPrecedingReturnPC(AbstractInstruction * self_in_isCallPrecedingReturnPC, sqInt _mcpc);
static sqInt NoDbgRegParms isInImmediateJumpRange(AbstractInstruction * self_in_isInImmediateJumpRange, usqIntptr_t _operand);
static sqInt NoDbgRegParms isPCRelativeValueLoad(AbstractInstruction * self_in_isPCRelativeValueLoad, unsigned int _instr);
static sqInt NoDbgRegParms isShiftable16bitImmediate(AbstractInstruction * self_in_isShiftable16bitImmediate, sqInt _constant);
static sqInt NoDbgRegParms isShiftedMask(AbstractInstruction * self_in_isShiftedMask, sqInt _aMask);
static sqInt NoDbgRegParms jumpLongByteSize(AbstractInstruction * self_in_jumpLongByteSize);
static sqInt NoDbgRegParms jumpLongConditionalByteSize(AbstractInstruction * self_in_jumpLongConditionalByteSize);
static sqInt NoDbgRegParms jumpLongTargetBeforeFollowingAddress(AbstractInstruction * self_in_jumpLongTargetBeforeFollowingAddress, sqInt _mcpc);
static sqInt NoDbgRegParms ld1QOpCodeSRnRt(AbstractInstruction * self_in_ld1QOpCodeSRnRt, sqInt _q, sqInt _opCode, sqInt _size, sqInt _rn, sqInt _rt);
static sqInt NoDbgRegParms ld1QRmOpCodeSRnRt(AbstractInstruction * self_in_ld1QRmOpCodeSRnRt, sqInt _q, sqInt _rm, sqInt _opCode, sqInt _size, sqInt _rn, sqInt _rt);
static sqInt NoDbgRegParms ldrbSourceRegisterdestinationRegister(AbstractInstruction * self_in_ldrbSourceRegisterdestinationRegister, sqInt _sourceRegister, sqInt _destinationRegister);
static sqInt NoDbgRegParms ldrbSourceRegisterdestinationRegisteroffset(AbstractInstruction * self_in_ldrbSourceRegisterdestinationRegisteroffset, sqInt _sourceRegister, sqInt _destinationRegister, sqInt _immediate12BitValue);
static sqInt NoDbgRegParms ldrbSourceRegisteroffsetRegisterdestinationRegister(AbstractInstruction * self_in_ldrbSourceRegisteroffsetRegisterdestinationRegister, sqInt _sourceRegister, sqInt _offsetRegister, sqInt _destinationRegister);
static sqInt NoDbgRegParms ldrhBaseRegisteroffsetDividedBy2destinationRegister(AbstractInstruction * self_in_ldrhBaseRegisteroffsetDividedBy2destinationRegister, sqInt _baseRegister, sqInt _offset12Bits, sqInt _destinationRegister);
static sqInt NoDbgRegParms ldrSizebaseRegistersignedOffsetdestinationRegisterpreIndex(AbstractInstruction * self_in_ldrSizebaseRegistersignedOffsetdestinationRegisterpreIndex, sqInt _is64Bits, sqInt _baseReg, sqInt _immediate9bitValue, sqInt _destinationRegister, sqInt _preIndex);
static sqInt NoDbgRegParms ldrSizebaseRegisterunsignedOffsetdestinationFloatingPointRegisteris128BitVariant(AbstractInstruction * self_in_ldrSizebaseRegisterunsignedOffsetdestinationFloatingPointRegisteris128BitVariant, sqInt _size, sqInt _baseReg, sqInt _immediate12bitValue, sqInt _destinationRegister, sqInt _is128BitVariant);
static sqInt NoDbgRegParms ldrSizebaseRegisterunsignedOffsetdestinationRegister(AbstractInstruction * self_in_ldrSizebaseRegisterunsignedOffsetdestinationRegister, sqInt _is64Bits, sqInt _baseReg, sqInt _immediate12bitValue, sqInt _destinationRegister);
static sqInt NoDbgRegParms ldrSizeindexRegisterbaseRegisterdestinationRegister(AbstractInstruction * self_in_ldrSizeindexRegisterbaseRegisterdestinationRegister, sqInt _is64Bits, sqInt _indexRegister, sqInt _baseRegister, sqInt _destinationRegister);
static sqInt NoDbgRegParms ldrSizeindexRegisteroptionscalebaseRegisterdestinationRegister(AbstractInstruction * self_in_ldrSizeindexRegisteroptionscalebaseRegisterdestinationRegister, sqInt _is64Bits, sqInt _indexRegister, sqInt _extendShiftOption, sqInt _isScaled, sqInt _baseRegister, sqInt _destinationRegister);
static sqInt NoDbgRegParms ldrSizeprogramCounterRelativeOffsetdestinationRegister(AbstractInstruction * self_in_ldrSizeprogramCounterRelativeOffsetdestinationRegister, sqInt _is64Bits, sqInt _immediate19bitValue, sqInt _destinationRegister);
static sqInt NoDbgRegParms ldurbSizebaseRegistersignedOffsetdestinationRegister(AbstractInstruction * self_in_ldurbSizebaseRegistersignedOffsetdestinationRegister, sqInt is64Bits, sqInt _baseRegister, sqInt _immediate9bitTwoComplementOffset, sqInt _destinationRegister);
static sqInt NoDbgRegParms ldurSizebaseRegistersignedOffsetdestinationRegister(AbstractInstruction * self_in_ldurSizebaseRegistersignedOffsetdestinationRegister, sqInt _is64Bits, sqInt _baseReg, sqInt _immediate9bitValue, sqInt _destinationRegister);
static sqInt NoDbgRegParms leadingOnesOf(AbstractInstruction * self_in_leadingOnesOf, sqInt _aNumber);
static sqInt NoDbgRegParms leadingZerosOf(AbstractInstruction * self_in_leadingZerosOf, sqInt _aNumber);
static sqInt NoDbgRegParms literalBeforeInlineCacheTagAt(AbstractInstruction * self_in_literalBeforeInlineCacheTagAt, sqInt callSiteReturnAddress);
static usqInt NoDbgRegParms loadCwInto(AbstractInstruction * self_in_loadCwInto, sqInt _destReg);
static sqInt NoDbgRegParms loadPICLiteralByteSize(AbstractInstruction * self_in_loadPICLiteralByteSize);
static sqInt NoDbgRegParms logicalImmediateopcodeimmediate13bitValuesourceRegisterdestinationRegister(AbstractInstruction * self_in_logicalImmediateopcodeimmediate13bitValuesourceRegisterdestinationRegister, sqInt _is64Bits, sqInt _instructionOpcode, sqInt _logicalEncodedImmediate13BitValue, sqInt _sourceRegister, sqInt _destinationRegister);
static sqInt NoDbgRegParms logicalShiftedRegisterSizeopcodefirstRegistershiftedRegistershiftOptionshiftValuenegateddestinationRegister(AbstractInstruction * self_in_logicalShiftedRegisterSizeopcodefirstRegistershiftedRegistershiftOptionshiftValuenegateddestinationRegister, sqInt _is64Bits, sqInt _logicalOpcode, sqInt _firstRegister, sqInt _shiftedRegister, sqInt _shiftOption, sqInt _immediate6BitsValue, sqInt _negatedFlag, sqInt _destinationRegister);
static sqInt NoDbgRegParms logicalShiftLeftSizesourceRegistershiftRegisterdestinationRegister(AbstractInstruction * self_in_logicalShiftLeftSizesourceRegistershiftRegisterdestinationRegister, sqInt _is64bits, sqInt _sourceRegister, sqInt _shiftRegister, sqInt _destinationRegister);
static sqInt NoDbgRegParms logicalShiftLeftSizesourceRegistershiftValuedestinationRegister(AbstractInstruction * self_in_logicalShiftLeftSizesourceRegistershiftValuedestinationRegister, sqInt _is64Bits, sqInt _sourceRegister, sqInt _shiftValue, sqInt _destinationRegister);
static sqInt NoDbgRegParms logicalShiftRightSizesourceRegistershiftValuedestinationRegister(AbstractInstruction * self_in_logicalShiftRightSizesourceRegistershiftValuedestinationRegister, sqInt _is64Bits, sqInt _sourceRegister, sqInt _shiftValue, sqInt _destinationRegister);
static sqInt NoDbgRegParms movSizedestinationRegisterimmshift(AbstractInstruction * self_in_movSizedestinationRegisterimmshift, sqInt _is64Bits, sqInt _destinationRegister, sqInt _immediate16bitValue, sqInt _shift);
static sqInt NoDbgRegParms movSizedestinationRegisternegatedImmshift(AbstractInstruction * self_in_movSizedestinationRegisternegatedImmshift, sqInt _is64Bits, sqInt _destinationRegister, sqInt _immediate16bitValue, sqInt _shift);
static sqInt NoDbgRegParms movSizesourceRegisterMaybeSPdestinationRegisterMaybeSP(AbstractInstruction * self_in_movSizesourceRegisterMaybeSPdestinationRegisterMaybeSP, sqInt _is64Bits, sqInt _sourceRegister, sqInt _destinationRegister);
static sqInt NoDbgRegParms movSizesourceRegisterdestinationRegister(AbstractInstruction * self_in_movSizesourceRegisterdestinationRegister, sqInt _is64Bits, sqInt _sourceRegister, sqInt _destinationRegister);
static sqInt NoDbgRegParms movToFromSPrn(AbstractInstruction * self_in_movToFromSPrn, sqInt _destinationRegister, sqInt _sourceRegister);
static sqInt NoDbgRegParms movrn(AbstractInstruction * self_in_movrn, sqInt _destReg, sqInt _srcReg);
static sqInt NoDbgRegParms msubSizeminuendRegfactor1Regfactor2RegdestinationRegister(AbstractInstruction * self_in_msubSizeminuendRegfactor1Regfactor2RegdestinationRegister, sqInt _is64Bits, sqInt _minuendReg, sqInt _factor1Reg, sqInt _factor2Reg, sqInt _destinationReg);
static sqInt NoDbgRegParms mulSizefirstRegistersecondRegisterdestinationRegister(AbstractInstruction * self_in_mulSizefirstRegistersecondRegisterdestinationRegister, sqInt _is64bits, sqInt _registerA, sqInt _registerB, sqInt _destinationRegister);
static sqInt NoDbgRegParms negateSizesourceRegistersourceRegisterShiftTypesourceRegisterShiftdestinationRegister(AbstractInstruction * self_in_negateSizesourceRegistersourceRegisterShiftTypesourceRegisterShiftdestinationRegister, sqInt _is64Bits, sqInt _sourceRegister, sqInt _immediate2bitShiftType, sqInt _immediate6bitsShiftValue, sqInt _destinationRegister);
static sqInt NoDbgRegParms nop(AbstractInstruction * self_in_nop);
static sqInt NoDbgRegParms numIntRegArgs(AbstractInstruction * self_in_numIntRegArgs);
static sqInt NoDbgRegParms orSizeimmediate13bitValuesourceRegisterdestinationRegister(AbstractInstruction * self_in_orSizeimmediate13bitValuesourceRegisterdestinationRegister, sqInt _is64Bits, sqInt _logicalEncodedImmediate13BitValue, sqInt _sourceRegister, sqInt _destinationRegister);
static sqInt NoDbgRegParms orSizeshiftedRegistershiftTypeshiftValuewithRegisterdestinationRegister(AbstractInstruction * self_in_orSizeshiftedRegistershiftTypeshiftValuewithRegisterdestinationRegister, sqInt _is64Bits, sqInt _shiftedRegister, sqInt _shiftType, sqInt _immediate6bitValue, sqInt _sourceRegister2, sqInt _destinationRegister);
static AbstractInstruction * NoDbgRegParms padIfPossibleWithStopsFromto(AbstractInstruction * self_in_padIfPossibleWithStopsFromto, sqInt _startAddr, sqInt _endAddr);
static sqInt NoDbgRegParms popR(AbstractInstruction * self_in_popR, sqInt _dstReg);
static sqInt NoDbgRegParms prefetchMemorysourceRegisteroffset(AbstractInstruction * self_in_prefetchMemorysourceRegisteroffset, sqInt _prefetchOperationFlags, sqInt _sourceRegister, sqInt _offset);
static AbstractInstruction * NoDbgRegParms prepareStackToCallCFunctionInSmalltalkStack(AbstractInstruction * self_in_prepareStackToCallCFunctionInSmalltalkStack, sqInt anObject);
static sqInt NoDbgRegParms pushLinkRegisterByteSize(AbstractInstruction * self_in_pushLinkRegisterByteSize);
static sqInt NoDbgRegParms pushR(AbstractInstruction * self_in_pushR, sqInt _srcReg);
static AbstractInstruction * NoDbgRegParms relocateCallBeforeReturnPCby(AbstractInstruction * self_in_relocateCallBeforeReturnPCby, sqInt _retpc, sqInt _delta);
static sqInt NoDbgRegParms ret(AbstractInstruction * self_in_ret);
static AbstractInstruction * NoDbgRegParms returnFromCallCFunctionInSmalltalkStack(AbstractInstruction * self_in_returnFromCallCFunctionInSmalltalkStack, sqInt anObject);
static sqInt NoDbgRegParms rewriteCallAttarget(AbstractInstruction * self_in_rewriteCallAttarget, usqInt _callSiteReturnAddress, usqInt _callTargetAddress);
static sqInt NoDbgRegParms rewriteCPICJumpAttarget(AbstractInstruction * self_in_rewriteCPICJumpAttarget, usqInt _callSiteReturnAddress, usqInt _callTargetAddress);
static sqInt NoDbgRegParms rewriteJumpLongAttarget(AbstractInstruction * self_in_rewriteJumpLongAttarget, usqInt _callSiteReturnAddress, usqInt _callTargetAddress);
static sqInt NoDbgRegParms rewriteTransferAttarget(AbstractInstruction * self_in_rewriteTransferAttarget, usqInt _callSiteReturnAddress, usqInt _callTargetAddress);
static sqInt NoDbgRegParms rorSizesourceRegisterrotationBitsdestinationRegister(AbstractInstruction * self_in_rorSizesourceRegisterrotationBitsdestinationRegister, sqInt _is64bits, sqInt _sourceRegister, sqInt _immediate6bitValue, sqInt _destinationRegister);
static sqInt NoDbgRegParms scalarConvertSizefromScalarRegistertoDoublePrecisionFloatRegister(AbstractInstruction * self_in_scalarConvertSizefromScalarRegistertoDoublePrecisionFloatRegister, sqInt _is64Bits, sqInt _scalarRegister, sqInt _doublePrecisionFloatingPointRegister);
static sqInt NoDbgRegParms sdivSizenumeratorRegdenominatorRegdestinationRegister(AbstractInstruction * self_in_sdivSizenumeratorRegdenominatorRegdestinationRegister, sqInt _is64Bits, sqInt _numeratorReg, sqInt _denominatorReg, sqInt _destinationReg);
static sqInt NoDbgRegParms setsConditionCodesFor(AbstractInstruction * self_in_setsConditionCodesFor, sqInt aConditionalJumpOpcode);
static sqInt NoDbgRegParms sizeOfregisterSize(AbstractInstruction * self_in_sizeOfregisterSize, sqInt _immediate, sqInt _registerSize);
static sqInt NoDbgRegParms smulhSizefirstRegistersecondRegisterdestinationRegister(AbstractInstruction * self_in_smulhSizefirstRegistersecondRegisterdestinationRegister, sqInt is64bits, sqInt _registerA, sqInt _registerB, sqInt _destinationRegister);
static sqInt NoDbgRegParms st1QOpCodeSRnRt(AbstractInstruction * self_in_st1QOpCodeSRnRt, sqInt _q, sqInt _opCode, sqInt _size, sqInt _rn, sqInt _rt);
static sqInt NoDbgRegParms st1QRmOpCodeSRnRt(AbstractInstruction * self_in_st1QRmOpCodeSRnRt, sqInt _q, sqInt _rm, sqInt _opCode, sqInt _size, sqInt _rn, sqInt _rt);
static sqInt NoDbgRegParms stop(AbstractInstruction * self_in_stop);
static AbstractInstruction * NoDbgRegParms stopsFromto(AbstractInstruction * self_in_stopsFromto, sqInt _startAddr, sqInt _endAddr);
static sqInt NoDbgRegParms strBaseRegisterpositiveOffsetsourceFloatingPointRegisterprecision(AbstractInstruction * self_in_strBaseRegisterpositiveOffsetsourceFloatingPointRegisterprecision, sqInt _baseReg, sqInt _immediate12bitValue, sqInt _sourceRegister, sqInt _size);
static sqInt NoDbgRegParms strbBaseRegisteroffsetRegisterextensionshiftsrcRegister(AbstractInstruction * self_in_strbBaseRegisteroffsetRegisterextensionshiftsrcRegister, sqInt _baseRegister, sqInt _offsetRegister, sqInt _extensionType, sqInt _shiftFlag, sqInt _srcRegister);
static sqInt NoDbgRegParms strbSourceRegisterdestinationRegister(AbstractInstruction * self_in_strbSourceRegisterdestinationRegister, sqInt _sourceRegister, sqInt _destinationRegister);
static sqInt NoDbgRegParms strbSourceRegisterdestinationRegisteroffset(AbstractInstruction * self_in_strbSourceRegisterdestinationRegisteroffset, sqInt _sourceRegister, sqInt _destinationRegister, sqInt _immediate12BitValue);
static sqInt NoDbgRegParms strhSourceRegisterdestinationRegisteroffset(AbstractInstruction * self_in_strhSourceRegisterdestinationRegisteroffset, sqInt _sourceRegister, sqInt _destinationRegister, sqInt _immediate12BitValue);
static sqInt NoDbgRegParms strSizebaseRegisteroffsetRegisterextensionshiftstoredRegister(AbstractInstruction * self_in_strSizebaseRegisteroffsetRegisterextensionshiftstoredRegister, sqInt _is64Bits, sqInt _baseRegister, sqInt _offsetRegister, sqInt _extensionType, sqInt _shiftFlag, sqInt _storedRegister);
static sqInt NoDbgRegParms strSizebaseRegisterpositiveOffsetdestinationRegister(AbstractInstruction * self_in_strSizebaseRegisterpositiveOffsetdestinationRegister, sqInt _is64Bits, sqInt _baseReg, sqInt _immediate12bitValue, sqInt _destinationRegister);
static sqInt NoDbgRegParms strSizebaseRegistersignedOffsetsourceRegisterpreIndex(AbstractInstruction * self_in_strSizebaseRegistersignedOffsetsourceRegisterpreIndex, sqInt _is64Bits, sqInt _baseRegister, sqInt _immediate9bitValue, sqInt _sourceRegister, sqInt _preIndex);
static sqInt NoDbgRegParms sturSizebaseRegistersignedOffsetdestinationRegister(AbstractInstruction * self_in_sturSizebaseRegistersignedOffsetdestinationRegister, sqInt _is64Bits, sqInt _baseReg, sqInt _immediate9bitValue, sqInt _destinationRegister);
static sqInt NoDbgRegParms subsExtendedSizeleftRegisterMaybeSPshiftedRightRegisteroptionshiftOffsetdestinationRegister(AbstractInstruction * self_in_subsExtendedSizeleftRegisterMaybeSPshiftedRightRegisteroptionshiftOffsetdestinationRegister, sqInt _is64Bits, sqInt _leftRegister, sqInt _rightRegister, sqInt _option, sqInt _immediate3bitValue, sqInt _destinationRegister);
static sqInt NoDbgRegParms subsSizeleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister(AbstractInstruction * self_in_subsSizeleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister, sqInt _is64Bits, sqInt _leftRegister, sqInt _rightRegister, sqInt _shiftType, sqInt _immediate6bitValue, sqInt _destinationRegister);
static sqInt NoDbgRegParms subsSizesourceRegisterimmediate12BitValueshifteddestinationRegister(AbstractInstruction * self_in_subsSizesourceRegisterimmediate12BitValueshifteddestinationRegister, sqInt _is64Bits, sqInt _leftRegister, sqInt _immediate12BitValue, sqInt _shiftedFlag, sqInt _destinationRegister);
static sqInt NoDbgRegParms subTqterm1term2dest(AbstractInstruction * self_in_subTqterm1term2dest, sqInt _t, sqInt _q, sqInt _vectorReg1, sqInt _vectorReg2, sqInt _vectorRegSum);
static sqInt NoDbgRegParms trailingOnesOf(AbstractInstruction * self_in_trailingOnesOf, sqInt _aNumber);
static sqInt NoDbgRegParms trailingZerosOf(AbstractInstruction * self_in_trailingZerosOf, sqInt _aNumber);
static sqInt NoDbgRegParms tstSizeimmediate13bitValueregister(AbstractInstruction * self_in_tstSizeimmediate13bitValueregister, sqInt _is64bits, sqInt _immediate13bitValue, sqInt _registerToUse);
static sqInt NoDbgRegParms unsignedBitfieldMoveSizeimmrimmssourceRegisterdestinationRegister(AbstractInstruction * self_in_unsignedBitfieldMoveSizeimmrimmssourceRegisterdestinationRegister, sqInt _is64Bits, sqInt _immr, sqInt _imms, sqInt _sourceRegister, sqInt _destinationRegister);
static sqInt NoDbgRegParms isBranch(BytecodeDescriptor * self_in_isBranch);
static AbstractInstruction * NoDbgRegParms gAddCqR(sqInt _quickConstant, sqInt _reg);
static AbstractInstruction * NoDbgRegParms gAndCqR(sqInt _quickConstant, sqInt _reg);
static AbstractInstruction * NoDbgRegParms gAndCqRR(sqInt _quickConstant, sqInt _srcReg, sqInt _destReg);
extern sqInt abortOffset(void);
extern void addCogMethodsToHeapMap(void);
static sqInt NoDbgRegParms addressIsInCurrentCompilation(sqInt _address);
static sqInt NoDbgRegParms addressIsInFixups(BytecodeFixup *_address);
static sqInt NoDbgRegParms addressIsInInstructions(AbstractInstruction *_address);
static sqInt NoDbgRegParms addressOfEndOfCaseinCPIC(sqInt _n, CogMethod *_cPIC);
static sqInt NoDbgRegParms alignUptoRoutineBoundary(sqInt _anAddress);
static sqInt allMachineCodeObjectReferencesValid(void);
static sqInt allMethodsHaveCorrectHeader(void);
static AbstractInstruction * NoDbgRegParms annotateAbsolutePCRef(AbstractInstruction *_abstractInstruction);
static AbstractInstruction * NoDbgRegParms annotateBytecode(AbstractInstruction *_abstractInstruction);
static AbstractInstruction * NoDbgRegParms annotateobjRef(AbstractInstruction *_abstractInstruction, sqInt _anOop);
static void NoDbgRegParms assertSaneJumpTarget(AbstractInstruction *_jumpTarget);
extern sqInt bytecodePCForstartBcpcin(sqInt _mcpc, sqInt _startbcpc, CogMethod *_cogMethod);
static AbstractInstruction * NoDbgRegParms CallRTregistersToBeSavedMask(sqInt _callTarget, sqInt _registersToBeSaved);
static AbstractInstruction * NoDbgRegParms gCall(sqInt _callTarget);
static AbstractInstruction * NoDbgRegParms gCmpCqR(sqInt _quickConstant, sqInt _reg);
static AbstractInstruction * NoDbgRegParms gCmpCwR(sqInt _wordConstant, sqInt _reg);
static sqInt NoDbgRegParms cacheTagIsSelectorForAnnotationandEntryPoint(sqInt _annotation, sqInt _entryPoint);
extern void callCogCodePopReceiver(void);
extern void callCogCodePopReceiverAndClassRegs(void);
extern sqInt ceCPICMissreceiver(CogMethod *_cPIC, sqInt _receiver);
extern void ceFree(void *_pointer);
extern void* ceMalloc(size_t _size);
extern sqInt ceSICMiss(sqInt _receiver);
extern void checkAssertsEnabledInCogit(void);
static sqInt checkCFramePointerInUse(void);
static sqInt NoDbgRegParms checkIfValidOopRefAndTargetpccogMethod(sqInt _annotation, char *_mcpc, sqInt _cogMethod);
static sqInt NoDbgRegParms checkIfValidOopRefpccogMethod(sqInt _annotation, char *_mcpc, sqInt _cogMethod);
extern sqInt checkIntegrityOfObjectReferencesInCode(sqInt gcModes);
static sqInt NoDbgRegParms checkMaybeObjRefInClosedPIC(sqInt _maybeObject);
static sqInt NoDbgRegParms checkValidObjectReferencesInClosedPIC(CogMethod *_cPIC);
static sqInt NoDbgRegParms NeverInline cleanUpFailingCogCodeConstituents(CogMethod *_cogMethodArg);
static sqInt NoDbgRegParms closedPICRefersToUnmarkedObject(CogMethod *_cPIC);
extern char * codeEntryFor(char *_address);
extern char * codeEntryNameFor(char *_address);
extern sqInt cogCodeBase(void);
extern sqInt cogCodeConstituents(sqInt _withDetails);
static sqInt NoDbgRegParms cogExtendPICCaseNMethodtagisMNUCase(CogMethod *_cPIC, sqInt _caseNMethod, sqInt _caseNTag, sqInt _isMNUCase);
extern CogMethod * cogFullBlockMethodnumCopied(sqInt _aMethodObj, sqInt _numCopied);
extern void cogitPostGCAction(sqInt _gcMode);
extern sqInt cogMethodDoesntLookKosher(CogMethod *_cogMethod);
extern void cogMethodIfPossibleselector(sqInt _methodOrSelectorIndex, sqInt _selector);
extern CogMethod * cogMNUPICSelectorreceivermethodOperandnumArgs(sqInt _selector, sqInt _rcvr, sqInt _methodOperand, sqInt _numArgs);
static CogMethod * NoDbgRegParms cogOpenPICSelectornumArgs(sqInt _selector, sqInt _numArgs);
static CogMethod * NoDbgRegParms cogPICSelectornumArgsCase0MethodCase1MethodtagisMNUCase(sqInt _selector, sqInt _numArgs, CogMethod *_case0CogMethod, sqInt _case1MethodOrNil, sqInt _case1Tag, sqInt _isMNUCase);
extern CogMethod * cogselector(sqInt _aMethodObj, sqInt _aSelectorOop);
static sqInt NoDbgRegParms collectCogConstituentForAnnotationMcpcBcpcMethod(BytecodeDescriptor *_descriptor, sqInt _isBackwardBranchAndAnnotation, char *_mcpc, sqInt _bcpc, void *cogMethodArg);
static sqInt NoDbgRegParms collectCogMethodConstituent(CogMethod *_cogMethod);
extern void compactCogCompiledCode(void);
static void compactPICsWithFreedTargets(void);
static AbstractInstruction * compileAbort(void);
static void NoDbgRegParms compileCallFornumArgsargargargargresultRegregsToSave(void *_aRoutine, sqInt _numArgs, sqInt _regOrConst0, sqInt _regOrConst1, sqInt _regOrConst2, sqInt _regOrConst3, sqInt _resultRegOrNone, sqInt _regMask);
static AbstractInstruction * compileCPICEntry(void);
static sqInt NoDbgRegParms compileEntireFullBlockMethod(sqInt _numCopied);
static void compileEntry(void);
static sqInt compileFullBlockEntry(void);
static sqInt compileMethodBody(void);
static sqInt NoDbgRegParms compilePICAbort(sqInt _numArgs);
static void NoDbgRegParms compileTrampolineFornumArgsargargargargregsToSavepushLinkRegresultReg(void *_aRoutine, sqInt _numArgs, sqInt _regOrConst0, sqInt _regOrConst1, sqInt _regOrConst2, sqInt _regOrConst3, sqInt _regMask, sqInt _pushLinkReg, sqInt _resultRegOrNone);
static void computeEntryOffsets(void);
static void computeFullBlockEntryOffsets(void);
static void computeMaximumSizes(void);
static sqInt NoDbgRegParms configureCPICCase0Case1MethodtagisMNUCase(CogMethod *_aPIC, CogMethod *_case0CogMethod, sqInt _case1Method, sqInt _case1Tag, sqInt _isMNUCase);
static sqInt NoDbgRegParms configureMNUCPICmethodOperand(CogMethod *_aPIC, sqInt _methodOop);
static sqInt NoDbgRegParms cPICCompactAndIsNowEmpty(CogMethod *_cPIC);
static sqInt NoDbgRegParms cPICHasForwardedClass(CogMethod *_cPIC);
static sqInt NoDbgRegParms cPICHasFreedTargets(CogMethod *_cPIC);
static sqInt cPICPrototypeCaseOffset(void);
static sqInt NoDbgRegParms cPICHasTarget(CogMethod *_cPIC, CogMethod *_targetMethod);
static sqInt NoDbgRegParms createCPICData(CogMethod *_cPIC);
static AbstractInstruction * NoDbgRegParms gDivRRQuoRem(sqInt _rDivisor, sqInt _rDividend, sqInt _rQuotient, sqInt _rRemainder);
#if FEATURE_JIT_SIMD
static AbstractInstruction * NoDbgRegParms gDupSRVr(sqInt _aSize, sqInt _aGeneralRegister, sqInt _aVectorRegister);
#endif /* FEATURE_JIT_SIMD */
extern sqInt defaultCogCodeSize(void);
static sqInt NoDbgRegParms deltaToSkipPrimAndErrorStoreInheader(sqInt _aMethodObj, sqInt _aMethodHeader);
static sqInt NoDbgRegParms endPCOf(sqInt _aMethod);
static void NoDbgRegParms ensureAndClearAbstractOpcodes(sqInt _numberOfAbstractOpcodes);
extern void enterCogCodePopReceiver(void);
static sqInt NoDbgRegParms expectedClosedPICPrototype(CogMethod *_cPIC);
static sqInt extABytecode(void);
static sqInt extBBytecode(void);
static AbstractInstruction * NoDbgRegParms gFaddSRvRvRv(sqInt _aSize, sqInt _vectorRegister1, sqInt _vectorRegister2, sqInt _vectorRegisterSum);
static AbstractInstruction * NoDbgRegParms gFsubSRvRvRv(sqInt _aSize, sqInt _minuendVectorRegister, sqInt _subtrahendVectorRegister, sqInt _vectorRegisterSum);
static CogMethod * NoDbgRegParms fillInMethodHeadersizeselector(CogMethod *method, sqInt _size, sqInt _selector);
static sqInt NoDbgRegParms findBackwardBranchIsBackwardBranchMcpcBcpcMatchingBcpc(BytecodeDescriptor *descriptor, sqInt _isBackwardBranchAndAnnotation, char *_mcpc, sqInt _bcpc, void *_targetBcpc);
static sqInt NoDbgRegParms findIsBackwardBranchMcpcBcpcMatchingMcpc(BytecodeDescriptor *_descriptor, sqInt _isBackwardBranchAndAnnotation, char *_mcpc, sqInt _bcpc, void *_targetMcpc);
static sqInt firstPrototypeMethodOop(void);
static BytecodeFixup * NoDbgRegParms fixupAt(sqInt _fixupPC);
extern void followForwardedLiteralsIn(CogMethod *_cogMethod);
extern void followForwardedMethods(void);
static sqInt NoDbgRegParms followMaybeObjRefInClosedPICAt(sqInt _mcpc);
static sqInt NoDbgRegParms followMethodReferencesInClosedPIC(CogMethod *_cPIC);
extern void freeUnmarkedMachineCode(void);
static AbstractInstruction * NoDbgRegParms genCallMustBeBooleanFor(sqInt _boolean);
static sqInt genCheckForInterruptsTrampoline(void);
static AbstractInstruction * NoDbgRegParms genConditionalBranchoperand(sqInt _opcode, sqInt _operandOne);
static void (*genEnilopmartForandandforCallcalled(sqInt _regArg1, sqInt _regArg2OrNone, sqInt _regArg3OrNone, sqInt _forCall, char *_trampolineName))(void) ;
static void NoDbgRegParms genEnilopmartReturn(sqInt _forCall);
static void NoDbgRegParms generateCaptureCStackPointers(sqInt _captureFramePointer);
static void generateClosedPICPrototype(void);
static CogMethod * generateCogFullBlock(void);
static CogMethod * NoDbgRegParms generateCogMethod(sqInt _selector);
static sqInt NoDbgRegParms generateMapAtstart(usqInt _addressOrNull, usqInt _startAddress);
static void generateOpenPICPrototype(void);
static void generateReturnToInterpreterPCTrampoline(void);
static void generateRunTimeTrampolines(void);
static void generateStackPointerCapture(void);
static void generateTrampolines(void);
static BytecodeDescriptor * NoDbgRegParms generatorForPC(sqInt _pc);
static void genGetLeafCallStackPointer(void);
static sqInt NoDbgRegParms genInnerPICAbortTrampoline(char *_name);
static sqInt genLoadCStackPointersForPrimCall(void);
static void NoDbgRegParms genLoadInlineCacheWithSelector(sqInt _selectorIndex);
static sqInt genNonLocalReturnTrampoline(void);
static sqInt NoDbgRegParms genReturnTrampolineForcalledarg(void *_aRoutine, char *_aString, sqInt _regOrConst0);
static sqInt NoDbgRegParms genSmalltalkToCStackSwitch(sqInt _pushLinkReg);
static sqInt NoDbgRegParms genTrampolineForcalled(void *_aRoutine, char *_aString);
static sqInt NoDbgRegParms genTrampolineForcalledarg(void *_aRoutine, char *_aString, sqInt _regOrConst0);
static sqInt NoDbgRegParms genTrampolineForcalledargargargresult(void *_aRoutine, char *_aString, sqInt _regOrConst0, sqInt _regOrConst1, sqInt _regOrConst2, sqInt _resultReg);
static sqInt NoDbgRegParms genTrampolineForcalledargargregsToSave(void *_aRoutine, char *_aString, sqInt _regOrConst0, sqInt _regOrConst1, sqInt _regMask);
static sqInt NoDbgRegParms genTrampolineForcalledargargresult(void *_aRoutine, char *_aString, sqInt _regOrConst0, sqInt _regOrConst1, sqInt _resultReg);
static sqInt NoDbgRegParms genTrampolineForcalledargregsToSave(void *_aRoutine, char *_aString, sqInt _regOrConst0, sqInt _regMask);
static sqInt NoDbgRegParms genTrampolineForcalledargresult(void *_aRoutine, char *_aString, sqInt _regOrConst0, sqInt _resultReg);
static sqInt NoDbgRegParms genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(void *_aRoutine, char *_trampolineName, sqInt _numArgs, sqInt _regOrConst0, sqInt _regOrConst1, sqInt _regOrConst2, sqInt _regOrConst3, sqInt _regMask, sqInt _pushLinkReg, sqInt _resultRegOrNone, sqInt _appendBoolean);
static sqInt NoDbgRegParms genTrampolineForcalledregsToSave(void *_aRoutine, char *_aString, sqInt _regMask);
static AbstractInstruction * NoDbgRegParms gen(sqInt _opcode);
static AbstractInstruction * NoDbgRegParms genoperand(sqInt _opcode, sqInt _operand);
static AbstractInstruction * NoDbgRegParms genoperandoperand(sqInt _opcode, sqInt _operandOne, sqInt _operandTwo);
static AbstractInstruction * NoDbgRegParms genoperandoperandoperand(sqInt _opcode, sqInt _operandOne, sqInt _operandTwo, sqInt _operandThree);
static AbstractInstruction * NoDbgRegParms genoperandoperandoperandoperand(sqInt _opcode, sqInt _operandOne, sqInt _operandTwo, sqInt _operandThree, sqInt _operandFour);
extern sqInt getBlockCompilationCount(void);
extern sqInt getBlockCompilationMSecs(void);
static sqInt NoDbgRegParms getLiteral(sqInt _litIndex);
extern sqInt getMethodCompilationCount(void);
extern sqInt getMethodCompilationMSecs(void);
static sqInt getOpcodeIndex(void);
static sqInt NoDbgRegParms incrementUsageOfTargetIfLinkedSendmcpcignored(sqInt _annotation, char *_mcpc, sqInt superfluity);
static sqInt NoDbgRegParms indexForSelectorinat(sqInt _selector, CogMethod *_cogMethod, sqInt _mcpc);
static sqInt initialClosedPICUsageCount(void);
static void initializeBackend(void);
extern void initializeCodeZoneFromupTo(sqInt _startAddress, sqInt _endAddress);
static void NoDbgRegParms initializePICatDeltanumArgs(CogMethod *_aPIC, sqInt _addrDelta, sqInt _numArgs);
static sqInt initialMethodUsageCount(void);
static sqInt initialOpenPICUsageCount(void);
static sqInt NoDbgRegParms inlineCacheValueForSelectorinat(sqInt _selector, CogMethod *_aCogMethod, sqInt _mcpc);
static sqInt NoDbgRegParms inverseBranchFor(sqInt _opcode);
static sqInt isMNUPicAbortDiscriminatorValue(void);
static sqInt NoDbgRegParms isPCMappedAnnotation(sqInt _annotation);
extern sqInt isPCWithinMethodZone(void *_address);
extern sqInt isSendReturnPC(sqInt _retpc);
static AbstractInstruction * NoDbgRegParms gJumpFPEqual(void *_jumpTarget);
static AbstractInstruction * NoDbgRegParms gJumpFPGreaterOrEqual(void *_jumpTarget);
static AbstractInstruction * NoDbgRegParms gJumpFPGreater(void *_jumpTarget);
static AbstractInstruction * NoDbgRegParms gJumpFPNotEqual(void *_jumpTarget);
static AbstractInstruction * NoDbgRegParms gLd1SVrRMw(sqInt _aSize, sqInt _aVectorRegister, sqInt _aMemoryRegister, sqInt _anOffset);
static AbstractInstruction * NoDbgRegParms gLogicalShiftLeftCqR(sqInt _quickConstant, sqInt _reg);
static AbstractInstruction * lastOpcode(void);
extern void linkSendAtintooffsetreceiver(sqInt _callSiteReturnAddress, CogMethod *sendingMethod, CogMethod *_targetMethod, sqInt _theEntryOffset, sqInt _receiver);
static BytecodeDescriptor * loadBytesAndGetDescriptor(void);
static void NoDbgRegParms loadSubsequentBytesForDescriptorat(BytecodeDescriptor *_descriptor, sqInt _pc);
static AbstractInstruction * NoDbgRegParms gMoveAwR(sqInt _address, sqInt _reg);
static AbstractInstruction * NoDbgRegParms gMoveCwR(sqInt _wordConstant, sqInt _reg);
static sqInt NoDbgRegParms mapForperformUntilarg(CogMethod *_cogMethod, sqInt (*_functionSymbol)(sqInt annotation, char *mcpc, sqInt arg), sqInt _arg);
static sqInt NoDbgRegParms mapObjectReferencesInClosedPIC(CogMethod *_cPIC);
static void mapObjectReferencesInGeneratedRuntime(void);
static void mapObjectReferencesInMachineCodeForBecome(void);
static void mapObjectReferencesInMachineCodeForFullGC(void);
static void mapObjectReferencesInMachineCodeForYoungGC(void);
extern void mapObjectReferencesInMachineCode(sqInt _gcMode);
extern void markAndTraceMachineCodeOfMarkedMethods(void);
static void markAndTraceObjectReferencesInGeneratedRuntime(void);
static sqInt NoDbgRegParms markAndTraceOrFreeCogMethodfirstVisit(CogMethod *_cogMethod, sqInt _firstVisit);
static sqInt NoDbgRegParms markAndTraceOrFreePICTargetin(sqInt _entryPoint, CogMethod *_cPIC);
static sqInt NoDbgRegParms markLiteralsAndUnlinkIfUnmarkedSendpcmethod(sqInt _annotation, char *_mcpc, sqInt _cogMethod);
static sqInt NoDbgRegParms markLiteralspcmethod(sqInt _annotation, char *_mcpc, sqInt _cogMethod);
extern void markMethodAndReferents(CogMethod *_aCogMethod);
extern usqInt maxCogMethodAddress(void);
static sqInt NoDbgRegParms maybeFreeCogMethodDoesntLookKosher(CogMethod *_cogMethod);
static void NoDbgRegParms maybeMarkCountersIn(CogMethod *cogMethod);
static sqInt mclassIsSmallInteger(void);
extern usqInt mcPCForBackwardBranchstartBcpcin(sqInt _bcpc, sqInt _startbcpc, CogMethod *_cogMethod);
static sqInt NoDbgRegParms methodhasSameCodeAscheckPenultimate(sqInt _methodA, sqInt _methodB, sqInt _comparePenultimateLiteral);
extern sqInt minCogMethodAddress(void);
extern sqInt mnuOffset(void);
static sqInt NoDbgRegParms needsFrameIfImmutability(sqInt stackDelta);
static sqInt NoDbgRegParms needsFrameIfInBlock(sqInt stackDelta);
static sqInt NoDbgRegParms needsFrameNever(sqInt stackDelta);
static sqInt NoDbgRegParms noAssertMethodClassAssociationOf(sqInt _methodPointer);
static sqInt noCogMethodsMaximallyMarked(void);
static sqInt NoDbgRegParms noTargetsFreeInClosedPIC(CogMethod *_cPIC);
static sqInt NoDbgRegParms outputInstructionsAt(sqInt _startAddress);
static sqInt NoDbgRegParms outputInstructionsForGeneratedRuntimeAt(sqInt _startAddress);
static AbstractInstruction * NoDbgRegParms gPushCw(sqInt _wordConstant);
extern sqInt patchToMegamorphicICFornumArgsreceiver(sqInt _selector, sqInt _numArgs, sqInt _receiver);
static usqIntptr_t NoDbgRegParms picAbortAddress(CogMethod *_cPIC);
static sqInt picInterpretAbortOffset(void);
extern void printCogMethodFor(void *_address);
extern void printTrampolineTable(void);
extern void printWhereIs(void *_address);
static sqInt processorHasDivQuoRemAndMClassIsSmallInteger(void);
static sqInt processorHasMultiplyAndMClassIsSmallInteger(void);
static void NoDbgRegParms recordGeneratedRunTimeaddress(char *_aString, sqInt _address);
extern sqInt recordPrimTraceFunc(void);
static void recordRunTimeObjectReferences(void);
static sqInt NoDbgRegParms registerMaskFor(sqInt _reg);
static sqInt NoDbgRegParms registerMaskForand(sqInt _reg1, sqInt _reg2);
static void NoDbgRegParms relocateCallsAndSelfReferencesInMethod(CogMethod *_cogMethod);
static void NoDbgRegParms relocateCallsInClosedPIC(CogMethod *_cPIC);
static sqInt NoDbgRegParms relocateIfCallOrMethodReferencemcpcdelta(sqInt _annotation, char *_mcpc, sqInt _refDelta);
static sqInt NoDbgRegParms remapIfObjectRefpchasYoung(sqInt _annotation, char *_mcpc, sqInt _hasYoungPtr);
static sqInt NoDbgRegParms remapMaybeObjRefInClosedPICAt(sqInt _mcpc);
static void NoDbgRegParms rewritePICCaseAttagobjReftarget(sqInt _followingAddress, sqInt _newTag, sqInt _newObjRef, sqInt _newTarget);
#if FEATURE_JIT_SIMD
static AbstractInstruction * NoDbgRegParms gSt1SVrRMw(sqInt _aSize, sqInt _aVectorRegister, sqInt _aMemoryRegister, sqInt _anOffset);
#endif /* FEATURE_JIT_SIMD */
static AbstractInstruction * NoDbgRegParms gSubCwR(sqInt _wordConstant, sqInt _reg);
extern void safeFreeMethod(sqInt _cogMethod);
extern void setHeaderOopOfto(CogMethod *_cogMethod, sqInt _aMethodHeaderOop);
extern void setPostCompileHook(void (*_aFunction)(CogMethod *));
extern void setSelectorOfto(CogMethod *_cogMethod, sqInt _aSelectorOop);
extern int sizeOfTrampoline(char *_address);
static sqInt subsequentPrototypeMethodOop(void);
static AbstractInstruction * NoDbgRegParms gTstCqR(sqInt _quickConstant, sqInt _reg);
extern sqInt traceLinkedSendOffset(void);
static sqInt NoDbgRegParms trampolineArgConstant(sqInt _booleanOrInteger);
static char * NoDbgRegParms trampolineNamenumArgs(char *_routinePrefix, sqInt _numArgs);
static char * NoDbgRegParms trampolineNamenumArgslimit(char *_routinePrefix, int _numArgs, sqInt _argsLimit);
static char * NoDbgRegParms trampolineNamenumRegArgs(char *_routinePrefix, sqInt _numArgs);
static sqInt unknownBytecode(void);
extern void unlinkAllSends(void);
static sqInt NoDbgRegParms unlinkIfFreeOrLinkedSendpcof(sqInt _annotation, char *_mcpc, sqInt _theSelector);
static sqInt NoDbgRegParms unlinkIfInvalidClassSendpcignored(sqInt _annotation, char *_mcpc, sqInt superfluity);
static sqInt NoDbgRegParms unlinkIfLinkedSendToFreepcignored(sqInt _annotation, char *_mcpc, sqInt superfluity);
static sqInt NoDbgRegParms unlinkIfLinkedSendpcignored(sqInt _annotation, char *_mcpc, sqInt superfluity);
static sqInt NoDbgRegParms unlinkIfLinkedSendpcto(sqInt _annotation, char *_mcpc, sqInt _theCogMethod);
extern void unlinkSendsLinkedForInvalidClasses(void);
extern void unlinkSendsOfisMNUSelector(sqInt _selector, sqInt _isMNUSelector);
extern void unlinkSendsToFree(void);
extern void unlinkSendsToandFreeIf(sqInt _targetMethodObject, sqInt _freeIfTrue);
static AbstractInstruction * NoDbgRegParms gXorCwR(sqInt _wordConstant, sqInt _reg);
static void zeroOpcodeIndex(void);
static void zeroOpcodeIndexForNewOpcodes(void);
static sqInt NoDbgRegParms counters(CogMethod * self_in_counters);
extern void addAllToYoungReferrers(void);
static void NoDbgRegParms addToMegamorphicICList(CogMethod *_anOpenPIC);
static void NoDbgRegParms addToYoungReferrers(CogMethod *_cogMethod);
static usqInt NoDbgRegParms allocate(sqInt _numBytes);
static void clearCogCompiledCode(void);
static void compactCompiledCode(void);
static void NoDbgRegParms ensureInYoungReferrers(CogMethod *_cogMethod);
static void followForwardedLiteralsInOpenPICList(void);
extern void freeMethod(CogMethod *_cogMethod);
static void freeOlderMethodsForCompaction(void);
static sqInt kosherYoungReferrers(void);
static void NoDbgRegParms manageFromto(sqInt _theStartAddress, sqInt _theLimitAddress);
extern CogMethod * methodFor(void *_address);
extern sqInt methodsCompiledToMachineCodeInto(sqInt _arrayObj);
extern sqInt numMethods(void);
extern sqInt numMethodsOfType(sqInt _cogMethodType);
static sqInt NoDbgRegParms occurrencesInYoungReferrers(CogMethod *_cogMethod);
static CogMethod * NoDbgRegParms openPICWithSelector(sqInt _aSelector);
static void planCompaction(void);
extern void printCogMethods(void);
extern void printCogMethodsOfType(sqInt _cmType);
extern void printCogMethodsWithMethod(sqInt _methodOop);
extern void printCogMethodsWithPrimitive(sqInt _primIdx);
extern void printCogMethodsWithSelector(sqInt _selectorOop);
extern void printCogYoungReferrers(void);
extern sqInt printOpenPICList(void);
static sqInt pruneYoungReferrers(void);
static sqInt relocateAndPruneYoungReferrers(void);
static sqInt relocateMethodsPreCompaction(void);
static sqInt NoDbgRegParms removeFromOpenPICList(CogMethod *_anOpenPIC);
static void voidOpenPICList(void);
static void voidYoungReferrersPostTenureAll(void);
extern char * whereIsMaybeCodeThing(sqInt _anOop);
static sqInt zoneAlignment(void);
static sqInt NoDbgRegParms checkValidObjectReference(sqInt _anOop);
static AbstractInstruction * NoDbgRegParms genCmpClassFloatCompactIndexR(sqInt _reg);
static sqInt NoDbgRegParms genGetMethodHeaderOfintoscratch(sqInt _methodReg, sqInt _headerReg, sqInt _scratchReg);
static sqInt NoDbgRegParms genLoadSlotsourceRegdestReg(sqInt _index, sqInt _sourceReg, sqInt _destReg);
static sqInt genNonImplementedPrimitive(void);
static sqInt genPrimitiveAdd(void);
static sqInt genPrimitiveAsFloat(void);
static sqInt genPrimitiveBitAnd(void);
static sqInt genPrimitiveBitOr(void);
static sqInt genPrimitiveBitShift(void);
static sqInt genPrimitiveBitXor(void);
static sqInt genPrimitiveClass(void);
static sqInt genPrimitiveDiv(void);
static sqInt genPrimitiveDivide(void);
static sqInt genPrimitiveEqual(void);
static sqInt genPrimitiveFloatAdd(void);
static sqInt genPrimitiveFloatDivide(void);
static sqInt genPrimitiveFloatEqual(void);
static sqInt genPrimitiveFloatGreaterOrEqual(void);
static sqInt genPrimitiveFloatGreaterThan(void);
static sqInt genPrimitiveFloatLessOrEqual(void);
static sqInt genPrimitiveFloatLessThan(void);
static sqInt genPrimitiveFloatMultiply(void);
static sqInt genPrimitiveFloatNotEqual(void);
static sqInt genPrimitiveFloatSquareRoot(void);
static sqInt genPrimitiveFloatSubtract(void);
static sqInt genPrimitiveFormat(void);
static sqInt genPrimitiveGreaterOrEqual(void);
static sqInt genPrimitiveGreaterThan(void);
static sqInt genPrimitiveIdentical(void);
static sqInt genPrimitiveLessOrEqual(void);
static sqInt genPrimitiveLessThan(void);
static sqInt genPrimitiveMod(void);
static sqInt genPrimitiveMultiply(void);
static sqInt genPrimitiveNewMethod(void);
static sqInt genPrimitiveNotEqual(void);
static sqInt genPrimitiveNotIdentical(void);
static sqInt genPrimitiveQuo(void);
static sqInt genPrimitiveSmallFloatAdd(void);
static sqInt genPrimitiveSmallFloatDivide(void);
static sqInt genPrimitiveSmallFloatEqual(void);
static sqInt genPrimitiveSmallFloatGreaterOrEqual(void);
static sqInt genPrimitiveSmallFloatGreaterThan(void);
static sqInt genPrimitiveSmallFloatLessOrEqual(void);
static sqInt genPrimitiveSmallFloatLessThan(void);
static sqInt genPrimitiveSmallFloatMultiply(void);
static sqInt genPrimitiveSmallFloatNotEqual(void);
static sqInt genPrimitiveSmallFloatSquareRoot(void);
static sqInt genPrimitiveSmallFloatSubtract(void);
static sqInt genPrimitiveSubtract(void);
static sqInt NoDbgRegParms genSmallIntegerComparison(sqInt _jumpOpcode);
static sqInt NoDbgRegParms genSmallIntegerComparisonorDoubleComparisoninvert(sqInt _jumpOpcode, AbstractInstruction * NoDbgRegParms (*_jumpFPOpcodeGenerator)(void *), sqInt _invertComparison);
static sqInt NoDbgRegParms isUnannotatableConstant(CogSimStackEntry *_simStackEntry);
static sqInt NoDbgRegParms classForInlineCacheTag(sqInt _classIndex);
static sqInt NoDbgRegParms genAddSmallIntegerTagsTo(sqInt _aRegister);
static AbstractInstruction * NoDbgRegParms genAlloc64BitPositiveIntegerValueintoscratchRegscratchReg(sqInt _valueReg, sqInt _resultReg, sqInt _scratch1, sqInt scratch2);
static AbstractInstruction * NoDbgRegParms genAlloc64BitSignedIntegerValueintoscratchRegscratchReg(sqInt _valueReg, sqInt _resultReg, sqInt _scratch1, sqInt scratch2);
static AbstractInstruction * NoDbgRegParms genAllocFloatValueintoscratchRegscratchReg(sqInt _dpreg, sqInt _resultReg, sqInt _scratch1, sqInt scratch2);
static AbstractInstruction * NoDbgRegParms genBoxedOrSmallFloatscratchReginto(sqInt _floatOopReg, sqInt _scratchReg, sqInt _destReg);
static sqInt NoDbgRegParms genClearAndSetSmallIntegerTagsIn(sqInt _scratchReg);
static sqInt NoDbgRegParms genConvertBitsToSmallFloatInscratch(sqInt _reg, sqInt scratch);
static void NoDbgRegParms genConvertCharacterToSmallIntegerInReg(sqInt _reg);
static void NoDbgRegParms genConvertDataFormatnumSlotsintoBytes(sqInt _formatReg, sqInt _slotsRegister, sqInt _destReg);
static sqInt NoDbgRegParms genConvertIntegerToSmallIntegerInReg(sqInt _reg);
static sqInt NoDbgRegParms genConvertSmallFloatToSmallFloatHashAsIntegerInRegscratch(sqInt _reg, sqInt _scratch);
static void NoDbgRegParms genConvertSmallIntegerToCharacterInReg(sqInt _reg);
static sqInt NoDbgRegParms genConvertSmallIntegerToIntegerInReg(sqInt _reg);
static sqInt NoDbgRegParms genFloatArithmeticpreOpCheckboxed(sqInt _arithmeticOperator, AbstractInstruction *(*_preOpCheckOrNil)(int rcvrReg, int argReg), sqInt _rcvrBoxed);
static sqInt NoDbgRegParms genFloatComparisoninvertboxed(AbstractInstruction *(*_jumpOpcodeGenerator)(void *), sqInt _invertComparison, sqInt _rcvrBoxed);
static sqInt NoDbgRegParms genGetHashFieldNonImmOfasSmallIntegerInto(sqInt _instReg, sqInt _destReg);
static sqInt NoDbgRegParms genGetHashFieldNonImmOfinto(sqInt _instReg, sqInt _destReg);
static AbstractInstruction * NoDbgRegParms genGetInlineCacheClassTagFrominto(sqInt _sourceReg, sqInt _destReg);
static sqInt NoDbgRegParms genGetNumBytesOfinto(sqInt _srcReg, sqInt _destReg);
static sqInt NoDbgRegParms genGetOverflowSlotsOfinto(sqInt _srcReg, sqInt _destReg);
static sqInt NoDbgRegParms genGetSmallFloatValueOfscratchinto(sqInt _oopReg, sqInt _scratch, sqInt _dpReg);
static AbstractInstruction * NoDbgRegParms genIntegerTo64BitPositiveIntegerValueintoscratchRegscratchReg(sqInt _valueReg, sqInt _resultReg, sqInt _scratch1, sqInt _scratch2);
static AbstractInstruction * NoDbgRegParms genIntegerTo64BitSignedIntegerValueintoscratchRegscratchReg(sqInt _valueReg, sqInt _resultReg, sqInt _scratch1, sqInt _scratch2);
static AbstractInstruction * NoDbgRegParms genJumpIsSmallIntegerValuescratch(sqInt _aRegister, sqInt _scratchReg);
static AbstractInstruction * NoDbgRegParms genJumpNotCharacter(sqInt _reg);
static AbstractInstruction * NoDbgRegParms genJumpNotSmallFloatValueBitsscratch(sqInt _reg, sqInt _exponent);
static AbstractInstruction * NoDbgRegParms genJumpNotSmallFloat(sqInt _reg);
static AbstractInstruction * NoDbgRegParms genJumpNotSmallIntegerValuescratch(sqInt _aRegister, sqInt _scratchReg);
static AbstractInstruction * NoDbgRegParms genJumpNotSmallInteger(sqInt _reg);
static AbstractInstruction * NoDbgRegParms genJumpSmallInteger(sqInt _aRegister);
static sqInt NoDbgRegParms genPrimitiveAtPutSigned(sqInt _signedVersion);
static sqInt NoDbgRegParms genPrimitiveAtSigned(sqInt _signedVersion);
static sqInt genPrimitiveIdentityHash(void);
static sqInt genPrimitiveImmediateAsInteger(void);
static sqInt genPrimitiveLoadInt32FromBytes(void);
static sqInt genPrimitiveLoadInt32FromExternalAddress(void);
static sqInt genPrimitiveLoadInt64FromBytes(void);
static sqInt genPrimitiveLoadInt64FromExternalAddress(void);
static sqInt genPrimitiveLoadUInt32FromBytes(void);
static sqInt genPrimitiveLoadUInt32FromExternalAddress(void);
static sqInt genPrimitiveLoadUInt64FromBytes(void);
static sqInt genPrimitiveLoadUInt64FromExternalAddress(void);
static sqInt genPrimitiveNew(void);
static sqInt genPrimitiveNewWithArg(void);
static sqInt genPrimitiveShallowCopy(void);
static sqInt genPrimitiveStoreInt32IntoBytes(void);
static sqInt genPrimitiveStoreInt32IntoExternalAddress(void);
static sqInt genPrimitiveStoreInt64IntoBytes(void);
static sqInt genPrimitiveStoreInt64IntoExternalAddress(void);
static sqInt genPrimitiveStoreUInt32IntoBytes(void);
static sqInt genPrimitiveStoreUInt32IntoExternalAddress(void);
static sqInt genPrimitiveStoreUInt64IntoBytes(void);
static sqInt genPrimitiveStoreUInt64IntoExternalAddress(void);
static sqInt genPrimitiveStringAt(void);
static sqInt genPrimitiveStringAtPut(void);
static sqInt NoDbgRegParms genRemoveSmallIntegerTagsInScratchReg(sqInt _scratchReg);
static sqInt NoDbgRegParms getLiteralCountOfplusOneinBytesintoscratch(sqInt _methodReg, sqInt _plusOne, sqInt _inBytes, sqInt _litCountReg, sqInt _scratchReg);
static sqInt NoDbgRegParms inlineCacheTagForInstance(sqInt _oop);
static sqInt log2BytesPerWord(void);
static void maybeGenerateSelectorIndexDereferenceRoutine(void);
static sqInt numSmallIntegerBits(void);
static sqInt numSmallIntegerTagBits(void);
static sqInt NoDbgRegParms validInlineCacheTag(sqInt _classIndexOrTagPattern);
static sqInt NoDbgRegParms cacheTagIsMarked(sqInt cacheTag);
static void callStoreCheckTrampoline(void);
static sqInt NoDbgRegParms checkValidDerivedObjectReference(sqInt _bodyAddress);
static sqInt NoDbgRegParms checkValidOopReference(sqInt _anOop);
static sqInt NoDbgRegParms couldBeDerivedObject(sqInt _bodyAddress);
static sqInt NoDbgRegParms couldBeObject(sqInt _literal);
static sqInt NoDbgRegParms genActiveContextTrampolineLargeinBlockcalled(sqInt _isLarge, sqInt _isInBlock, char *_aString);
static AbstractInstruction * NoDbgRegParms genAllocExternalAddressValueintoscratchRegscratchReg(sqInt _valueReg, sqInt _resultReg, sqInt _scratch1, sqInt scratch2);
static AbstractInstruction * NoDbgRegParms genCheckRememberedBitOfscratch(sqInt _objReg, sqInt _scratchReg);
static sqInt NoDbgRegParms genConvertCharacterToCodeInReg(sqInt _reg);
static sqInt NoDbgRegParms genConvertIntegerToCharacterInReg(sqInt _reg);
static sqInt NoDbgRegParms genCreateFullClosurenumArgsnumCopiedignoreContextcontextNumArgslargeinBlock(sqInt _compiledBlock, sqInt _numArgs, sqInt _numCopied, sqInt _ignoreContext, sqInt _contextNumArgs, sqInt _contextIsLarge, sqInt _contextIsBlock);
static sqInt NoDbgRegParms genEnsureObjInRegNotForwardedscratchReg(sqInt _reg, sqInt _scratch);
static sqInt NoDbgRegParms genEnsureOopInRegNotForwardedscratchReg(sqInt _reg, sqInt _scratch);
static sqInt NoDbgRegParms genEnsureOopInRegNotForwardedscratchRegifForwarderifNotForwarder(sqInt _reg, sqInt _scratch, sqInt _fwdJumpTarget, sqInt _nonFwdJumpTargetOrZero);
static sqInt NoDbgRegParms genEnsureOopInRegNotForwardedscratchRegupdatingSlotin(sqInt _reg, sqInt _scratch, sqInt _index, sqInt _objReg);
static void generateObjectRepresentationTrampolines(void);
static sqInt NoDbgRegParms genGetActiveContextLargeinBlock(sqInt _isLarge, sqInt _isInBlock);
static sqInt NoDbgRegParms genGetActiveContextNumArgslargeinBlock(sqInt _numArgs, sqInt _isLargeContext, sqInt _isInBlock);
static sqInt NoDbgRegParms genGetBitsofFormatByteOfinto(sqInt _mask, sqInt _sourceReg, sqInt _destReg);
static sqInt NoDbgRegParms genGetClassIndexOfNonImminto(sqInt _sourceReg, sqInt _destReg);
static sqInt NoDbgRegParms genGetClassObjectOfClassIndexintoscratchReg(sqInt _classIndexRegister, sqInt _destReg, sqInt _scratchReg);
static sqInt NoDbgRegParms genGetClassObjectOfintoscratchReginstRegIsReceiver(sqInt _instReg, sqInt _destReg, sqInt _scratchReg, sqInt _instRegIsReceiver);
static AbstractInstruction * NoDbgRegParms genGetClassTagOfintoscratchReg(sqInt _instReg, sqInt _destReg, sqInt scratchReg);
static sqInt NoDbgRegParms genGetCompactClassIndexNonImmOfinto(sqInt _instReg, sqInt _destReg);
static sqInt NoDbgRegParms genGetDoubleValueOfinto(sqInt _srcReg, sqInt _destFPReg);
static sqInt NoDbgRegParms genGetFormatOfinto(sqInt _srcReg, sqInt _destReg);
static sqInt NoDbgRegParms genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(sqInt _sourceReg, sqInt _destReg, sqInt _scratchRegOrNone);
static sqInt NoDbgRegParms genGetNumSlotsOfinto(sqInt _srcReg, sqInt _destReg);
static sqInt NoDbgRegParms genGetRawSlotSizeOfNonImminto(sqInt _sourceReg, sqInt _destReg);
static AbstractInstruction * NoDbgRegParms genJumpImmediate(sqInt _aRegister);
#if IMMUTABILITY
static AbstractInstruction * NoDbgRegParms genJumpImmutablescratchReg(sqInt _sourceReg, sqInt _scratchReg);
#endif /* IMMUTABILITY */
#if IMMUTABILITY
static AbstractInstruction * NoDbgRegParms genJumpMutablescratchReg(sqInt _sourceReg, sqInt _scratchReg);
#endif /* IMMUTABILITY */
static sqInt NoDbgRegParms genNewArrayOfSizeinitialized(sqInt _size, sqInt _initialized);
static sqInt genPrimitiveAsCharacter(void);
static sqInt genPrimitiveAt(void);
static sqInt genPrimitiveAtPut(void);
static sqInt NoDbgRegParms genPrimitiveIdenticalOrNotIf(sqInt _orNot);
static sqInt genPrimitiveIntegerAt(void);
static sqInt genPrimitiveIntegerAtPut(void);
static sqInt genPrimitiveLoadBoolean8FromBytes(void);
static sqInt genPrimitiveLoadBoolean8FromExternalAddress(void);
static sqInt genPrimitiveLoadChar16FromBytes(void);
static sqInt genPrimitiveLoadChar16FromExternalAddress(void);
static sqInt genPrimitiveLoadChar32FromBytes(void);
static sqInt genPrimitiveLoadChar32FromExternalAddress(void);
static sqInt genPrimitiveLoadChar8FromBytes(void);
static sqInt genPrimitiveLoadChar8FromExternalAddress(void);
static sqInt genPrimitiveLoadFloat32FromBytes(void);
static sqInt genPrimitiveLoadFloat32FromExternalAddress(void);
static sqInt genPrimitiveLoadFloat64FromBytes(void);
static sqInt genPrimitiveLoadFloat64FromExternalAddress(void);
static sqInt genPrimitiveLoadInt16FromBytes(void);
static sqInt genPrimitiveLoadInt16FromExternalAddress(void);
static sqInt genPrimitiveLoadInt8FromBytes(void);
static sqInt genPrimitiveLoadInt8FromExternalAddress(void);
static sqInt genPrimitiveLoadPointerFromBytes(void);
static sqInt genPrimitiveLoadPointerFromExternalAddress(void);
static sqInt genPrimitiveLoadUInt16FromBytes(void);
static sqInt genPrimitiveLoadUInt16FromExternalAddress(void);
static sqInt genPrimitiveLoadUInt8FromBytes(void);
static sqInt genPrimitiveLoadUInt8FromExternalAddress(void);
static sqInt genPrimitiveObjectAt(void);
static sqInt genPrimitiveSize(void);
static sqInt genPrimitiveStoreBoolean8IntoBytes(void);
static sqInt genPrimitiveStoreBoolean8IntoExternalAddress(void);
static sqInt genPrimitiveStoreChar16IntoBytes(void);
static sqInt genPrimitiveStoreChar16IntoExternalAddress(void);
static sqInt genPrimitiveStoreChar32IntoBytes(void);
static sqInt genPrimitiveStoreChar32IntoExternalAddress(void);
static sqInt genPrimitiveStoreChar8IntoBytes(void);
static sqInt genPrimitiveStoreChar8IntoExternalAddress(void);
static sqInt genPrimitiveStoreFloat32IntoBytes(void);
static sqInt genPrimitiveStoreFloat32IntoExternalAddress(void);
static sqInt genPrimitiveStoreFloat64IntoBytes(void);
static sqInt genPrimitiveStoreFloat64IntoExternalAddress(void);
static sqInt genPrimitiveStoreInt16IntoBytes(void);
static sqInt genPrimitiveStoreInt16IntoExternalAddress(void);
static sqInt genPrimitiveStoreInt8IntoBytes(void);
static sqInt genPrimitiveStoreInt8IntoExternalAddress(void);
static sqInt genPrimitiveStorePointerIntoBytes(void);
static sqInt genPrimitiveStorePointerIntoExternalAddress(void);
static sqInt genPrimitiveStoreUInt16IntoBytes(void);
static sqInt genPrimitiveStoreUInt16IntoExternalAddress(void);
static sqInt genPrimitiveStoreUInt8IntoBytes(void);
static sqInt genPrimitiveStoreUInt8IntoExternalAddress(void);
static sqInt genPrimitiveStringCompareWith(void);
static sqInt genPrimitiveStringReplace(void);
static sqInt NoDbgRegParms genSetSmallIntegerTagsIn(sqInt _scratchReg);
static sqInt genStoreCheckContextReceiverTrampoline(void);
static sqInt NoDbgRegParms genStoreCheckReceiverRegvalueRegscratchReginFrame(sqInt _destReg, sqInt _valueReg, sqInt _scratchReg, sqInt _inFrame);
static sqInt NoDbgRegParms genStoreSourceRegslotIndexdestRegscratchReginFrameneedsStoreCheck(sqInt _sourceReg, sqInt _index, sqInt _destReg, sqInt _scratchReg, sqInt _inFrame, sqInt _needsStoreCheck);
static sqInt NoDbgRegParms genStoreSourceRegslotIndexintoNewObjectInDestReg(sqInt _sourceReg, sqInt _index, sqInt _destReg);
#if IMMUTABILITY
static sqInt NoDbgRegParms genStoreTrampolineCalledinstVarIndex(char *_trampolineName, sqInt _instVarIndex);
#endif /* IMMUTABILITY */
#if IMMUTABILITY
static sqInt NoDbgRegParms genStoreWithImmutabilityAndStoreCheckSourceRegslotIndexdestRegscratchRegneedRestoreRcvr(sqInt _sourceReg, sqInt _index, sqInt _destReg, sqInt _scratchReg, sqInt _needRestoreRcvr);
#endif /* IMMUTABILITY */
#if IMMUTABILITY
static sqInt NoDbgRegParms genStoreWithImmutabilityButNoStoreCheckSourceRegslotIndexdestRegscratchRegneedRestoreRcvr(sqInt _sourceReg, sqInt _index, sqInt _destReg, sqInt _scratchReg, sqInt _needRestoreRcvr);
#endif /* IMMUTABILITY */
#if IMMUTABILITY
static sqInt NoDbgRegParms genStoreWithImmutabilityCheckSourceRegslotIndexdestRegscratchRegneedsStoreCheckneedRestoreRcvr(sqInt _sourceReg, sqInt _index, sqInt _destReg, sqInt _scratchReg, sqInt _needsStoreCheck, sqInt _needRestoreRcvr);
#endif /* IMMUTABILITY */
static AbstractInstruction * NoDbgRegParms jumpNotCharacterUnsignedValueInRegister(sqInt _reg);
static sqInt NoDbgRegParms markAndTraceLiteralinatpc(sqInt _literal, CogMethod *_cogMethodOrNil, usqInt _address);
static void NoDbgRegParms markAndTraceLiteralinat(sqInt _literal, CogMethod *_cogMethod, sqInt *_address);
static void NoDbgRegParms markAndTraceUpdatedLiteralin(sqInt _objOop, CogMethod *_cogMethodOrNil);
static sqInt NoDbgRegParms maybeCompileRetryOnPrimitiveFail(sqInt _primIndex);
static sqInt NoDbgRegParms maybeShiftClassTagRegisterForMethodCacheProbe(sqInt _classTagReg);
static sqInt numCharacterBits(void);
extern sqInt numRegArgs(void);
static sqInt NoDbgRegParms remapObject(sqInt _objOop);
static sqInt NoDbgRegParms remapOop(sqInt _objOop);
static sqInt NoDbgRegParms shouldAnnotateObjectReference(sqInt _anOop);
static sqInt NoDbgRegParms slotOffsetOfInstVarIndex(sqInt _index);
static sqInt NoDbgRegParms valueOfAssociation(sqInt _associationOop);
static sqInt NoDbgRegParms cmpC32RTempByteSize(AbstractInstruction * self_in_cmpC32RTempByteSize);
static AbstractInstruction * NoDbgRegParms concretizeLiteral(AbstractInstruction * self_in_concretizeLiteral);
static usqInt NoDbgRegParms concretizeMovePatcheableC32R(AbstractInstruction * self_in_concretizeMovePatcheableC32R);
static usqInt NoDbgRegParms inlineCacheTagAt(AbstractInstruction * self_in_inlineCacheTagAt, sqInt _callSiteReturnAddress);
static sqInt NoDbgRegParms isPCDependent(AbstractInstruction * self_in_isPCDependent);
static sqInt NoDbgRegParms literalBeforeFollowingAddress(AbstractInstruction * self_in_literalBeforeFollowingAddress, sqInt _followingAddress);
static sqInt NoDbgRegParms literalLoadInstructionBytes(AbstractInstruction * self_in_literalLoadInstructionBytes);
static sqInt NoDbgRegParms loadLiteralByteSize(AbstractInstruction * self_in_loadLiteralByteSize);
static sqInt NoDbgRegParms outOfLineLiteralOpcodeLimit(AbstractInstruction * self_in_outOfLineLiteralOpcodeLimit);
static sqInt NoDbgRegParms pcRelativeAddressAt(AbstractInstruction * self_in_pcRelativeAddressAt, sqInt _instrAddress);
static AbstractInstruction * NoDbgRegParms relocateMethodReferenceBeforeAddressby(AbstractInstruction * self_in_relocateMethodReferenceBeforeAddressby, sqInt _pc, sqInt _delta);
static sqInt NoDbgRegParms rewriteFullTransferAttargetexpectedInstruction(AbstractInstruction * self_in_rewriteFullTransferAttargetexpectedInstruction, usqInt _callSiteReturnAddress, usqInt _callTargetAddress, sqInt _expectedInstruction);
static sqInt NoDbgRegParms rewriteInlineCacheAttagtarget(AbstractInstruction * self_in_rewriteInlineCacheAttagtarget, usqInt _callSiteReturnAddress, sqInt _cacheTag, usqInt _callTargetAddress);
static usqInt NoDbgRegParms sizePCDependentInstructionAt(AbstractInstruction * self_in_sizePCDependentInstructionAt, sqInt _eventualAbsoluteAddress);
static AbstractInstruction * NoDbgRegParms storeLiteralbeforeFollowingAddress(AbstractInstruction * self_in_storeLiteralbeforeFollowingAddress, sqInt _literal, sqInt _followingAddress);
static sqInt NoDbgRegParms usesOutOfLineLiteral(AbstractInstruction * self_in_usesOutOfLineLiteral);
static SimStackEntry * NoDbgRegParms copyToReg(SimStackEntry * self_in_copyToReg, sqInt _reg);
static SimStackEntry * NoDbgRegParms ensureSpilledAtfrom(SimStackEntry * self_in_ensureSpilledAtfrom, sqInt _baseOffset, sqInt _baseRegister);
static sqInt NoDbgRegParms isSameEntryAs(SimStackEntry * self_in_isSameEntryAs, CogSimStackEntry *_ssEntry);
static SimStackEntry * NoDbgRegParms moveToVectorReg(SimStackEntry * self_in_moveToVectorReg, sqInt _reg);
static sqInt NoDbgRegParms registerMask(SimStackEntry * self_in_registerMask);
static sqInt NoDbgRegParms registerMaskOrNone(SimStackEntry * self_in_registerMaskOrNone);
static signed char NoDbgRegParms registerOrNone(SimStackEntry * self_in_registerOrNone);
static sqInt NoDbgRegParms isMergeFixup(BytecodeFixup * self_in_isMergeFixup);
static AbstractInstruction * NoDbgRegParms allocateLiteral(sqInt _aLiteral);
static AbstractInstruction * NoDbgRegParms checkLiteralforInstruction(sqInt _literal, AbstractInstruction *_anInstruction);
static AbstractInstruction * NoDbgRegParms checkQuickConstantforInstruction(sqInt _literal, AbstractInstruction *_anInstruction);
static sqInt NoDbgRegParms dumpLiterals(sqInt _generateBranchAround);
static sqInt endSizeOffset(void);
static sqInt NoDbgRegParms literalInstructionInRange(AbstractInstruction *_litInst);
static AbstractInstruction * NoDbgRegParms locateLiteral(sqInt _aLiteral);
static sqInt NoDbgRegParms mustDumpLiterals(sqInt _currentOpcodeIndex);
static void compileGetErrorCode(void);
static sqInt compileInterpreterPrimitive(void);
static sqInt NoDbgRegParms compileInterpreterPrimitiveMayCallBackflags(void (*_primitiveRoutine)(void), sqInt _flags);
static sqInt NoDbgRegParms compileInterpreterPrimitiveflags(void (*_primitiveRoutine)(void), sqInt _flags);
static sqInt NoDbgRegParms compileMachineCodeInterpreterPrimitive(void (*_primitiveRoutine)(void));
static AbstractInstruction * NoDbgRegParms compileOpenPICMethodCacheProbeForwithShiftbaseRegOrNone(sqInt _selector, sqInt _shift, sqInt _baseRegOrNone);
static void NoDbgRegParms compileOpenPICnumArgs(sqInt _selector, sqInt _numArgs);
static AbstractInstruction * NoDbgRegParms compilePerformMethodCacheProbeForwithShiftbaseRegOrNone(sqInt _selectorReg, sqInt _shift, sqInt _baseRegOrNone);
static sqInt compilePrimitive(void);
static sqInt NoDbgRegParms frameOffsetOfTemporary(sqInt _index);
static AbstractInstruction * NoDbgRegParms genDoubleFailIfZeroArgRcvrarg(int rcvrReg, int _argReg);
static sqInt genExtJumpIfFalse(void);
static sqInt genExtJumpIfTrue(void);
static sqInt genExtNopBytecode(void);
static sqInt genExtPushCharacterBytecode(void);
static sqInt genExtPushIntegerBytecode(void);
static sqInt genExtPushLiteralBytecode(void);
static sqInt genExtPushLiteralVariableBytecode(void);
static sqInt genExtPushPseudoVariable(void);
static sqInt genExtPushReceiverVariableBytecode(void);
static sqInt genExtSendBytecode(void);
static sqInt genExtSendSuperBytecode(void);
static sqInt genExtStoreAndPopLiteralVariableBytecode(void);
static sqInt genExtStoreAndPopReceiverVariableBytecode(void);
static sqInt genExtStoreLiteralVariableBytecode(void);
static sqInt genExtStoreReceiverVariableBytecode(void);
static sqInt genExtUnconditionalJump(void);
static sqInt genFastPrimFail(void);
static void NoDbgRegParms genFastPrimTraceUsingand(sqInt _r1, sqInt _r2);
static sqInt genLongPushTemporaryVariableBytecode(void);
static sqInt genLongStoreAndPopTemporaryVariableBytecode(void);
static sqInt genLongStoreTemporaryVariableBytecode(void);
static sqInt NoDbgRegParms genLookupForPerformNumArgs(sqInt _numArgs);
static AbstractInstruction * NoDbgRegParms genMoveConstantR(sqInt _constant, sqInt _reg);
static sqInt NoDbgRegParms genMustBeBooleanTrampolineForcalled(sqInt _boolean, char *_trampolineName);
static sqInt genPrimitiveHashMultiply(void);
static void NoDbgRegParms genPrimReturnEnterCogCodeEnilopmart(sqInt _profiling);
static sqInt genPushConstantFalseBytecode(void);
static sqInt genPushConstantNilBytecode(void);
static sqInt genPushConstantOneBytecode(void);
static sqInt genPushConstantTrueBytecode(void);
static sqInt genPushConstantZeroBytecode(void);
static sqInt genPushLiteralConstantBytecode(void);
static sqInt genPushLiteralVariable16CasesBytecode(void);
static sqInt genPushQuickIntegerConstantBytecode(void);
static sqInt genPushReceiverVariableBytecode(void);
static sqInt genPushTemporaryVariableBytecode(void);
extern sqInt genQuickReturnConst(void);
extern sqInt genQuickReturnInstVar(void);
extern sqInt genQuickReturnSelf(void);
static sqInt genReturnFalse(void);
static sqInt genReturnNil(void);
static sqInt genReturnNilFromBlock(void);
static sqInt genReturnTrue(void);
static sqInt genSendLiteralSelector0ArgsBytecode(void);
static sqInt genSendLiteralSelector1ArgBytecode(void);
static sqInt genSendLiteralSelector2ArgsBytecode(void);
static sqInt genShortJumpIfFalse(void);
static sqInt genShortJumpIfTrue(void);
static sqInt genShortUnconditionalJump(void);
static sqInt genSpecialSelectorEqualsEquals(void);
static sqInt genSpecialSelectorNotEqualsEquals(void);
static sqInt genSpecialSelectorSend(void);
static sqInt genStoreAndPopReceiverVariableBytecode(void);
static sqInt genStoreAndPopRemoteTempLongBytecode(void);
static sqInt genStoreAndPopTemporaryVariableBytecode(void);
static sqInt genStoreRemoteTempLongBytecode(void);
static sqInt genUnconditionalTrapBytecode(void);
extern sqInt mapPCDataForinto(CogMethod *_cogMethod, sqInt _arrayObj);
static void maybeCompileAllocFillerCheck(void);
static sqInt numSpecialSelectors(void);
static sqInt NoDbgRegParms pcDataForAnnotationMcpcBcpcMethod(BytecodeDescriptor *_descriptor, sqInt _isBackwardBranchAndAnnotation, char *_mcpc, sqInt _bcpc, void *_cogMethodArg);
static PrimitiveDescriptor * primitiveDescriptor(void);
static sqInt NoDbgRegParms primitivePropertyFlagsprimitiveDescriptor(sqInt _primIndex, CogPrimitiveDescriptor *_aPrimitiveDescriptor);
extern void recordCallOffsetIn(CogMethod *_cogMethod);
extern void rewritePrimInvocationInto(CogMethod *_cogMethod, void (*_primFunctionPointer)(void));
static sqInt NoDbgRegParms seemsToBeInstantiating(sqInt _format);
static sqInt NoDbgRegParms v3ShortForwardBranchDistance(BytecodeDescriptor *descriptor, sqInt _pc, sqInt _nExts, sqInt _aMethodObj);
static sqInt NoDbgRegParms v4LongForwardBranchDistance(BytecodeDescriptor *descriptor, sqInt _pc, sqInt _nExts, sqInt _aMethodObj);
static sqInt NoDbgRegParms v4LongBranchDistance(BytecodeDescriptor *descriptor, sqInt _pc, sqInt _nExts, sqInt _aMethodObj);
extern void voidCogCompiledCode(void);
static void NoDbgRegParms adjustArgumentsForPerform(sqInt _numArgs);
static signed char NoDbgRegParms allocateRegForStackEntryAtnotConflictingWith(sqInt _index, sqInt _regMask);
static sqInt NoDbgRegParms allocateRegNotConflictingWith(sqInt _regMask);
#if FEATURE_JIT_SIMD
static signed char NoDbgRegParms allocateVectorRegForStackEntryAtnotConflictingWith(sqInt _index, sqInt _regMask);
#endif /* FEATURE_JIT_SIMD */
#if FEATURE_JIT_SIMD
static sqInt NoDbgRegParms allocateVectorRegNotConflictingWith(sqInt _regMask);
#endif /* FEATURE_JIT_SIMD */
static sqInt NoDbgRegParms anyReferencesToRegisterinTopNItems(sqInt _reg, sqInt _n);
extern void callCogCodePopReceiverArg0Regs(void);
extern void callCogCodePopReceiverArg1Arg0Regs(void);
static sqInt NoDbgRegParms compileAbstractInstructionsFromthrough(sqInt _start, sqInt _end);
static CogMethod * NoDbgRegParms compileCogFullBlockMethod(sqInt _numCopied);
static CogMethod * NoDbgRegParms compileCogMethod(sqInt _selector);
static sqInt compileEntireMethod(void);
static void compileFrameBuild(void);
static void NoDbgRegParms compileFullBlockFramelessEntry(sqInt numCopied);
static void NoDbgRegParms compileFullBlockMethodFrameBuild(sqInt _numCopied);
#if IMMUTABILITY
static void compileTwoPathFrameBuild(void);
#endif /* IMMUTABILITY */
static void compileTwoPathFramelessInit(void);
static sqInt NoDbgRegParms cPICMissTrampolineFor(sqInt _numArgs);
static sqInt duplicateTopBytecode(void);
static BytecodeFixup * NoDbgRegParms ensureFixupAt(sqInt _targetPC);
static BytecodeFixup * NoDbgRegParms ensureFixupAtwithStackPointer(sqInt _targetPC, sqInt _aStackPointer);
static BytecodeFixup * NoDbgRegParms ensureNonMergeFixupAt(sqInt _targetPC);
static void ensureReceiverResultRegContainsSelf(void);
static void NoDbgRegParms evaluateat(BytecodeDescriptor *_descriptor, sqInt _pc);
static sqInt NoDbgRegParms eventualTargetOf(sqInt _targetBytecodePC);
static sqInt NoDbgRegParms freeAnyRegNotConflictingWith(sqInt _regMask);
#if FEATURE_JIT_SIMD
static sqInt genAddFloat32Vector(void);
#endif /* FEATURE_JIT_SIMD */
#if FEATURE_JIT_SIMD
static sqInt genAddFloat64Vector(void);
#endif /* FEATURE_JIT_SIMD */
static sqInt genBlockReturn(void);
static sqInt genCallMappedInlinedPrimitive(void);
static void (*genCallPICEnilopmartNumArgs(sqInt _numArgs))(void) ;
static sqInt genCallPrimitiveBytecode(void);
static sqInt genExternalizePointersForPrimitiveCall(void);
static sqInt genExtPushFullClosureBytecode(void);
static void generateEnilopmarts(void);
static sqInt NoDbgRegParms generateInstructionsAt(sqInt _eventualAbsoluteAddress);
static void generateMissAbortTrampolines(void);
static void generateSendTrampolines(void);
static sqInt NoDbgRegParms generateSuperSendTrampolineTonamednumArgsin(sqInt _function, sqInt _name, sqInt _numArgs, sqInt *_table);
static void generateTracingTrampolines(void);
static sqInt NoDbgRegParms genForwardersInlinedIdenticalOrNotIf(sqInt _orNot);
static sqInt NoDbgRegParms genIdenticalNoBranchArgIsConstantrcvrIsConstantargRegrcvrRegorNotIf(sqInt _argIsConstant, sqInt _rcvrIsConstant, sqInt _argReg, sqInt _rcvrRegOrNone, sqInt _orNot);
static sqInt NoDbgRegParms genInlinedIdenticalOrNotIf(sqInt _orNot);
static sqInt NoDbgRegParms genJumpBackTo(sqInt _targetBytecodePC);
static sqInt NoDbgRegParms genJumpIfto(sqInt _boolean, sqInt _targetBytecodePC);
static sqInt NoDbgRegParms genJumpTo(sqInt _targetBytecodePC);
static sqInt NoDbgRegParms genMappedInlinePrimitive(sqInt _primIndex);
static sqInt NoDbgRegParms genMarshalledSendnumArgssendTable(sqInt _selectorIndex, sqInt _numArgs, sqInt *_sendTable);
static sqInt NoDbgRegParms genMethodAbortTrampolineFor(sqInt _numArgs);
static sqInt NoDbgRegParms genPICAbortTrampolineFor(sqInt _numArgs);
static sqInt NoDbgRegParms genPICMissTrampolineFor(sqInt _numArgs);
static sqInt genPopStackBytecode(void);
static sqInt genPrimitiveFullClosureValue(void);
static sqInt genPrimitivePerform(void);
static sqInt genPushActiveContextBytecode(void);
#if FEATURE_JIT_SIMD
static sqInt genPushFloat32ArrayToRegister(void);
#endif /* FEATURE_JIT_SIMD */
#if FEATURE_JIT_SIMD
static sqInt genPushFloat64ArrayToRegister(void);
#endif /* FEATURE_JIT_SIMD */
static sqInt NoDbgRegParms genPushLiteralIndex(sqInt _literalIndex);
static sqInt NoDbgRegParms genPushLiteralVariable(sqInt _literalIndex);
static sqInt NoDbgRegParms genPushLiteral(sqInt _literal);
static sqInt NoDbgRegParms genPushMaybeContextReceiverVariable(sqInt _slotIndex);
static sqInt genPushNewArrayBytecode(void);
static sqInt genPushReceiverBytecode(void);
static sqInt NoDbgRegParms genPushReceiverVariable(sqInt _index);
static void genPushRegisterArgs(void);
static sqInt genPushRemoteTempLongBytecode(void);
static sqInt NoDbgRegParms genPushTemporaryVariable(sqInt _index);
static sqInt genReturnReceiver(void);
static sqInt genReturnTopFromBlock(void);
static sqInt genReturnTopFromMethod(void);
static sqInt NoDbgRegParms genSendDirectedSupernumArgs(sqInt _selectorIndex, sqInt _numArgs);
static sqInt NoDbgRegParms genSendSupernumArgs(sqInt _selectorIndex, sqInt _numArgs);
static sqInt NoDbgRegParms genSendTrampolineFornumArgscalledargargargarg(void *_aRoutine, sqInt _numArgs, char *_aString, sqInt _regOrConst0, sqInt _regOrConst1, sqInt _regOrConst2, sqInt _regOrConst3);
static sqInt NoDbgRegParms genSendnumArgs(sqInt _selectorIndex, sqInt _numArgs);
static sqInt genSpecialSelectorArithmetic(void);
static sqInt genSpecialSelectorClass(void);
static sqInt genSpecialSelectorComparison(void);
static sqInt genStaticallyResolvedSpecialSelectorComparison(void);
#if FEATURE_JIT_SIMD
static sqInt genStoreFloat32RegisterIntoArray(void);
#endif /* FEATURE_JIT_SIMD */
#if FEATURE_JIT_SIMD
static sqInt genStoreFloat64RegisterIntoArray(void);
#endif /* FEATURE_JIT_SIMD */
static sqInt NoDbgRegParms genStorePopLiteralVariableneedsStoreCheckneedsImmutabilityCheck(sqInt _popBoolean, sqInt _litVarIndex, sqInt _needsStoreCheck, sqInt _needsImmCheck);
static sqInt NoDbgRegParms genStorePopMaybeContextReceiverVariableneedsStoreCheckneedsImmutabilityCheck(sqInt _popBoolean, sqInt _slotIndex, sqInt _needsStoreCheck, sqInt _needsImmCheck);
static sqInt NoDbgRegParms genStorePopReceiverVariableneedsStoreCheckneedsImmutabilityCheck(sqInt _popBoolean, sqInt _slotIndex, sqInt _needsStoreCheck, sqInt _needsImmCheck);
static sqInt NoDbgRegParms genStorePopRemoteTempAtneedsStoreCheck(sqInt _popBoolean, sqInt _slotIndex, sqInt _remoteTempIndex, sqInt _needsStoreCheck);
static sqInt NoDbgRegParms genStorePopTemporaryVariable(sqInt _popBoolean, sqInt _tempIndex);
#if FEATURE_JIT_SIMD
static sqInt genSubFloat64Vector(void);
#endif /* FEATURE_JIT_SIMD */
static sqInt genUpArrowReturn(void);
static void NoDbgRegParms initSimStackForFramefulMethod(sqInt _startpc);
static void NoDbgRegParms initSimStackForFramelessBlock(sqInt _startpc);
static void NoDbgRegParms initSimStackForFramelessMethod(sqInt _startpc);
static sqInt liveRegisters(void);
static sqInt liveVectorRegisters(void);
static sqInt NoDbgRegParms mapDeadDescriptorIfNeeded(BytecodeDescriptor *_descriptor);
static void NoDbgRegParms marshallSendArguments(sqInt _numArgs);
static sqInt NoDbgRegParms mergeWithFixupIfRequired(BytecodeFixup *_fixup);
static sqInt NoDbgRegParms methodAbortTrampolineFor(sqInt _numArgs);
static sqInt methodFoundInvalidPostScan(void);
static sqInt NoDbgRegParms needsFrameIfMod16GENumArgs(sqInt stackDelta);
static sqInt NoDbgRegParms needsFrameIfStackGreaterThanOne(sqInt _stackDelta);
static sqInt NoDbgRegParms numberOfSpillsInTopNItems(sqInt _n);
static sqInt NoDbgRegParms picAbortTrampolineFor(sqInt _numArgs);
static void NoDbgRegParms populatewithPICInfoForfirstCacheTag(sqInt _tuple, CogMethod *_cPIC, sqInt _firstCacheTag);
static sqInt prevInstIsPCAnnotated(void);
static sqInt NoDbgRegParms profilingDataForCounterat(sqInt counter, sqInt bcpc);
static sqInt NoDbgRegParms profilingDataForSendTomethodClassIfSuperatbcpc(CogMethod *_cogCodeSendTarget, sqInt _methodClassOrNil, char *_sendMcpc, sqInt _sendBcpc);
static sqInt NoDbgRegParms profilingDataForAnnotationMcpcBcpcMethod(BytecodeDescriptor *_descriptor, sqInt _isBackwardBranchAndAnnotation, char *_mcpc, sqInt _bcpc, void *_cogMethodArg);
extern sqInt profilingDataForinto(CogMethod *_cogMethod, sqInt _arrayObj);
static sqInt receiverIsInReceiverResultReg(void);
static sqInt scanMethod(void);
static sqInt NoDbgRegParms sistaV1PushNilSizenumInitialNils(sqInt aMethodObj, sqInt _numInitialNils);
static sqInt NoDbgRegParms sistaV1NumPushNils(BytecodeDescriptor *_descriptor, sqInt pc, sqInt nExts, sqInt aMethodObj);
static void NoDbgRegParms ssAllocateRequiredRegMaskupThrough(sqInt _requiredRegsMask, sqInt _stackPtr);
static void ssFlushStack(void);
static void NoDbgRegParms ssFlushStackExceptTop(sqInt _n);
static void NoDbgRegParms ssFlushUpThroughReceiverVariable(sqInt _slotIndex);
static void NoDbgRegParms ssFlushUpThroughTemporaryVariable(sqInt _tempIndex);
static void NoDbgRegParms ssPopTopToReg(sqInt _aRegister);
static void NoDbgRegParms ssPopTopToVectorReg(sqInt _aVectorRegister);
static void NoDbgRegParms ssPop(sqInt _n);
static void NoDbgRegParms ssPopandCopyReg(sqInt _popBoolean, sqInt _reg);
static void NoDbgRegParms ssPoppopSpilled(sqInt _n, sqInt _popSpilled);
static sqInt NoDbgRegParms ssPushAnnotatedConstant(sqInt _literal);
static sqInt NoDbgRegParms ssPushBaseoffset(sqInt _reg, sqInt _offset);
static sqInt NoDbgRegParms ssPushConstant(sqInt _literal);
static sqInt NoDbgRegParms ssPushDesc(SimStackEntry _simStackEntry);
static sqInt NoDbgRegParms ssPushRegister(sqInt _reg);
static sqInt NoDbgRegParms ssPushVectorRegister(sqInt _reg);
static void NoDbgRegParms ssPush(sqInt _n);
static SimStackEntry ssSelfDescriptor(void);
static void NoDbgRegParms ssStoreAndReplacePoptoReg(sqInt _popBoolean, sqInt _reg);
static sqInt NoDbgRegParms ssStorePoptoPreferredReg(sqInt _popBoolean, sqInt _preferredReg);
static CogSimStackEntry * ssTop(void);
static CogSimStackEntry * NoDbgRegParms ssValue(sqInt _n);
static sqInt NoDbgRegParms stackEntryIsBoolean(CogSimStackEntry *_simStackEntry);
static sqInt tempsValidAndVolatileEntriesSpilled(void);
static sqInt NoDbgRegParms tryCollapseTempVectorInitializationOfSize(sqInt _slots);
static sqInt violatesEnsureSpilledSpillAssert(void);
static void voidReceiverResultRegContainsSelf(void);


/*** Variables ***/
static AbstractInstruction * abstractOpcodes;
static AbstractInstruction aMethodLabel;
static AbstractInstruction * const backEnd = &aMethodLabel;
static usqInt baseAddress;
static sqInt byte0;
static sqInt byte1;
static sqInt byte2;
static sqInt byte3;
static sqInt bytecodePC;
void * CFramePointer;
void * CStackPointer;
sqInt cbEntryOffset;
sqInt cbNoSwitchEntryOffset;
sqInt ceBaseFrameReturnTrampoline;
void (*ceCall0ArgsPIC)(void);
void (*ceCall1ArgsPIC)(void);
void (*ceCall2ArgsPIC)(void);
void (*ceCallCogCodePopReceiverAndClassRegs)(void);
void (*ceCallCogCodePopReceiverArg0Regs)(void);
void (*ceCallCogCodePopReceiverArg1Arg0Regs)(void);
void (*ceCallCogCodePopReceiverReg)(void);
sqInt ceCannotResumeTrampoline;
void (*ceCaptureCStackPointers)(void);
sqInt ceCheckForInterruptTrampoline;
static sqInt ceDereferenceSelectorIndex;
void (*ceEnterCogCodePopReceiverReg)(void);
static sqInt ceFetchContextInstVarTrampoline;
usqIntptr_t (*ceGetFP)(void);
usqIntptr_t (*ceGetSP)(void);
static sqInt ceLargeActiveContextInFullBlockTrampoline;
static sqInt ceLargeActiveContextInMethodTrampoline;
static sqInt ceNewHashTrampoline;
static sqInt ceNonLocalReturnTrampoline;
static sqInt cePrimReturnEnterCogCode;
static sqInt cePrimReturnEnterCogCodeProfiling;
static sqInt ceReapAndResetErrorCodeTrampoline;
sqInt ceReturnToInterpreterTrampoline;
static sqInt ceScheduleScavengeTrampoline;
static sqInt ceSendMustBeBooleanAddFalseTrampoline;
static sqInt ceSendMustBeBooleanAddTrueTrampoline;
static sqInt ceSmallActiveContextInFullBlockTrampoline;
static sqInt ceSmallActiveContextInMethodTrampoline;
static sqInt ceStoreCheckContextReceiverTrampoline;
static sqInt ceStoreCheckTrampoline;
static sqInt ceStoreContextInstVarTrampoline;
#if IMMUTABILITY
sqInt ceStoreTrampolines[5];
#endif
static sqInt ceTraceLinkedSendTrampoline;
static sqInt ceTraceStoreTrampoline;
usqIntptr_t (*ceTryLockVMOwner)(void);
void (*ceUnlockVMOwner)(void);
sqInt cFramePointerInUse;
static sqInt closedPICSize;
sqInt cmEntryOffset;
sqInt cmNoCheckEntryOffset;
static sqInt codeBase;
static sqInt codeModified;
static sqInt cogConstituentIndex;
static sqInt compactionInProgress;
static sqInt compilationTrace;
static sqInt counterIndex;
static sqInt cPICCaseSize;
static sqInt cPICEndOfCodeOffset;
static sqInt cPICEndSize;
static sqInt cPICPrototype;
static sqInt deadCode;
usqIntptr_t debugPrimCallStackOffset;
static sqInt directedSendUsesBinding;
static sqInt directedSuperBindingSendTrampolines[NumSendTrampolines];
static sqInt directedSuperSendTrampolines[NumSendTrampolines];
static AbstractInstruction * endCPICCase0;
static sqInt endPC;
static AbstractInstruction * entry;
static CogMethod * enumeratingCogMethod;
static sqInt extA;
static sqInt extB;
static sqInt externalPrimCallOffsets[MaxNumArgs + 1];
static sqInt externalPrimJumpOffsets[MaxNumArgs + 1];
static sqInt externalSetPrimOffsets[MaxNumArgs + 1];
static sqInt firstCPICCaseOffset;
static sqInt firstOpcodeIndex;
static sqInt firstSend;
static BytecodeFixup * fixups;
static AbstractInstruction * fullBlockEntry;
static AbstractInstruction * fullBlockNoContextSwitchEntry;
static BytecodeDescriptor generatorTable[256] = {
	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
	{ genPushLiteralVariable16CasesBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralVariable16CasesBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralVariable16CasesBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralVariable16CasesBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralVariable16CasesBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralVariable16CasesBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralVariable16CasesBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralVariable16CasesBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralVariable16CasesBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralVariable16CasesBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralVariable16CasesBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralVariable16CasesBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralVariable16CasesBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralVariable16CasesBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralVariable16CasesBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralVariable16CasesBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushReceiverBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushConstantTrueBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushConstantFalseBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushConstantNilBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushConstantZeroBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPushConstantOneBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genExtPushPseudoVariable, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ duplicateTopBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ unknownBytecode, 0, 0, 0, Nop, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
	{ unknownBytecode, 0, 0, 0, Nop, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
	{ unknownBytecode, 0, 0, 0, Nop, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
	{ unknownBytecode, 0, 0, 0, Nop, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
	{ genReturnReceiver, 0, needsFrameIfInBlock, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0 },
	{ genReturnTrue, 0, needsFrameIfInBlock, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0 },
	{ genReturnFalse, 0, needsFrameIfInBlock, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0 },
	{ genReturnNil, 0, needsFrameIfInBlock, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0 },
	{ genReturnTopFromMethod, 0, needsFrameIfInBlock, -1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0 },
	{ genReturnNilFromBlock, 0, needsFrameNever, -1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
	{ genReturnTopFromBlock, 0, needsFrameNever, -1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
	{ genExtNopBytecode, 0, needsFrameNever, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorArithmetic, 0, 0, 0, AddRR, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorArithmetic, 0, 0, 0, SubRR, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorComparison, 0, 0, 0, JumpLess, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorComparison, 0, 0, 0, JumpGreater, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorComparison, 0, 0, 0, JumpLessOrEqual, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorComparison, 0, 0, 0, JumpGreaterOrEqual, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorComparison, 0, 0, 0, JumpZero, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorComparison, 0, 0, 0, JumpNonZero, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorArithmetic, 0, 0, 0, AndRR, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorArithmetic, 0, 0, 0, OrRR, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorEqualsEquals, 0, needsFrameNever, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorClass, 0, needsFrameIfStackGreaterThanOne, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorNotEqualsEquals, 0, needsFrameNever, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genShortUnconditionalJump, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genShortUnconditionalJump, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genShortUnconditionalJump, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genShortUnconditionalJump, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genShortUnconditionalJump, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genShortUnconditionalJump, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genShortUnconditionalJump, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genShortUnconditionalJump, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genShortJumpIfTrue, v3ShortForwardBranchDistance, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genShortJumpIfTrue, v3ShortForwardBranchDistance, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genShortJumpIfTrue, v3ShortForwardBranchDistance, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genShortJumpIfTrue, v3ShortForwardBranchDistance, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genShortJumpIfTrue, v3ShortForwardBranchDistance, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genShortJumpIfTrue, v3ShortForwardBranchDistance, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genShortJumpIfTrue, v3ShortForwardBranchDistance, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genShortJumpIfTrue, v3ShortForwardBranchDistance, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genShortJumpIfFalse, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
	{ genShortJumpIfFalse, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
	{ genShortJumpIfFalse, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
	{ genShortJumpIfFalse, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
	{ genShortJumpIfFalse, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
	{ genShortJumpIfFalse, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
	{ genShortJumpIfFalse, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
	{ genShortJumpIfFalse, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
	{ genStoreAndPopReceiverVariableBytecode, 0, needsFrameIfImmutability, -1, 0, 1, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 1, 0 },
	{ genStoreAndPopReceiverVariableBytecode, 0, needsFrameIfImmutability, -1, 0, 1, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 1, 0 },
	{ genStoreAndPopReceiverVariableBytecode, 0, needsFrameIfImmutability, -1, 0, 1, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 1, 0 },
	{ genStoreAndPopReceiverVariableBytecode, 0, needsFrameIfImmutability, -1, 0, 1, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 1, 0 },
	{ genStoreAndPopReceiverVariableBytecode, 0, needsFrameIfImmutability, -1, 0, 1, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 1, 0 },
	{ genStoreAndPopReceiverVariableBytecode, 0, needsFrameIfImmutability, -1, 0, 1, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 1, 0 },
	{ genStoreAndPopReceiverVariableBytecode, 0, needsFrameIfImmutability, -1, 0, 1, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 1, 0 },
	{ genStoreAndPopReceiverVariableBytecode, 0, needsFrameIfImmutability, -1, 0, 1, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 1, 0 },
	{ genStoreAndPopTemporaryVariableBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genStoreAndPopTemporaryVariableBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genStoreAndPopTemporaryVariableBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genStoreAndPopTemporaryVariableBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genStoreAndPopTemporaryVariableBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genStoreAndPopTemporaryVariableBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genStoreAndPopTemporaryVariableBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genStoreAndPopTemporaryVariableBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genPopStackBytecode, 0, needsFrameNever, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genUnconditionalTrapBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ unknownBytecode, 0, 0, 0, Nop, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
	{ unknownBytecode, 0, 0, 0, Nop, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
	{ unknownBytecode, 0, 0, 0, Nop, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
	{ unknownBytecode, 0, 0, 0, Nop, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
	{ unknownBytecode, 0, 0, 0, Nop, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
	{ unknownBytecode, 0, 0, 0, Nop, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
	{ extABytecode, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
	{ extBBytecode, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
	{ genExtPushReceiverVariableBytecode, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
	{ genExtPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genExtPushLiteralBytecode, 0, needsFrameNever, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genLongPushTemporaryVariableBytecode, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ unknownBytecode, 0, 0, 0, Nop, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
	{ genPushNewArrayBytecode, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genExtPushIntegerBytecode, 0, needsFrameNever, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genExtPushCharacterBytecode, 0, needsFrameNever, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genExtSendBytecode, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genExtSendSuperBytecode, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genCallMappedInlinedPrimitive, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genExtUnconditionalJump, v4LongBranchDistance, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genExtJumpIfTrue, v4LongBranchDistance, 0, 0, 0, 2, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
	{ genExtJumpIfFalse, v4LongBranchDistance, 0, 0, 0, 2, 0, 1, 0, 1, 0, 0, 0, 0, 0 },
	{ genExtStoreAndPopReceiverVariableBytecode, 0, 0, 0, 0, 2, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 0, 0 },
	{ genExtStoreAndPopLiteralVariableBytecode, 0, 0, 0, 0, 2, 0, 0, 0, IMMUTABILITY, 0, 0, 0, 0, 0 },
	{ genLongStoreAndPopTemporaryVariableBytecode, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genExtStoreReceiverVariableBytecode, 0, 0, 0, 0, 2, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 0, 0 },
	{ genExtStoreLiteralVariableBytecode, 0, 0, 0, 0, 2, 0, 0, 0, IMMUTABILITY, 0, 0, 0, 0, 0 },
	{ genLongStoreTemporaryVariableBytecode, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ unknownBytecode, 0, 0, 0, Nop, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
	{ unknownBytecode, 0, 0, 0, Nop, 2, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
	{ genCallPrimitiveBytecode, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 1 },
	{ genExtPushFullClosureBytecode, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ unknownBytecode, 0, 0, 0, Nop, 3, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
	{ genPushRemoteTempLongBytecode, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genStoreRemoteTempLongBytecode, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ genStoreAndPopRemoteTempLongBytecode, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
	{ unknownBytecode, 0, 0, 0, Nop, 3, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
	{ unknownBytecode, 0, 0, 0, Nop, 3, 0, 0, 0, 0, 0, 1, 0, 0, 0 }
};
static sqInt hasYoungReferent;
static sqInt inBlock;
static sqInt initialPC;
static sqInt introspectionData;
static sqInt introspectionDataIndex;
static int jitCodeZoneWriteEnabled = 0;
static int labelCounter;
static sqInt lastDumpedLiteralIndex;
static sqInt lastSend;
static usqInt limitAddress;
static AbstractInstruction * literals;
static sqInt literalsSize;
static sqInt maxLitIndex;
static sqInt methodAbortTrampolines[4];
static sqInt methodBytesFreedSinceLastCompaction;
static sqInt methodCount;
static sqInt methodHeader;
static AbstractInstruction * const methodLabel = &aMethodLabel;
static sqInt methodObj;
static sqInt methodOrBlockNumArgs;
static sqInt methodOrBlockNumTemps;
static sqInt methodZoneBase;
static usqIntptr_t minValidCallAddress;
sqInt missOffset;
static usqInt mzFreeStart;
static sqInt needsFrame;
static sqInt nextLiteralIndex;
static AbstractInstruction * noCheckEntry;
static sqInt numAbstractOpcodes;
static sqInt numExtB;
static usqInt objectReferencesInRuntime[NumObjRefsInRuntime+1];
static sqInt opcodeIndex;
static CogMethod *openPICList = 0;
static sqInt openPICSize;
static sqInt ordinarySendTrampolines[NumSendTrampolines];
static sqInt picAbortTrampolines[4];
static AbstractInstruction * picInterpretAbort;
static sqInt picMissTrampolines[4];
static void (*postCompileHook)(CogMethod *);
static AbstractInstruction * primInvokeInstruction;
static sqInt primitiveIndex;
static AbstractInstruction * primSetFunctionLabel;
void (*realCECallCogCodePopReceiverAndClassRegs)(void);
void (*realCECallCogCodePopReceiverArg0Regs)(void);
void (*realCECallCogCodePopReceiverArg1Arg0Regs)(void);
void (*realCECallCogCodePopReceiverReg)(void);
void (*realCEEnterCogCodePopReceiverReg)(void);
static sqInt receiverTags;
static sqInt regArgsHaveBeenPushed;
static sqInt runtimeObjectRefIndex;
static AbstractInstruction * sendMiss;
static sqInt simSpillBase;
static SimStackEntry simStack[70];
static sqInt simStackPtr;
static AbstractInstruction * stackCheckLabel;
static AbstractInstruction * stackOverflowCall;
static sqInt statCompileFullBlockCount;
static sqInt statCompileFullBlockUsecs;
static sqInt statCompileMethodCount;
static sqInt statCompileMethodUsecs;
static sqInt superSendTrampolines[NumSendTrampolines];
static sqInt tempOop;
int traceFlags = 8 /* prim trace log on by default */;
sqInt traceStores;
static char *trampolineAddresses[NumTrampolines*2];
static sqInt trampolineTableIndex;
static sqInt useTwoPaths;
static usqInt youngReferrers;


/*** Macros ***/
#define seeAlso(self, msg) 
#define unalignedLongAtput(byteAddress,aWord) memcpy((void*)byteAddress, &aWord, sizeof(sqInt))
#define abstractInstructionAt(index) (&abstractOpcodes[index])
#define backEnd() backEnd
#define blockAlignment() 8
#define breakOnImplicitReceiver() (traceFlags & 64)
#define ceBaseFrameReturnPC() ceBaseFrameReturnTrampoline
#define ceCannotResumePC() ((usqInt)ceCannotResumeTrampoline)
#define ceCheckFeatures() ceCheckFeaturesFunction()
#define ceReturnToInterpreterPC() ((usqInt)ceReturnToInterpreterTrampoline)
#define cFramePointerAddress() ((usqIntptr_t)&CFramePointer)
#define cogitTryLockVMOwner() (ceTryLockVMOwner() != 0)
#define cogitUnlockVMOwner() ceUnlockVMOwner()
#define compileSendTrace() ((traceFlags & 258) == 258)
#define cr() putchar('\n')
#define cStackPointerAddress() ((usqIntptr_t)&CStackPointer)
#define entryOffset() cmEntryOffset
#define generatorAt(index) (&generatorTable[index])
#define getCFramePointer() CFramePointer
#define getCStackPointer() CStackPointer
#define getIsObjectReference() 2
#define halt() warning("halt")
#define haltmsg(msg) warning("halt: " msg)
#define interpretOffset() missOffset
#define maxCogCodeSize() (16*1024*1024)
#define methodLabel() methodLabel
#define methodZoneBase() methodZoneBase
#define minCallAddress() minValidCallAddress
#define noCheckEntryOffset() cmNoCheckEntryOffset
#define printNum(n) vm_printf("%" PRIdSQINT, (sqInt) (n))
#define printOnTrace() (traceFlags & 1)
#define print(aString) vm_printf("%s", aString)
#define recordBlockTrace() (traceFlags & 4)
#define recordEventTrace() (traceFlags & 16)
#define recordOverflowTrace() (traceFlags & 32)
#define recordPrimTrace() (traceFlags & 8)
#define recordSendTrace() (traceFlags & 2)
#define reportError(n) warning("compilation error")
#define setCFramePointer(theFP) (CFramePointer = (void *)(theFP))
#define setCStackPointer(theSP) (CStackPointer = (void *)(theSP))
#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 freeStart() mzFreeStart
#define limitZony() ((CogMethod *)mzFreeStart)
#define methodBytesFreedSinceLastCompaction() methodBytesFreedSinceLastCompaction
#define roundUpLength(numBytes) ((numBytes) + 7 & -8)
#define youngReferrers() youngReferrers
#define maybeConstant(sse) ((sse)->constant)
#define literalInstructionAt(index) (&literals[index])
#define fullBlockEntryOffset() cbEntryOffset
#define fullBlockNoContextSwitchEntryOffset() cbNoSwitchEntryOffset
#define fixupAtIndex(index) (&fixups[index])
#define simSelf() simStack
#define simStackAt(index) (simStack + (index))
#define traceDescriptor(ign) 0
#define traceSpill(ign) 0
#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))

/* CogAbstractInstruction>>#addDependent: */
static AbstractInstruction * NoDbgRegParms
addDependent(AbstractInstruction * self_in_addDependent, AbstractInstruction *_anInstruction)
{
	if ((self_in_addDependent->dependent)) {
		(_anInstruction->dependent = (self_in_addDependent->dependent));
	}
	return ((self_in_addDependent->dependent) = _anInstruction);
}
/*	Answer an unused abstract vector register in the liveRegMask. 
	Subclasses with more registers can override to answer them. */
/* CogAbstractInstruction>>#availableVectorRegisterOrNoneFor: */
static sqInt NoDbgRegParms
availableVectorRegisterOrNoneFor(AbstractInstruction * self_in_availableVectorRegisterOrNoneFor, sqInt _liveRegsMask)
{
	if (!(_liveRegsMask & (1U << VReg0))) {
		return VReg0;
	}
	if (!(_liveRegsMask & (1U << VReg1))) {
		return VReg1;
	}
	if (!(_liveRegsMask & (1U << VReg2))) {
		return VReg2;
	}
	if (!(_liveRegsMask & (1U << VReg3))) {
		return VReg3;
	}
	if (!(_liveRegsMask & (1U << VReg4))) {
		return VReg4;
	}
	if (!(_liveRegsMask & (1U << VReg5))) {
		return VReg5;
	}
	if (!(_liveRegsMask & (1U << VReg6))) {
		return VReg6;
	}
	if (!(_liveRegsMask & (1U << VReg7))) {
		return VReg7;
	}
	return NoReg;
}
/*	For out-of-line literal support, clone a literal from a literal. */
/* CogAbstractInstruction>>#cloneLiteralFrom: */
static AbstractInstruction * NoDbgRegParms
cloneLiteralFrom(AbstractInstruction * self_in_cloneLiteralFrom, AbstractInstruction *_existingLiteral)
{
	assert((((_existingLiteral->opcode)) == Literal) && ((((self_in_cloneLiteralFrom->dependent)) == null) && (((self_in_cloneLiteralFrom->address)) == null)));
	(self_in_cloneLiteralFrom->opcode) = Literal;
	(self_in_cloneLiteralFrom->annotation) = (_existingLiteral->annotation);
	{
		(self_in_cloneLiteralFrom->operands)[0] = (_existingLiteral->operands)[0];
		(self_in_cloneLiteralFrom->operands)[1] = (_existingLiteral->operands)[1];
		(self_in_cloneLiteralFrom->operands)[2] = (_existingLiteral->operands)[2];
	}
	return self_in_cloneLiteralFrom;
}
/* CogAbstractInstruction>>#genMoveM32:r:R: */
static AbstractInstruction * NoDbgRegParms
genMoveM32rR(AbstractInstruction * self_in_genMoveM32rR, sqInt _offset, sqInt _baseReg, sqInt _destReg)
{
	AbstractInstruction *_anInstruction;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveM32rR, _offset, _baseReg, _destReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_offset));
	}
	return _anInstruction;
	/* end checkQuickConstant:forInstruction: */
}
/* CogAbstractInstruction>>#genWriteCResultIntoReg: */
static AbstractInstruction * NoDbgRegParms
genWriteCResultIntoReg(AbstractInstruction * self_in_genWriteCResultIntoReg, sqInt _abstractRegister)
{
	sqInt _cResultReg;

	_cResultReg = R0;
	if (_abstractRegister != _cResultReg) {
		genoperandoperand(MoveRR, _cResultReg, _abstractRegister);
	}
	return self_in_genWriteCResultIntoReg;
}
/*	For out-of-line literal support, initialize a sharable literal. */
/* CogAbstractInstruction>>#initializeSharableLiteral: */
static AbstractInstruction * NoDbgRegParms
initializeSharableLiteral(AbstractInstruction * self_in_initializeSharableLiteral, sqInt _literal)
{
	(self_in_initializeSharableLiteral->opcode) = Literal;
	(self_in_initializeSharableLiteral->annotation) = null;
	(self_in_initializeSharableLiteral->address) = null;
	(self_in_initializeSharableLiteral->dependent) = null;
	{
		(self_in_initializeSharableLiteral->operands)[0] = _literal;
		(self_in_initializeSharableLiteral->operands)[1] = 1;
		(self_in_initializeSharableLiteral->operands)[2] = -1;
	}
	return self_in_initializeSharableLiteral;
}
/*	For out-of-line literal support, initialize an unsharable literal. */
/* CogAbstractInstruction>>#initializeUniqueLiteral: */
static AbstractInstruction * NoDbgRegParms
initializeUniqueLiteral(AbstractInstruction * self_in_initializeUniqueLiteral, sqInt _literal)
{
	(self_in_initializeUniqueLiteral->opcode) = Literal;
	(self_in_initializeUniqueLiteral->annotation) = null;
	(self_in_initializeUniqueLiteral->address) = null;
	(self_in_initializeUniqueLiteral->dependent) = null;
	{
		(self_in_initializeUniqueLiteral->operands)[0] = _literal;
		(self_in_initializeUniqueLiteral->operands)[1] = 0;
		(self_in_initializeUniqueLiteral->operands)[2] = -1;
	}
	return self_in_initializeUniqueLiteral;
}
/* CogAbstractInstruction>>#isJump */
static sqInt NoDbgRegParms
isJump(AbstractInstruction * self_in_isJump)
{
	return (((self_in_isJump->opcode)) >= FirstJump) && (((self_in_isJump->opcode)) <= LastJump);
}
/*	Answer if an address can be accessed using the offset in a MoveMw:r:R: or 
	similar instruction. 
	We assume this is true for 32-bit processors and expect 64-bit processors 
	to answer false 
	for values in the interpreter or the object memory. */
/* CogAbstractInstruction>>#isWithinMwOffsetRange: */
static sqInt NoDbgRegParms
isWithinMwOffsetRange(AbstractInstruction * self_in_isWithinMwOffsetRange, sqInt anAddress)
{
	return 1;
}
/*	Set the target of a jump instruction. These all have the target in the 
	first operand. */
/* CogAbstractInstruction>>#jmpTarget: */
static AbstractInstruction * NoDbgRegParms
jmpTarget(AbstractInstruction * self_in_jmpTarget, AbstractInstruction *_anAbstractInstruction)
{
	(self_in_jmpTarget->operands)[0] = ((usqInt) _anAbstractInstruction );
	return _anAbstractInstruction;
}
/*	Answer the constant loaded by the instruction sequence just before this 
	address:  */
/* CogAbstractInstruction>>#literal32BeforeFollowingAddress: */
static sqInt NoDbgRegParms
literal32BeforeFollowingAddress(AbstractInstruction * self_in_literal32BeforeFollowingAddress, sqInt _followingAddress)
{
	return literalBeforeFollowingAddress(self_in_literal32BeforeFollowingAddress, _followingAddress);
}
/*	We assume here that calls and jumps look the same as regards their 
	displacement. This works on at least x86, ARM and x86_64. Processors on 
	which that isn't the 
	case can override as necessary. */
/* CogAbstractInstruction>>#relocateJumpLongBeforeFollowingAddress:by: */
static AbstractInstruction * NoDbgRegParms
relocateJumpLongBeforeFollowingAddressby(AbstractInstruction * self_in_relocateJumpLongBeforeFollowingAddressby, sqInt _pc, sqInt _delta)
{
	relocateCallBeforeReturnPCby(self_in_relocateJumpLongBeforeFollowingAddressby, _pc, _delta);
	return self_in_relocateJumpLongBeforeFollowingAddressby;
}
/*	Relocate a long conditional jump before pc. Default to relocating a 
	non-conditional jump. 
	Processors that have different formats for conditional and unconditional 
	jumps override. */
/* CogAbstractInstruction>>#relocateJumpLongConditionalBeforeFollowingAddress:by: */
static AbstractInstruction * NoDbgRegParms
relocateJumpLongConditionalBeforeFollowingAddressby(AbstractInstruction * self_in_relocateJumpLongConditionalBeforeFollowingAddressby, sqInt _pc, sqInt _delta)
{
	relocateJumpLongBeforeFollowingAddressby(self_in_relocateJumpLongConditionalBeforeFollowingAddressby, _pc, _delta);
	return self_in_relocateJumpLongConditionalBeforeFollowingAddressby;
}
/* CogAbstractInstruction>>#resolveJumpTarget */
static AbstractInstruction * NoDbgRegParms
resolveJumpTarget(AbstractInstruction * self_in_resolveJumpTarget)
{
	BytecodeFixup *_fixup;

	assert(isJump(self_in_resolveJumpTarget));
	_fixup = ((BytecodeFixup *) ((self_in_resolveJumpTarget->operands)[0]) );
	if (addressIsInFixups(_fixup)) {
		assert(addressIsInInstructions((_fixup->targetInstruction)));
		jmpTarget(self_in_resolveJumpTarget, (_fixup->targetInstruction));
	}
	return self_in_resolveJumpTarget;
}
/*	C6.2.4 ADD (immediate) 
	 
	Add (immediate) adds a register value and an optionally-shifted immediate 
	value, and writes the result to the destination register. 
	 
	ADD <Xd|SP>, <Xn|SP>, #<imm>{, <shift>} 
	 
	if shift = 1 the immediate will be shifted by 12 
	 */
/* CogARMv8Compiler>>#addSize:sourceRegister:shift:immediate12:destinationRegister: */
static sqInt NoDbgRegParms
addSizesourceRegistershiftimmediate12destinationRegister(AbstractInstruction * self_in_addSizesourceRegistershiftimmediate12destinationRegister, sqInt _is64Bits, sqInt _sourceRegister, sqInt _shift, sqInt _immediate12bitValue, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) _is64Bits ) << 0x1F) ) | ((34U << 23) | (((sqInt) (((usqInt) (_shift & 1) ) << 22) ) | (((sqInt) (((usqInt) _immediate12bitValue ) << 10) ) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)))));
}
/*	C6.2.7 ADDS (extended register) 
	 
	Add (extended register), setting flags, adds a register value and a sign 
	or zero-extended register value, followed by an optional left shift 
	amount, and writes the result to the destination register. The argument 
	that is extended from the <Rm> register can be a byte, halfword, word, or 
	doubleword. It updates the condition flags based on the result. 
	 
	ADDS <Xd>, <Xn|SP>, <R><m>{, <extend> {#<amount>}} */
/* CogARMv8Compiler>>#addsExtendedSize:leftRegisterMaybeSP:shiftedRightRegister:option:shiftOffset:destinationRegister: */
static sqInt NoDbgRegParms
addsExtendedSizeleftRegisterMaybeSPshiftedRightRegisteroptionshiftOffsetdestinationRegister(AbstractInstruction * self_in_addsExtendedSizeleftRegisterMaybeSPshiftedRightRegisteroptionshiftOffsetdestinationRegister, sqInt _is64Bits, sqInt _leftRegister, sqInt _rightRegister, sqInt _option, sqInt _immediate3bitValue, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) _is64Bits ) << 0x1F) ) | ((345U << 21) | (((sqInt) (((usqInt) (_rightRegister & 0x1F) ) << 16) ) | (((sqInt) (((usqInt) (_option & 3) ) << 13) ) | (((sqInt) (((usqInt) (_immediate3bitValue & 7) ) << 10) ) | (((sqInt) (((usqInt) (_leftRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F))))));
}
/*	C6.2.9 ADDS (shifted register) 
	 
	Add (shifted register), setting flags, adds a register value and an 
	optionally-shifted register value, and writes the result to the 
	destination register. It updates the condition flags based on the result. 
	 
	ADDS <Xd>, <Xn>, <Xm>{, <shift> #<amount>} 
	 
	LSL when shift = 00 
	LSR when shift = 01 
	ASR when shift = 10 */
/* CogARMv8Compiler>>#addsSize:leftRegister:shiftedRightRegister:shiftType:shiftOffset:destinationRegister: */
static sqInt NoDbgRegParms
addsSizeleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister(AbstractInstruction * self_in_addsSizeleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister, sqInt _is64Bits, sqInt _leftRegister, sqInt _rightRegister, sqInt _shiftType, sqInt _immediate6bitValue, sqInt _destinationRegister)
{
	return arithmeticShiftedRegisterSizeisSubstractionsetFlagsleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister(self_in_addsSizeleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister, _is64Bits, 0, 1, _leftRegister, _rightRegister, _shiftType, _immediate6bitValue, _destinationRegister);
}
/*	C6.2.8 ADDS (immediate) 
	 
	Add (immediate), setting flags, adds a register value and an 
	optionally-shifted immediate value, and writes the result to the 
	destination register. It updates the condition flags based on the result. 
	 
	ADDS <Xd>, <Xn|SP>, #<imm>{, <shift>} */
/* CogARMv8Compiler>>#addsSize:sourceRegister:immediate12BitValue:shifted:destinationRegister: */
static sqInt NoDbgRegParms
addsSizesourceRegisterimmediate12BitValueshifteddestinationRegister(AbstractInstruction * self_in_addsSizesourceRegisterimmediate12BitValueshifteddestinationRegister, sqInt _is64Bits, sqInt _leftRegister, sqInt _immediate12BitValue, sqInt _shiftedFlag, sqInt _destinationRegister)
{
	return arithmeticImmediateSizeisSubstractionsetFlagssourceRegisterimmediate12BitValueshifteddestinationRegister(self_in_addsSizesourceRegisterimmediate12BitValueshifteddestinationRegister, _is64Bits, 0, 1, _leftRegister, _immediate12BitValue, _shiftedFlag, _destinationRegister);
}
/*	 
	C7.2.49 FADD (vector) 
	 
	FADD <Vd>.<T>, <Vn>.<T>, <Vm>.<T> 
	 
	This instruction adds corresponding vector elements in the two source 
	SIMD&FP registers, writes the result into a vector, and writes the vector 
	to the destination SIMD&FP register. 
	All the values in this instruction are floating-point values. */
/* CogARMv8Compiler>>#addT:q:term1:term2:dest: */
static sqInt NoDbgRegParms
addTqterm1term2dest(AbstractInstruction * self_in_addTqterm1term2dest, sqInt _t, sqInt _q, sqInt _vectorReg1, sqInt _vectorReg2, sqInt _vectorRegSum)
{
	return ((sqInt) (((usqInt) _q ) << 30) ) | ((14U << 24) | (((sqInt) (((usqInt) (_t & 1) ) << 22) ) | ((1U << 21) | (((sqInt) (((usqInt) (_vectorReg2 & 0x1F) ) << 16) ) | ((53U << 10) | (((sqInt) (((usqInt) (_vectorReg1 & 0x1F) ) << 5) ) | (_vectorRegSum & 0x1F)))))));
}
/* CogARMv8Compiler>>#add:rn:imm:ror: */
static sqInt NoDbgRegParms
addrnimmror(AbstractInstruction * self_in_addrnimmror, sqInt _destReg, sqInt _srcReg, sqInt _immediate, sqInt _rot)
{
	assert(_rot == 0);
	return addSizesourceRegistershiftimmediate12destinationRegister(self_in_addrnimmror, 1, _srcReg, 0, _immediate, _destReg);
}
/*	C6.2.10 ADR 
	 
	Form PC-relative address adds an immediate value to the PC value to form a 
	PC-relative address, and writes the result to the destination register. 
	 
	ADR <Xd>, <label> 
	 
	signedImmediate21bitValue - Is the program label whose address is to be 
	calculated. Its offset from the address of this instruction, in the range 
	+/-1MB, is encoded in  
	immhi:immlo */
/* CogARMv8Compiler>>#adrSignedImmediate21BitsValue:destinationRegister: */
static sqInt NoDbgRegParms
adrSignedImmediate21BitsValuedestinationRegister(AbstractInstruction * self_in_adrSignedImmediate21BitsValuedestinationRegister, sqInt _signedImmediate21bitValue, sqInt _destinationRegister)
{
	sqInt _immhi;
	sqInt _immlo;
	sqInt _twoComplement;

	_twoComplement = ((_signedImmediate21bitValue < 0)
		 ? (0x1FFFFF - (SQABS(_signedImmediate21bitValue))) + 1
		 : _signedImmediate21bitValue);
	_immhi = ((usqInt) _twoComplement ) >> 2;
	_immlo = _twoComplement & 3;
	return ((sqInt) (((usqInt) _immlo ) << 29) ) | ((16U << 24) | (((sqInt) (((usqInt) _immhi ) << 5) ) | (_destinationRegister & 0x1F)));
}
/*	C6.2.14 ANDS (immediate) 
	 
	Bitwise AND (immediate), setting flags, performs a bitwise AND of a 
	register value and an immediate value, and writes the result to the 
	destination register. It updates the condition flags based on the result. 
	This instruction is used by the alias TST (immediate). See Alias 
	conditions for details of 
	when each alias is preferred. 
	 
	ANDS <Xd|SP>, <Xn>, #<imm> */
/* CogARMv8Compiler>>#andSetFlagsSize:immediate13bitValue:sourceRegister:destinationRegister: */
static sqInt NoDbgRegParms
andSetFlagsSizeimmediate13bitValuesourceRegisterdestinationRegister(AbstractInstruction * self_in_andSetFlagsSizeimmediate13bitValuesourceRegisterdestinationRegister, sqInt _is64Bits, sqInt _logicalEncodedImmediate13BitValue, sqInt _sourceRegister, sqInt _destinationRegister)
{
	return logicalImmediateopcodeimmediate13bitValuesourceRegisterdestinationRegister(self_in_andSetFlagsSizeimmediate13bitValuesourceRegisterdestinationRegister, _is64Bits, 3, _logicalEncodedImmediate13BitValue, _sourceRegister, _destinationRegister);
}
/*	C6.2.15 ANDS (shifted register) 
	 
	Bitwise AND (shifted register), setting flags, performs a bitwise AND of a 
	register value and an optionally-shifted register value, and writes the 
	result to the destination register. It updates the condition flags based 
	on the result. 
	This instruction is used by the alias TST (shifted register). See Alias 
	conditions for details of when each alias is preferred. 
	 
	ANDS <Xd>, <Xn>, <Xm>{, <shift> #<amount>} 
	 
	LSL when shift = 00 LSR when shift = 01 ASR when shift = 10 ROR when shift 
	= 11 */
/* CogARMv8Compiler>>#andSetFlagsSize:shiftedRegister:shiftType:shiftValue:withRegister:destinationRegister: */
static sqInt NoDbgRegParms
andSetFlagsSizeshiftedRegistershiftTypeshiftValuewithRegisterdestinationRegister(AbstractInstruction * self_in_andSetFlagsSizeshiftedRegistershiftTypeshiftValuewithRegisterdestinationRegister, sqInt _is64Bits, sqInt _shiftedRegister, sqInt _shiftType, sqInt _immediate6bitValue, sqInt _sourceRegister2, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) _is64Bits ) << 0x1F) ) | ((106U << 24) | (((sqInt) (((usqInt) (_shiftType & 3) ) << 22) ) | (((sqInt) (((usqInt) (_shiftedRegister & 0x1F) ) << 16) ) | (((sqInt) (((usqInt) (_immediate6bitValue & 0x3F) ) << 10) ) | (((sqInt) (((usqInt) (_sourceRegister2 & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F))))));
}
/*	C4.1.2 Data Processing -- Immediate 
	C3.3.1 Arithmetic (immediate) 
	 
	The Arithmetic (immediate) instructions accept a 12-bit unsigned immediate 
	value, optionally shifted left by 12 bits. 
	The Arithmetic (immediate) instructions that do not set Condition flags 
	can read from and write to the current stack pointer. The flag setting 
	instructions can read from the stack pointer, but they cannot write to it. 
	 
	- is64Bits: single bit indicating if the registers should be interpreted 
	as 64bit (X) or 32bit (W) registers. 
	- substractionFlag: single bit indicating if the instruction is a SUB or 
	ADD - setFlagsFlag: single bit indicating if the instruction should set 
	flags (SUBS vs SUB, ADDS vs ADD) 
	- shiftedFlag: single bit indicating if the immediate value should be 
	shifted 12 bits 
	LSL when shiftType = 00 
	LSR when shiftType = 01 
	ASR when shiftType = 10 */
/* CogARMv8Compiler>>#arithmeticImmediateSize:isSubstraction:setFlags:sourceRegister:immediate12BitValue:shifted:destinationRegister: */
static sqInt NoDbgRegParms
arithmeticImmediateSizeisSubstractionsetFlagssourceRegisterimmediate12BitValueshifteddestinationRegister(AbstractInstruction * self_in_arithmeticImmediateSizeisSubstractionsetFlagssourceRegisterimmediate12BitValueshifteddestinationRegister, sqInt _is64Bits, sqInt _substractionFlag, sqInt _setFlagsFlag, sqInt _sourceRegister, sqInt _immediate12BitValue, sqInt _shiftedFlag, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) (_is64Bits & 1) ) << 0x1F) ) | (((sqInt) (((usqInt) (_substractionFlag & 1) ) << 30) ) | (((sqInt) (((usqInt) (_setFlagsFlag & 1) ) << 29) ) | ((34U << 23) | (((sqInt) (((usqInt) (_shiftedFlag & 1) ) << 22) ) | (((sqInt) (((usqInt) (_immediate12BitValue & 0xFFF) ) << 10) ) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)))))));
}
/*	C4.1.5 Data Processing -- Register 
	 
	- is64Bits: single bit indicating if the registers should be interpreted 
	as 64bit (X) or 32bit (W) registers. 
	- substractionFlag: single bit indicating if the instruction is a SUB or 
	ADD - setFlagsFlag: single bit indicating if the instruction should set 
	flags (SUBS vs SUB, ADDS vs ADD) 
	 
	LSL when shiftType = 00 
	LSR when shiftType = 01 
	ASR when shiftType = 10 */
/* CogARMv8Compiler>>#arithmeticShiftedRegisterSize:isSubstraction:setFlags:leftRegister:shiftedRightRegister:shiftType:shiftOffset:destinationRegister: */
static sqInt NoDbgRegParms
arithmeticShiftedRegisterSizeisSubstractionsetFlagsleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister(AbstractInstruction * self_in_arithmeticShiftedRegisterSizeisSubstractionsetFlagsleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister, sqInt _is64Bits, sqInt _substractionFlag, sqInt _setFlagsFlag, sqInt _leftRegister, sqInt _rightRegister, sqInt _shiftType, sqInt _immediate6bitValue, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) (_is64Bits & 1) ) << 0x1F) ) | (((sqInt) (((usqInt) (_substractionFlag & 1) ) << 30) ) | (((sqInt) (((usqInt) (_setFlagsFlag & 1) ) << 29) ) | ((11U << 24) | (((sqInt) (((usqInt) (_shiftType & 3) ) << 22) ) | (((sqInt) (((usqInt) (_rightRegister & 0x1F) ) << 16) ) | (((sqInt) (((usqInt) (_immediate6bitValue & 0x3F) ) << 10) ) | (((sqInt) (((usqInt) (_leftRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F))))))));
}
/*	C6.2.16 ASR (register) 
	 
	Arithmetic Shift Right (register) shifts a register value right by a 
	variable number of bits, shifting in copies of its sign bit, and writes 
	the result to the destination register. The remainder obtained by dividing 
	the second source register by the data size defines the number of bits by 
	which the first source register is right-shifted. 
	 
	ASR <Xd>, <Xn>, <Xm> 
	 */
/* CogARMv8Compiler>>#arithmeticShiftRightSize:sourceRegister:shiftRegister:destinationRegister: */
static sqInt NoDbgRegParms
arithmeticShiftRightSizesourceRegistershiftRegisterdestinationRegister(AbstractInstruction * self_in_arithmeticShiftRightSizesourceRegistershiftRegisterdestinationRegister, sqInt _is64bits, sqInt _sourceRegister, sqInt _shiftRegister, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) _is64bits ) << 0x1F) ) | ((214U << 21) | (((sqInt) (((usqInt) (_shiftRegister & 0x1F) ) << 16) ) | ((10U << 10) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)))));
}
/*	C6.2.17 ASR (immediate) 
	 
	Arithmetic Shift Right (immediate) shifts a register value right by an 
	immediate number of bits, shifting in copies of the sign bit in the upper 
	bits and zeros in the lower bits, and writes the result to the destination 
	register.  
	ASR <Xd>, <Xn>, #<shift> */
/* CogARMv8Compiler>>#arithmeticShiftRightSize:sourceRegister:shiftValue:destinationRegister: */
static sqInt NoDbgRegParms
arithmeticShiftRightSizesourceRegistershiftValuedestinationRegister(AbstractInstruction * self_in_arithmeticShiftRightSizesourceRegistershiftValuedestinationRegister, sqInt _is64Bits, sqInt _sourceRegister, sqInt _shiftValue, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) _is64Bits ) << 0x1F) ) | ((38U << 23) | (((sqInt) (((usqInt) (_is64Bits & 1) ) << 22) ) | (((sqInt) (((usqInt) (_shiftValue & 0x3F) ) << 16) ) | ((0x3FU << 10) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F))))));
}
/* CogARMv8Compiler>>#assembleSubCq:R: */
static usqInt NoDbgRegParms
assembleSubCqR(AbstractInstruction * self_in_assembleSubCqR, sqInt _quickValue, sqInt registerToUse)
{
	sqInt _aWord;
	int _fits12Bits;
	usqInt _reg;

	_fits12Bits = (_quickValue & 0xFFF) == _quickValue;
	if (_fits12Bits) {
		_reg = (self_in_assembleSubCqR->operands)[1];
		/* begin machineCodeAt:put: */
		_aWord = subsSizesourceRegisterimmediate12BitValueshifteddestinationRegister(self_in_assembleSubCqR, 1, _reg, _quickValue, 0, _reg);
		(self_in_assembleSubCqR->machineCode)[0 / 4] = _aWord;
		/* end machineCodeAt:put: */
		return ((self_in_assembleSubCqR->machineCodeSize) = 4);
	}
	/* begin notYetImplemented */
	/* begin notYetImplemented: */
	{
		logError("Not Yet Implemented!");
		abort();
	}
	/* end notYetImplemented: */
	/* end notYetImplemented */
	return 0;
}
/*	Answer an unused abstract register in the liveRegMask. 
	Subclasses with more registers can override to answer them. 
	N.B. Do /not/ allocate TempReg.Answer an unused abstract register in the liveRegMask. 
	Subclasses with more registers can override to answer them. 
	N.B. Do /not/ allocate TempReg. */
/* CogARMv8Compiler>>#availableRegisterOrNoneFor: */
static sqInt NoDbgRegParms
availableRegisterOrNoneFor(AbstractInstruction * self_in_availableRegisterOrNoneFor, sqInt _liveRegsMask)
{
	if (!(_liveRegsMask & (1U << Extra0Reg))) {
		return Extra0Reg;
	}
	if (!(_liveRegsMask & (1U << Extra1Reg))) {
		return Extra1Reg;
	}
	if (!(_liveRegsMask & (1U << Extra2Reg))) {
		return Extra2Reg;
	}
	{
		if (!(_liveRegsMask & (1U << Arg1Reg))) {
			return Arg1Reg;
		}
		if (!(_liveRegsMask & (1U << Arg0Reg))) {
			return Arg0Reg;
		}
		if (!(_liveRegsMask & (1U << SendNumArgsReg))) {
			return SendNumArgsReg;
		}
		if (!(_liveRegsMask & (1U << ClassReg))) {
			return ClassReg;
		}
		if (!(_liveRegsMask & (1U << ReceiverResultReg))) {
			return ReceiverResultReg;
		}
		return NoReg;
	}
	return 0;
}
/*	C6.2.34 BLR 
	 
	Branch with Link to Register calls a subroutine at an address in a 
	register, setting register X30 to PC+4. 
	 
	BLR <Xn> */
/* CogARMv8Compiler>>#blr: */
static sqInt NoDbgRegParms
blr(AbstractInstruction * self_in_blr, sqInt _registerToUse)
{
	return brwithLink(self_in_blr, _registerToUse, 1);
}
/*	C6.2.33 BL 
	 
	Branch with Link branches to a PC-relative offset, setting the register 
	X30 to PC+4. It provides a hint that this is a subroutine call. 
	 
	26-bit signed PC-relative branch offset variant 
	 
	BL <label> 
	 
	<label> Is the program label to be unconditionally branched to. Its offset 
	from the address of this instruction, in the range +/-128MB, is encoded as 
	imm26 times 4. */
/* CogARMv8Compiler>>#bl: */
static sqInt NoDbgRegParms
bl(AbstractInstruction * self_in_bl, sqInt _immediate26bitValue)
{
	return bwithLink(self_in_bl, _immediate26bitValue, 1);
}
/*	C6.2.25 B.cond 
	 
	Branch conditionally to a label at a PC-relative offset, with a hint that 
	this is not a subroutine call or return. 
	 
	B.<cond> <label> 
	Precondition: 
	the jump target can be encoded as an immediate of 19 bits multiplied by 4 */
/* CogARMv8Compiler>>#branchCondition:offset: */
static sqInt NoDbgRegParms
branchConditionoffset(AbstractInstruction * self_in_branchConditionoffset, sqInt _condition, sqInt _immediate19bitValue)
{
	sqInt _multiplier;
	sqInt _twoComplement;

	assert(((sqInt) (((usqInt) (((usqInt) _immediate19bitValue ) >> 2) ) << 2) ) == _immediate19bitValue);
	assert((0x3FFFF & (((usqInt) (SQABS(_immediate19bitValue)) ) >> 2)) == (((usqInt) (SQABS(_immediate19bitValue)) ) >> 2));
	_multiplier = ((usqInt) _immediate19bitValue ) >> 2;
	_twoComplement = ((_multiplier < 0)
		 ? (0x7FFFF - (SQABS(_multiplier))) + 1
		 : _multiplier);
	return (84U << 24) | (((sqInt) (((usqInt) (_twoComplement & 0x7FFFF) ) << 5) ) | (_condition & 15));
}
/*	C6.2.36 BR 
	 
	Branch to Register branches unconditionally to an address in a register, 
	with a hint that this is not a subroutine return. 
	 
	BR <Xn> */
/* CogARMv8Compiler>>#br: */
static sqInt NoDbgRegParms
br(AbstractInstruction * self_in_br, sqInt _registerToUse)
{
	return brwithLink(self_in_br, _registerToUse, 0);
}
/*	Branch optionally with Link branches to Register calls a subroutine at an 
	address in a register, setting register X30 to PC+4. 
	 
	BRL Xn 
	 */
/* CogARMv8Compiler>>#br:withLink: */
static sqInt NoDbgRegParms
brwithLink(AbstractInstruction * self_in_brwithLink, sqInt _registerToUse, sqInt _withLink)
{
	return (428U << 23) | (((sqInt) (((usqInt) (_withLink & 3) ) << 21) ) | ((0x1FU << 16) | ((sqInt) (((usqInt) (_registerToUse & 0x1F) ) << 5) )));
}
/*	C6.2.26 B 
	 
	Branch causes an unconditional branch to a label at a PC-relative offset, 
	with a hint that this is not a subroutine call or return. 
	 
	26-bit signed PC-relative branch offset variant 
	 
	BL <label> 
	 
	<label> Is the program label to be unconditionally branched to. Its offset 
	from the address of this instruction, in the range +/-128MB, is encoded as 
	imm26 times 4. */
/* CogARMv8Compiler>>#b: */
static sqInt NoDbgRegParms
b(AbstractInstruction * self_in_b, sqInt _immediate26bitValue)
{
	return bwithLink(self_in_b, _immediate26bitValue, 0);
}
/*	Branch optionally with Link branches to a PC-relative offset, setting the 
	register X30 to PC+4. It provides a hint that this is a subroutine call. 
	 
	26-bit signed PC-relative branch offset variant 
	 
	BL <label> 
	 
	<label> Is the program label to be unconditionally branched to. Its offset 
	from the address of this instruction, in the range +/-128MB, is encoded as 
	imm26 times 4. */
/* CogARMv8Compiler>>#b:withLink: */
static sqInt NoDbgRegParms
bwithLink(AbstractInstruction * self_in_bwithLink, sqInt _immediate26bitValue, sqInt _aBoolean)
{
	sqInt _multiplier;
	sqInt _twoComplement;

	seeAlso(self_in_bwithLink, b);
	seeAlso(self_in_bwithLink, bl);
	_multiplier = _immediate26bitValue / 4;
	_twoComplement = ((_multiplier > 0)
		 ? _multiplier
		 : (0x3FFFFFF - (SQABS(_multiplier))) + 1);
	return ((sqInt) (((usqInt) (((_aBoolean)
		 ? 1
		 : 0)) ) << 0x1F) ) | ((5U << 26) | _twoComplement);
}
/*	ARM calls and jumps span +/- 32 mb, more than enough for intra-zone calls 
	and jumps. */
/* CogARMv8Compiler>>#callInstructionByteSize */
static sqInt NoDbgRegParms
callInstructionByteSize(AbstractInstruction * self_in_callInstructionByteSize)
{
	return 4;
}
/*	Answer the address that the call immediately preceding 
	callSiteReturnAddress will jump to.this is also used by #jumpLongTargetBeforeFollowingAddress:. */
/* CogARMv8Compiler>>#callTargetFromReturnAddress: */
static sqInt NoDbgRegParms
callTargetFromReturnAddress(AbstractInstruction * self_in_callTargetFromReturnAddress, sqInt _callSiteReturnAddress)
{
	sqInt _callAddress;
	sqInt _callDistance;
	int _callInstruction;
	sqInt _relativeJump;

	_callAddress = _callSiteReturnAddress - 4;
	_callInstruction = long32At(_callAddress);
	assert((instructionIsB(self_in_callTargetFromReturnAddress, _callInstruction)) || (instructionIsBL(self_in_callTargetFromReturnAddress, _callInstruction)));
	/* begin extractOffsetFromBL: */
	_relativeJump = _callInstruction & 0x3FFFFFF;
	_relativeJump = (((_relativeJump & (1U << 25)) == (1U << 25))
		 ? ((int) (_relativeJump | 0xFC000000U) ) * 4
		 : ((sqInt) (((usqInt) _relativeJump ) << 2) ));
	_callDistance = _relativeJump;
	/* end extractOffsetFromBL: */
	return _callAddress + ((int) _callDistance );
}
/*	C6.2.58 CMN (immediate) 
	 
	Compare Negative (immediate) adds a register value and an 
	optionally-shifted immediate value. It updates the condition flags based 
	on the result, and discards the result. 
	 
	CMN <Xn|SP>, #<imm>{, <shift>} 
	 
	- shiftFlag: single bit indicating if the immediate value should be 
	shifted 12 bits or not */
/* CogARMv8Compiler>>#cmnSize:immediate12BitValue:shiftFlag:register: */
static sqInt NoDbgRegParms
cmnSizeimmediate12BitValueshiftFlagregister(AbstractInstruction * self_in_cmnSizeimmediate12BitValueshiftFlagregister, sqInt _is64bits, sqInt _immediate12BitValue, sqInt _shiftFlag, sqInt _registerToUse)
{
	return addsSizesourceRegisterimmediate12BitValueshifteddestinationRegister(self_in_cmnSizeimmediate12BitValueshiftFlagregister, _is64bits, _registerToUse, _immediate12BitValue, _shiftFlag, 0x1F);
}
/*	C6.2.61 CMP (immediate) 
	 
	Compare (immediate) subtracts an optionally-shifted immediate value from a 
	register value. It updates the condition flags based on the result, and 
	discards the result. 
	 
	CMP <Xn|SP>, #<imm>{, <shift>} 
	 
	- shiftFlag: single bit indicating if the immediate value should be 
	shifted 12 bits or not */
/* CogARMv8Compiler>>#cmpSize:immediate12BitValue:shiftFlag:register: */
static sqInt NoDbgRegParms
cmpSizeimmediate12BitValueshiftFlagregister(AbstractInstruction * self_in_cmpSizeimmediate12BitValueshiftFlagregister, sqInt _is64bits, sqInt _immediate12BitValue, sqInt _shiftFlag, sqInt _registerToUse)
{
	return subsSizesourceRegisterimmediate12BitValueshifteddestinationRegister(self_in_cmpSizeimmediate12BitValueshiftFlagregister, _is64bits, _registerToUse, _immediate12BitValue, _shiftFlag, 0x1F);
}
/*	C6.2.62 CMP (shifted register) 
	 
	Compare (shifted register) subtracts an optionally-shifted register value 
	from a register value. It updates the condition flags based on the result, 
	and discards the result. 
	 
	CMP <Xn>, <Xm>{, <shift> #<amount>} 
	 
	LSL when shift = 00 
	LSR when shift = 01 
	ASR when shift = 10 */
/* CogARMv8Compiler>>#cmpSize:shiftedRegister:shiftType:shiftValue:secondRegister: */
static sqInt NoDbgRegParms
cmpSizeshiftedRegistershiftTypeshiftValuesecondRegister(AbstractInstruction * self_in_cmpSizeshiftedRegistershiftTypeshiftValuesecondRegister, sqInt _is64bits, sqInt _register1, sqInt _shiftType, sqInt _immediate6BitShiftValue, sqInt _register2)
{
	return ((sqInt) (((usqInt) _is64bits ) << 0x1F) ) | ((107U << 24) | (((sqInt) (((usqInt) (_shiftType & 3) ) << 22) ) | (((sqInt) (((usqInt) (_register1 & 0x1F) ) << 16) ) | (((sqInt) (((usqInt) (_immediate6BitShiftValue & 0x3F) ) << 10) ) | (((sqInt) (((usqInt) (_register2 & 0x1F) ) << 5) ) | 0x1F)))));
}
/*	Because we don't use Thumb, each ARM instruction has 4 bytes. Many 
	abstract opcodes need more than one instruction. Instructions that refer 
	to constants and/or literals depend on literals being stored in-line or 
	out-of-line.  
	N.B. The ^N forms are to get around the bytecode compiler's long branch 
	limits which are exceeded when each case jumps around the otherwise. */
/* CogARMv8Compiler>>#computeMaximumSize */
static sqInt NoDbgRegParms
computeMaximumSize(AbstractInstruction * self_in_computeMaximumSize)
{
	sqInt i;
	usqInt _constant;
	sqInt _constant10;
	sqInt _constant11;
	sqInt _constant2;
	sqInt _constant3;
	sqInt _constant4;
	sqInt _constant5;
	sqInt _constant6;
	sqInt _constant7;
	sqInt _constant8;
	sqInt _constant9;
	int _fits12Bits;
	sqInt _i;
	sqInt _i2;
	sqInt _i3;
	sqInt _i4;
	sqInt _immediate;
	uint64_t _immediate2;
	uint64_t _immediate3;
	uint32_t _immr;
	uint32_t _immr2;
	uint32_t _leadingOnes;
	uint32_t _leadingOnes2;
	uint64_t _mask;
	uint64_t _mask2;
	uint64_t _maskedImmediate;
	uint64_t _maskedImmediate2;
	uint32_t _n;
	uint32_t _n2;
	uint64_t _nimms;
	uint64_t _nimms2;
	sqInt _offset;
	sqInt _originalConstant;
	sqInt _originalConstant2;
	sqInt _shiftedValue;
	int _shiftMagnitude;
	sqInt _signedConstant;
	sqInt _signedConstant2;
	sqInt _signedConstant3;
	uint64_t _size;
	uint64_t _size2;
	uint32_t _trailingOnes;
	uint32_t _trailingOnes2;
	uint32_t _trailingZeros;
	uint32_t _trailingZeros2;
	sqInt _twoComplement;
	sqInt _twoComplement2;
	sqInt _twoComplement3;
	sqInt _twoComplement4;
	sqInt _twoComplement5;
	sqInt _twoComplement6;
	sqInt _value;
	sqInt _value2;
	usqInt _word;

	switch ((self_in_computeMaximumSize->opcode)) {
		case Label:
		{
			return 0;
		}
		case Literal:
		{
			return 8;
		}
		case AlignmentNops:
		{
			return ((self_in_computeMaximumSize->operands)[0]) - 4;
		}
		case Fill32:
		case Nop:
		case Call:
		case JumpR:
		case Jump:
		case JumpLong:
		case JumpZero:
		case JumpNonZero:
		case JumpNegative:
		case JumpNonNegative:
		case JumpOverflow:
		case JumpNoOverflow:
		case JumpCarry:
		case JumpNoCarry:
		case JumpLess:
		case JumpGreaterOrEqual:
		case JumpGreater:
		case JumpLessOrEqual:
		case JumpBelow:
		case JumpAboveOrEqual:
		case JumpAbove:
		case JumpBelowOrEqual:
		case JumpFPEqual:
		case JumpFPNotEqual:
		case JumpFPLess:
		case JumpFPGreaterOrEqual:
		case JumpFPGreater:
		case JumpFPLessOrEqual:
		case JumpFPOrdered:
		case JumpFPUnordered:
		case Stop:
		case AddRR:
		case AndRR:
		case OrRR:
		case XorRR:
		case NegateR:
		case LogicalShiftLeftCqR:
		case LogicalShiftRightCqR:
		case ArithmeticShiftRightCqR:
		case LogicalShiftLeftRR:
		case LogicalShiftRightRR:
		case ArithmeticShiftRightRR:
		case RotateLeftCqR:
		case RotateRightCqR:
		case AddRdRd:
		case CmpRdRd:
		case SubRdRd:
		case MulRdRd:
		case DivRdRd:
		case SqrtRd:
		case XorRdRd:
		case MUL:
		case SMULH:
		case CMPMULOverflow:
		case SDIV:
		case MSUB:
		case MoveCqR:
		case MoveC32R:
		case MoveRR:
		case MoveRdRd:
		case MoveXbrRR:
		case MoveX32rRR:
		case MoveRX32rR:
		case MoveRXbrR:
		case MoveXwrRR:
		case MoveRXwrR:
		case PopR:
		case PushR:
		case ConvertRdRs:
		case ConvertRsRd:
		case ConvertRRd:
		case MoveRdR:
		case MoveRRd:
		case MovePatcheableC32R:
		case DupRVr:
		case St1VrRMw:
		case Ld1VrRMw:
		case FaddSRvRvRv:
		case FsubSRvRvRv:
		{
			return 4;
		}
		case CallFull:
		case JumpFull:
		case AddCwR:
		case AndCwR:
		case CmpCwR:
		case OrCwR:
		case SubCwR:
		case XorCwR:
		{
			return 4 + 4;
		}
		case JumpLongZero:
		case JumpLongNonZero:
		{
			return jumpLongConditionalByteSize(self_in_computeMaximumSize);
		}
		case RetN:
		{
			return ((((self_in_computeMaximumSize->operands)[0]) == 0)
				 ? 4
				 : 8);
		}
		case AddCqR:
		{
			return ((((self_in_computeMaximumSize->operands)[1]) == SP)
				 ? 12
				 : ((_word = (self_in_computeMaximumSize->operands)[0]), (_fits12Bits = (_word & 0xFFF) == _word), ((_fits12Bits)
					 ? 4
					 : 8)));
		}
		case AndCqR:
		{
			/* begin encodeLogicalImmediate:registerSize:ifPossible:ifNotPossible: */
			_immediate2 = ((uint64_t) ((self_in_computeMaximumSize->operands)[0]) );
			if ((_immediate2 == 0) || ((_immediate2 == (~((usqIntptr_t) 0 ))) || 0)) {
				return 8;
			}
			_size = sizeOfregisterSize(self_in_computeMaximumSize, _immediate2, 64);
			_mask = ((usqInt) 0xFFFFFFFFFFFFFFFFULL ) >> (64 - _size);
			_maskedImmediate = _immediate2 & _mask;
			if (isShiftedMask(self_in_computeMaximumSize, _maskedImmediate)) {
				_trailingZeros = trailingZerosOf(self_in_computeMaximumSize, _maskedImmediate);
				_trailingOnes = trailingOnesOf(self_in_computeMaximumSize, ((usqInt) _maskedImmediate ) >> _trailingZeros);
			} else {
				_maskedImmediate = _maskedImmediate | (~((usqIntptr_t) _mask ));
				if (!(isShiftedMask(self_in_computeMaximumSize, ~((usqIntptr_t) _maskedImmediate )))) {
					return 8;
				}
				_leadingOnes = leadingOnesOf(self_in_computeMaximumSize, _maskedImmediate);
				_trailingZeros = 64 - _leadingOnes;
				_trailingOnes = (_leadingOnes + (trailingOnesOf(self_in_computeMaximumSize, _maskedImmediate))) - (64 - _size);
			}
			_immr = (_size - _trailingZeros) & (_size - 1);
			_nimms = ((~((usqIntptr_t) (_size - 1) )) << 1) & 0xFFFFFFFFFFFFFFFFULL;
			_nimms = _nimms | (_trailingOnes - 1);
			_n = ((((usqInt) _nimms ) >> 6) & 1) ^ 1;
			return 4;
			/* end encodeLogicalImmediate:registerSize:ifPossible:ifNotPossible: */
		}
		case AndCqRR:
		case XorCqR:
		{
			/* begin rotateable8bitBitwiseImmediate:ifTrue:ifFalse: */
			_constant2 = (self_in_computeMaximumSize->operands)[0];
			_value = _constant2;
			while (1) {
				if ((_value & 0xFF) == _value) {
					return 4;
				}
				for (_i = 2; _i <= 30; _i += 2) {
					if ((_value & (((0xFFULL << _i) & 0xFFFFFFFFU) | (((usqInt) 0xFF ) >> (32 - _i)))) == _value) {
						return 4;
					}
				}
				if (!(_value == _constant2)) 
					break;
				_value = ((_constant2 < 0)
					 ? -1 - _constant2
					 : ((unsigned int) (~_constant2) ));
			}
			return 8;
			/* end rotateable8bitBitwiseImmediate:ifTrue:ifFalse: */
		}
		case CmpCqR:
		{
			_immediate = SQABS(((sqLong) ((self_in_computeMaximumSize->operands)[0]) ));
			return ((((_immediate & 0xFFF) == _immediate) || (((((usqInt) ((sqInt) (((usqInt) _immediate ) << 12) ) ) >> 12) & 0xFFF) == _immediate))
				 ? 4
				 : 4 + 4);
		}
		case CmpC32R:
		{
			/* begin rotateable8bitSignedImmediate:ifTrue:ifFalse: */
			_constant3 = (self_in_computeMaximumSize->operands)[0];
			_value2 = _constant3;
			while (1) {
				if ((_value2 & 0xFF) == _value2) {
					return 4;
				}
				for (_i2 = 2; _i2 <= 30; _i2 += 2) {
					if ((_value2 & (((0xFFULL << _i2) & 0xFFFFFFFFU) | (((usqInt) 0xFF ) >> (32 - _i2)))) == _value2) {
						return 4;
					}
				}
				if (!((_value2 == _constant3) && (_constant3 != 0))) 
					break;
				_value2 = -_constant3;
			}
			return 4 + 4;
			/* end rotateable8bitSignedImmediate:ifTrue:ifFalse: */
		}
		case OrCqR:
		case TstCqR:
		{
			/* begin encodeLogicalImmediate:registerSize:ifPossible:ifNotPossible: */
			_immediate3 = ((uint64_t) ((self_in_computeMaximumSize->operands)[0]) );
			if ((_immediate3 == 0) || ((_immediate3 == (~((usqIntptr_t) 0 ))) || 0)) {
				return 4 + 4;
			}
			_size2 = sizeOfregisterSize(self_in_computeMaximumSize, _immediate3, 64);
			_mask2 = ((usqInt) 0xFFFFFFFFFFFFFFFFULL ) >> (64 - _size2);
			_maskedImmediate2 = _immediate3 & _mask2;
			if (isShiftedMask(self_in_computeMaximumSize, _maskedImmediate2)) {
				_trailingZeros2 = trailingZerosOf(self_in_computeMaximumSize, _maskedImmediate2);
				_trailingOnes2 = trailingOnesOf(self_in_computeMaximumSize, ((usqInt) _maskedImmediate2 ) >> _trailingZeros2);
			} else {
				_maskedImmediate2 = _maskedImmediate2 | (~((usqIntptr_t) _mask2 ));
				if (!(isShiftedMask(self_in_computeMaximumSize, ~((usqIntptr_t) _maskedImmediate2 )))) {
					return 4 + 4;
				}
				_leadingOnes2 = leadingOnesOf(self_in_computeMaximumSize, _maskedImmediate2);
				_trailingZeros2 = 64 - _leadingOnes2;
				_trailingOnes2 = (_leadingOnes2 + (trailingOnesOf(self_in_computeMaximumSize, _maskedImmediate2))) - (64 - _size2);
			}
			_immr2 = (_size2 - _trailingZeros2) & (_size2 - 1);
			_nimms2 = ((~((usqIntptr_t) (_size2 - 1) )) << 1) & 0xFFFFFFFFFFFFFFFFULL;
			_nimms2 = _nimms2 | (_trailingOnes2 - 1);
			_n2 = ((((usqInt) _nimms2 ) >> 6) & 1) ^ 1;
			return 4;
			/* end encodeLogicalImmediate:registerSize:ifPossible:ifNotPossible: */
		}
		case SubCqR:
		{
			_constant = (self_in_computeMaximumSize->operands)[0];
			if ((_constant & 0xFFF) == _constant) {
				return 4;
			}
 else {
				return 4 + 4;
			}
		}
		case CmpRR:
		{
			return (((((self_in_computeMaximumSize->operands)[0]) == SP) || (((self_in_computeMaximumSize->operands)[1]) == SP))
				 ? 8
				 : 4);
		}
		case SubRR:
		{
			return ((((self_in_computeMaximumSize->operands)[0]) == SP)
				 ? 8
				 : 4);
		}
		case LoadEffectiveAddressMwrR:
		case MoveM16rR:
		{
			/* begin rotateable8bitImmediate:ifTrue:ifFalse: */
			_constant4 = (self_in_computeMaximumSize->operands)[0];
			if ((_constant4 & 0xFF) == _constant4) {
				return 4;
			}
			for (_i3 = 2; _i3 <= 30; _i3 += 2) {
				if ((_constant4 & (((0xFFULL << _i3) & 0xFFFFFFFFU) | (((usqInt) 0xFF ) >> (32 - _i3)))) == _constant4) {
					return 4;
				}
			}
			return 4 + 4;
			/* end rotateable8bitImmediate:ifTrue:ifFalse: */
		}
		case MoveCwR:
		{
			return 4;
		}
		case MoveAwR:
		{
			return (((((self_in_computeMaximumSize->operands)[0]) != null) && ((((self_in_computeMaximumSize->operands)[0]) >= (varBaseAddress())) && ((((self_in_computeMaximumSize->operands)[0]) - (varBaseAddress())) < (1U << 12))))
				 ? ((((self_in_computeMaximumSize->operands)[1]) == SP)
					 ? 8
					 : 4)
				 : 4 + 8);
		}
		case MoveRAw:
		{
			return (((((self_in_computeMaximumSize->operands)[1]) != null) && ((((self_in_computeMaximumSize->operands)[1]) >= (varBaseAddress())) && ((((self_in_computeMaximumSize->operands)[1]) - (varBaseAddress())) < (1U << 12))))
				 ? ((((self_in_computeMaximumSize->operands)[0]) == SP)
					 ? 8
					 : 4)
				 : ((((self_in_computeMaximumSize->operands)[0]) == SP)
					 ? (4 + 4) + 4
					 : 4 + 4));
		}
		case MoveAbR:
		case PrefetchAw:
		{
			return (((((self_in_computeMaximumSize->operands)[0]) != null) && ((((self_in_computeMaximumSize->operands)[0]) >= (varBaseAddress())) && ((((self_in_computeMaximumSize->operands)[0]) - (varBaseAddress())) < (1U << 12))))
				 ? 4
				 : 4 + 4);
		}
		case MoveRAb:
		{
			return (((((self_in_computeMaximumSize->operands)[1]) != null) && ((((self_in_computeMaximumSize->operands)[1]) >= (varBaseAddress())) && ((((self_in_computeMaximumSize->operands)[1]) - (varBaseAddress())) < (1U << 12))))
				 ? 4
				 : 4 + 4);
		}
		case MoveRM32r:
		case MoveRMwr:
		{
			/* begin is9BitValue:ifTrue:ifFalse: */
			_originalConstant = (self_in_computeMaximumSize->operands)[1];
			_constant6 = ((sqInt) _originalConstant );
			if (((SQABS(_constant6)) <= 0xFF) || (_constant6 == -256)) {
				_twoComplement = ((_constant6 >= 0)
					 ? _constant6
					 : (0x1FF - (SQABS(_constant6))) + 1);
				{
					return 4;
				}
			} else {
				{
					/* begin shiftable16bitImmediate:ifTrue:ifFalse: */
					_constant5 = (self_in_computeMaximumSize->operands)[1];
					if ((_constant5 & 0xFFFF) == _constant5) {
						{
							return 8;
						}
						goto l6;
					}
					for (_i4 = 0; _i4 <= 1; _i4 += 1) {
						_shiftMagnitude = (1ULL << _i4) * 16;
						_shiftedValue = ((usqInt) _constant5 ) >> _shiftMagnitude;
						if ((((sqInt) (((usqInt) _shiftedValue ) << _shiftMagnitude) ) == _constant5) && ((_shiftedValue & 0xFFFF) == _shiftedValue)) {
							{
								return 8;
							}
							goto l6;
						}
					}
					{
						return 4 + 4;
					}
					l6:
					;
					/* end shiftable16bitImmediate:ifTrue:ifFalse: */
				}
			}
			/* end is9BitValue:ifTrue:ifFalse: */
		}
		break;
		case MoveRsM32r:
		case MoveRdM64r:
		{
			/* begin is12BitValue:ifTrue:ifFalse: */
			_constant7 = (self_in_computeMaximumSize->operands)[1];
			_signedConstant = ((sqInt) _constant7 );
			return (((SQABS(_signedConstant)) <= 0x7FF)
				 ? ((_twoComplement2 = ((_signedConstant >= 0)
					 ? _signedConstant
					 : (0xFFF - (SQABS(_signedConstant))) + 1)), 4)
				 : (/* begin notYetImplemented */ /* begin notYetImplemented: */ (logError("Not Yet Implemented!"), abort()) /* end notYetImplemented: */ /* end notYetImplemented */, 4 + 4));
			/* end is12BitValue:ifTrue:ifFalse: */
		}
		case MoveMbrR:
		{
			/* begin is9BitValue:ifTrue:ifFalse: */
			_originalConstant2 = (self_in_computeMaximumSize->operands)[0];
			_constant8 = ((sqInt) _originalConstant2 );
			return ((((SQABS(_constant8)) <= 0xFF) || (_constant8 == -256))
				 ? ((_twoComplement3 = ((_constant8 >= 0)
					 ? _constant8
					 : (0x1FF - (SQABS(_constant8))) + 1)), 8)
				 : 8);
			/* end is9BitValue:ifTrue:ifFalse: */
		}
		case MoveRM8r:
		case MoveRMbr:
		case MoveRM16r:
		{
			/* begin is12BitValue:ifTrue:ifFalse: */
			_constant9 = (self_in_computeMaximumSize->operands)[1];
			_signedConstant2 = ((sqInt) _constant9 );
			return (((SQABS(_signedConstant2)) <= 0x7FF)
				 ? ((_twoComplement4 = ((_signedConstant2 >= 0)
					 ? _signedConstant2
					 : (0xFFF - (SQABS(_signedConstant2))) + 1)), 4)
				 : 4 + 4);
			/* end is12BitValue:ifTrue:ifFalse: */
		}
		case MoveM32rRs:
		case MoveM64rRd:
		{
			/* begin is12BitValue:ifTrue:ifFalse: */
			_constant10 = (self_in_computeMaximumSize->operands)[0];
			_signedConstant3 = ((sqInt) _constant10 );
			return (((SQABS(_signedConstant3)) <= 0x7FF)
				 ? ((_twoComplement5 = ((_signedConstant3 >= 0)
					 ? _signedConstant3
					 : (0xFFF - (SQABS(_signedConstant3))) + 1)), 4)
				 : (/* begin notYetImplemented */ /* begin notYetImplemented: */ (logError("Not Yet Implemented!"), abort()) /* end notYetImplemented: */ /* end notYetImplemented */, 0));
			/* end is12BitValue:ifTrue:ifFalse: */
		}
		case MoveM32rR:
		case MoveMwrR:
		{
			_offset = (self_in_computeMaximumSize->operands)[0];
			if ((_offset >= 0) && ((_offset & 0xFFF) == _offset)) {
				return 4;
			} else {
				/* begin is9BitValue:ifTrue:ifFalse: */
				_constant11 = ((sqInt) _offset );
				if (((SQABS(_constant11)) <= 0xFF) || (_constant11 == -256)) {
					_twoComplement6 = ((_constant11 >= 0)
						 ? _constant11
						 : (0x1FF - (SQABS(_constant11))) + 1);
					{
						return 4;
					}
				} else {
					{
						return 4 + 4;
					}
				}
				/* end is9BitValue:ifTrue:ifFalse: */
			}
		}
		break;
		case PushCw:
		{
			return 4 + 4;
		}
		case PushCq:
		{
			return 4 + 4;
		}
		default:
		error("Case not found and no otherwise clause");
	}
	return 0;
}
/* CogARMv8Compiler>>#concretizeAddCwR */
static usqInt NoDbgRegParms
concretizeAddCwR(AbstractInstruction * self_in_concretizeAddCwR)
{
	sqInt _anOffset;
	sqInt _aWord;

	assert(((self_in_concretizeAddCwR->dependent)) != null);
	loadCwInto(self_in_concretizeAddCwR, ConcreteIPReg);
	/* begin machineCodeAt:put: */
	_anOffset = (self_in_concretizeAddCwR->machineCodeSize);
	_aWord = addsSizeleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister(self_in_concretizeAddCwR, 1, ConcreteIPReg, (self_in_concretizeAddCwR->operands)[1], 0, 0, (self_in_concretizeAddCwR->operands)[1]);
	(self_in_concretizeAddCwR->machineCode)[_anOffset / 4] = _aWord;
	/* end machineCodeAt:put: */
	return ((self_in_concretizeAddCwR->machineCodeSize) = ((self_in_concretizeAddCwR->machineCodeSize)) + 4);
}
/* CogARMv8Compiler>>#concretizeAddRR */
static usqInt NoDbgRegParms
concretizeAddRR(AbstractInstruction * self_in_concretizeAddRR)
{
	sqInt _destinationRegister;
	sqInt _instruction;
	usqInt _leftRegister;
	usqInt _rightRegister;

	_leftRegister = (self_in_concretizeAddRR->operands)[0];
	_destinationRegister = (_rightRegister = (self_in_concretizeAddRR->operands)[1]);
	if (_rightRegister == SP) {
		/* begin notYetImplemented */
		/* begin notYetImplemented: */
		{
			logError("Not Yet Implemented!");
			abort();
		}
		/* end notYetImplemented: */
		/* end notYetImplemented */
	}
	if (_leftRegister == SP) {
		/* begin notYetImplemented */
		/* begin notYetImplemented: */
		{
			logError("Not Yet Implemented!");
			abort();
		}
		/* end notYetImplemented: */
		/* end notYetImplemented */
		_instruction = addsExtendedSizeleftRegisterMaybeSPshiftedRightRegisteroptionshiftOffsetdestinationRegister(self_in_concretizeAddRR, 1, _leftRegister, _rightRegister, 3, 0, _destinationRegister);
	} else {
		_instruction = addsSizeleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister(self_in_concretizeAddRR, 1, _leftRegister, _rightRegister, 0, 0, _destinationRegister);
	}
	/* begin machineCodeAt:put: */
	(self_in_concretizeAddRR->machineCode)[0 / 4] = _instruction;
	/* end machineCodeAt:put: */
	return ((self_in_concretizeAddRR->machineCodeSize) = 4);
}
/* CogARMv8Compiler>>#concretizeAndRR */
static usqInt NoDbgRegParms
concretizeAndRR(AbstractInstruction * self_in_concretizeAndRR)
{
	sqInt _aWord;
	usqInt _dstReg;
	usqInt _srcReg;

	_srcReg = (self_in_concretizeAndRR->operands)[0];
	_dstReg = (self_in_concretizeAndRR->operands)[1];
	/* begin machineCodeAt:put: */
	_aWord = andSetFlagsSizeshiftedRegistershiftTypeshiftValuewithRegisterdestinationRegister(self_in_concretizeAndRR, 1, _srcReg, 0, 0, _dstReg, _dstReg);
	(self_in_concretizeAndRR->machineCode)[0 / 4] = _aWord;
	/* end machineCodeAt:put: */
	return ((self_in_concretizeAndRR->machineCodeSize) = 4);
}
/* CogARMv8Compiler>>#concretizeArithmeticShiftRightRR */
static usqInt NoDbgRegParms
concretizeArithmeticShiftRightRR(AbstractInstruction * self_in_concretizeArithmeticShiftRightRR)
{
	sqInt _aWord;

	/* begin machineCodeAt:put: */
	_aWord = arithmeticShiftRightSizesourceRegistershiftRegisterdestinationRegister(self_in_concretizeArithmeticShiftRightRR, 1, (self_in_concretizeArithmeticShiftRightRR->operands)[1], (self_in_concretizeArithmeticShiftRightRR->operands)[0], (self_in_concretizeArithmeticShiftRightRR->operands)[1]);
	(self_in_concretizeArithmeticShiftRightRR->machineCode)[0 / 4] = _aWord;
	/* end machineCodeAt:put: */
	return ((self_in_concretizeArithmeticShiftRightRR->machineCodeSize) = 4);
}
/*	Generate concrete machine code for the instruction at actualAddress, 
	setting machineCodeSize, and answer the following address.Generate concrete machine code for the instruction at actualAddress, 
	setting machineCodeSize, and answer the following address. */
/* CogARMv8Compiler>>#concretizeAt: */
static sqInt NoDbgRegParms
concretizeAt(AbstractInstruction * self_in_concretizeAt, sqInt _actualAddress)
{
	assert((_actualAddress % 4) == 0);
	{
		(self_in_concretizeAt->address) = _actualAddress;
		dispatchConcretize(self_in_concretizeAt);
		assert((((self_in_concretizeAt->maxSize)) == null) || (((self_in_concretizeAt->maxSize)) >= ((self_in_concretizeAt->machineCodeSize))));
		return _actualAddress + ((self_in_concretizeAt->machineCodeSize));
	}
	return 0;
}
/* CogARMv8Compiler>>#concretizeCMPMULOverflow */
static usqInt NoDbgRegParms
concretizeCMPMULOverflow(AbstractInstruction * self_in_concretizeCMPMULOverflow)
{
	sqInt _aWord;
	usqInt _destinationRegister;
	usqInt _registerA;
	sqInt _registerB;

	_registerA = (self_in_concretizeCMPMULOverflow->operands)[0];
	_registerB = (_destinationRegister = (self_in_concretizeCMPMULOverflow->operands)[1]);
	/* begin machineCodeAt:put: */
	_aWord = cmpSizeshiftedRegistershiftTypeshiftValuesecondRegister(self_in_concretizeCMPMULOverflow, 1, _registerA, 2, 0x3F, _registerB);
	(self_in_concretizeCMPMULOverflow->machineCode)[0 / 4] = _aWord;
	/* end machineCodeAt:put: */
	return ((self_in_concretizeCMPMULOverflow->machineCodeSize) = 4);
}
/* CogARMv8Compiler>>#concretizeCmpCwR */
static usqInt NoDbgRegParms
concretizeCmpCwR(AbstractInstruction * self_in_concretizeCmpCwR)
{
	usqInt constant;
	sqInt _anOffset;
	sqInt _aWord;
	sqInt _aWord2;

	assert(((self_in_concretizeCmpCwR->dependent)) != null);
	/* begin moveCw:intoR: */
	constant = (self_in_concretizeCmpCwR->operands)[0];
	/* begin loadRelativeLiteralIn: */
	assert(((((self_in_concretizeCmpCwR->dependent))->opcode)) == Literal);
	assert(addressIsInCurrentCompilation((((self_in_concretizeCmpCwR->dependent))->address)));
	assert((SQABS(((((self_in_concretizeCmpCwR->dependent))->address)) - (((self_in_concretizeCmpCwR->address)) + 8))) < (1U << 12));
	/* begin machineCodeAt:put: */
	_aWord = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_concretizeCmpCwR, 1, ((((self_in_concretizeCmpCwR->dependent))->address)) - ((self_in_concretizeCmpCwR->address)), ConcreteIPReg);
	(self_in_concretizeCmpCwR->machineCode)[0 / 4] = _aWord;
	/* end machineCodeAt:put: */
	/* end loadRelativeLiteralIn: */
	(self_in_concretizeCmpCwR->machineCodeSize) = 4;
	/* end moveCw:intoR: */
	if (((self_in_concretizeCmpCwR->operands)[1]) == SP) {
		/* begin notYetImplemented */
		/* begin notYetImplemented: */
		{
			logError("Not Yet Implemented!");
			abort();
		}
		/* end notYetImplemented: */
		/* end notYetImplemented */
	}
	/* begin machineCodeAt:put: */
	_anOffset = (self_in_concretizeCmpCwR->machineCodeSize);
	_aWord2 = cmpSizeshiftedRegistershiftTypeshiftValuesecondRegister(self_in_concretizeCmpCwR, 1, (self_in_concretizeCmpCwR->operands)[1], 0, 0, ConcreteIPReg);
	(self_in_concretizeCmpCwR->machineCode)[_anOffset / 4] = _aWord2;
	/* end machineCodeAt:put: */
	return ((self_in_concretizeCmpCwR->machineCodeSize) = 8);
}
/* CogARMv8Compiler>>#concretizeDataOperationCwR: */
static sqInt NoDbgRegParms
concretizeDataOperationCwR(AbstractInstruction * self_in_concretizeDataOperationCwR, sqInt armOpcode)
{
	/* begin notYetImplemented */
	/* begin notYetImplemented: */
	{
		logError("Not Yet Implemented!");
		abort();
	}
	/* end notYetImplemented: */
	/* end notYetImplemented */
	return 0;
}
/*	fill with operand 0 according to the processor's endianness */
/* CogARMv8Compiler>>#concretizeFill32 */
static usqInt NoDbgRegParms
concretizeFill32(AbstractInstruction * self_in_concretizeFill32)
{
	sqInt _aWord;

	/* begin machineCodeAt:put: */
	_aWord = (self_in_concretizeFill32->operands)[0];
	(self_in_concretizeFill32->machineCode)[0 / 4] = _aWord;
	/* end machineCodeAt:put: */
	return ((self_in_concretizeFill32->machineCodeSize) = 4);
}
/* CogARMv8Compiler>>#concretizeInvertibleDataOperationCqR: */
static sqInt NoDbgRegParms
concretizeInvertibleDataOperationCqR(AbstractInstruction * self_in_concretizeInvertibleDataOperationCqR, sqInt armOpcode)
{
	/* begin notYetImplemented */
	/* begin notYetImplemented: */
	{
		logError("Not Yet Implemented!");
		abort();
	}
	/* end notYetImplemented: */
	/* end notYetImplemented */
	return 0;
}
/* CogARMv8Compiler>>#concretizeJumpLong */
static usqInt NoDbgRegParms
concretizeJumpLong(AbstractInstruction * self_in_concretizeJumpLong)
{
	sqInt _aWord;
	sqInt _offset;

	_offset = ((int) ((self_in_concretizeJumpLong->operands)[0]) ) - ((int) ((self_in_concretizeJumpLong->address)) );
	assert(isInImmediateJumpRange(self_in_concretizeJumpLong, _offset));
	/* begin machineCodeAt:put: */
	_aWord = b(self_in_concretizeJumpLong, _offset);
	(self_in_concretizeJumpLong->machineCode)[0 / 4] = _aWord;
	/* end machineCodeAt:put: */
	return ((self_in_concretizeJumpLong->machineCodeSize) = 4);
}
/* CogARMv8Compiler>>#concretizeJumpLongNonZero */
static sqInt NoDbgRegParms
concretizeJumpLongNonZero(AbstractInstruction * self_in_concretizeJumpLongNonZero)
{
	/* begin notYetImplemented */
	/* begin notYetImplemented: */
	{
		logError("Not Yet Implemented!");
		abort();
	}
	/* end notYetImplemented: */
	/* end notYetImplemented */
	return 0;
}
/*	There are no conditional long jumps in AARCH64. 
	Compile this to a sequence as follows: 
	 
	b.ne nonZero 
	b target 
	 
	nonZero: 
	 
	... 
	Calculate the offset between the B and the target. The B is the second 
	instruction thus the -4 */
/* CogARMv8Compiler>>#concretizeJumpLongZero */
static usqInt NoDbgRegParms
concretizeJumpLongZero(AbstractInstruction * self_in_concretizeJumpLongZero)
{
	sqInt _aWord;
	sqInt _aWord2;
	sqInt _offset;

	_offset = (((int) ((self_in_concretizeJumpLongZero->operands)[0]) ) - ((int) ((self_in_concretizeJumpLongZero->address)) )) - 4;
	assert(isInImmediateJumpRange(self_in_concretizeJumpLongZero, _offset));
	/* begin machineCodeAt:put: */
	_aWord = branchConditionoffset(self_in_concretizeJumpLongZero, NE, 8);
	(self_in_concretizeJumpLongZero->machineCode)[0 / 4] = _aWord;
	/* end machineCodeAt:put: */
	/* begin machineCodeAt:put: */
	_aWord2 = b(self_in_concretizeJumpLongZero, _offset);
	(self_in_concretizeJumpLongZero->machineCode)[4 / 4] = _aWord2;
	/* end machineCodeAt:put: */
	return ((self_in_concretizeJumpLongZero->machineCodeSize) = 8);
}
/* CogARMv8Compiler>>#concretizeLogicalShiftLeftRR */
static usqInt NoDbgRegParms
concretizeLogicalShiftLeftRR(AbstractInstruction * self_in_concretizeLogicalShiftLeftRR)
{
	sqInt _aWord;

	/* begin machineCodeAt:put: */
	_aWord = logicalShiftLeftSizesourceRegistershiftRegisterdestinationRegister(self_in_concretizeLogicalShiftLeftRR, 1, (self_in_concretizeLogicalShiftLeftRR->operands)[1], (self_in_concretizeLogicalShiftLeftRR->operands)[0], (self_in_concretizeLogicalShiftLeftRR->operands)[1]);
	(self_in_concretizeLogicalShiftLeftRR->machineCode)[0 / 4] = _aWord;
	/* end machineCodeAt:put: */
	return ((self_in_concretizeLogicalShiftLeftRR->machineCodeSize) = 4);
}
/* CogARMv8Compiler>>#concretizeLogicalShiftRightRR */
static sqInt NoDbgRegParms
concretizeLogicalShiftRightRR(AbstractInstruction * self_in_concretizeLogicalShiftRightRR)
{
	/* begin notYetImplemented */
	/* begin notYetImplemented: */
	{
		logError("Not Yet Implemented!");
		abort();
	}
	/* end notYetImplemented: */
	/* end notYetImplemented */
	return 0;
}
/* CogARMv8Compiler>>#concretizeMUL */
static usqInt NoDbgRegParms
concretizeMUL(AbstractInstruction * self_in_concretizeMUL)
{
	sqInt _aWord;
	usqInt _destinationRegister;
	usqInt _registerA;
	sqInt _registerB;

	_registerA = (self_in_concretizeMUL->operands)[0];
	_registerB = (_destinationRegister = (self_in_concretizeMUL->operands)[1]);
	/* begin machineCodeAt:put: */
	_aWord = mulSizefirstRegistersecondRegisterdestinationRegister(self_in_concretizeMUL, 1, _registerA, _registerB, _destinationRegister);
	(self_in_concretizeMUL->machineCode)[0 / 4] = _aWord;
	/* end machineCodeAt:put: */
	return ((self_in_concretizeMUL->machineCodeSize) = 4);
}
/* CogARMv8Compiler>>#concretizeOrRR */
static usqInt NoDbgRegParms
concretizeOrRR(AbstractInstruction * self_in_concretizeOrRR)
{
	sqInt _aWord;

	/* begin machineCodeAt:put: */
	_aWord = inclusiveOrSizefirstRegistersecondRegisterdestinationRegister(self_in_concretizeOrRR, 1, (self_in_concretizeOrRR->operands)[0], (self_in_concretizeOrRR->operands)[1], (self_in_concretizeOrRR->operands)[1]);
	(self_in_concretizeOrRR->machineCode)[0 / 4] = _aWord;
	/* end machineCodeAt:put: */
	return ((self_in_concretizeOrRR->machineCodeSize) = 4);
}
/* CogARMv8Compiler>>#concretizeSMULH */
static usqInt NoDbgRegParms
concretizeSMULH(AbstractInstruction * self_in_concretizeSMULH)
{
	sqInt _aWord;
	usqInt _destinationRegister;
	usqInt _registerA;
	usqInt _registerB;

	_registerA = (self_in_concretizeSMULH->operands)[0];
	_registerB = (self_in_concretizeSMULH->operands)[1];
	_destinationRegister = (self_in_concretizeSMULH->operands)[2];
	/* begin machineCodeAt:put: */
	_aWord = smulhSizefirstRegistersecondRegisterdestinationRegister(self_in_concretizeSMULH, 1, _registerA, _registerB, _destinationRegister);
	(self_in_concretizeSMULH->machineCode)[0 / 4] = _aWord;
	/* end machineCodeAt:put: */
	return ((self_in_concretizeSMULH->machineCodeSize) = 4);
}
/*	In ARM destReg <- leftReg - rightReg */
/* CogARMv8Compiler>>#concretizeSubRR */
static usqInt NoDbgRegParms
concretizeSubRR(AbstractInstruction * self_in_concretizeSubRR)
{
	sqInt _aWord;
	sqInt _aWord2;
	usqInt _destReg;
	sqInt _instruction;
	usqInt _leftReg;
	usqInt _rightReg;

	_leftReg = (self_in_concretizeSubRR->operands)[1];
	_rightReg = (self_in_concretizeSubRR->operands)[0];
	_destReg = (self_in_concretizeSubRR->operands)[1];
	if (_rightReg == SP) {
		/* begin machineCodeAt:put: */
		_aWord = movToFromSPrn(self_in_concretizeSubRR, ConcreteIPReg, SP);
		(self_in_concretizeSubRR->machineCode)[0 / 4] = _aWord;
		/* end machineCodeAt:put: */
		/* begin machineCodeAt:put: */
		_aWord2 = subsSizeleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister(self_in_concretizeSubRR, 1, _leftReg, ConcreteIPReg, 0, 0, _destReg);
		(self_in_concretizeSubRR->machineCode)[4 / 4] = _aWord2;
		/* end machineCodeAt:put: */
		return ((self_in_concretizeSubRR->machineCodeSize) = 8);
	}
	if (_leftReg == SP) {
		/* begin notYetImplemented */
		/* begin notYetImplemented: */
		{
			logError("Not Yet Implemented!");
			abort();
		}
		/* end notYetImplemented: */
		/* end notYetImplemented */
		_instruction = subsExtendedSizeleftRegisterMaybeSPshiftedRightRegisteroptionshiftOffsetdestinationRegister(self_in_concretizeSubRR, 1, _leftReg, _rightReg, 3, 0, _destReg);
	} else {
		_instruction = subsSizeleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister(self_in_concretizeSubRR, 1, _leftReg, _rightReg, 0, 0, _destReg);
	}
	/* begin machineCodeAt:put: */
	(self_in_concretizeSubRR->machineCode)[0 / 4] = _instruction;
	/* end machineCodeAt:put: */
	return ((self_in_concretizeSubRR->machineCodeSize) = 4);
}
/* CogARMv8Compiler>>#concretizeXorCwR */
static usqInt NoDbgRegParms
concretizeXorCwR(AbstractInstruction * self_in_concretizeXorCwR)
{
	usqInt constant;
	sqInt _anOffset;
	sqInt _aWord;
	sqInt _aWord2;

	/* begin moveCw:intoR: */
	constant = (self_in_concretizeXorCwR->operands)[0];
	/* begin loadRelativeLiteralIn: */
	assert(((((self_in_concretizeXorCwR->dependent))->opcode)) == Literal);
	assert(addressIsInCurrentCompilation((((self_in_concretizeXorCwR->dependent))->address)));
	assert((SQABS(((((self_in_concretizeXorCwR->dependent))->address)) - (((self_in_concretizeXorCwR->address)) + 8))) < (1U << 12));
	/* begin machineCodeAt:put: */
	_aWord = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_concretizeXorCwR, 1, ((((self_in_concretizeXorCwR->dependent))->address)) - ((self_in_concretizeXorCwR->address)), ConcreteIPReg);
	(self_in_concretizeXorCwR->machineCode)[0 / 4] = _aWord;
	/* end machineCodeAt:put: */
	/* end loadRelativeLiteralIn: */
	(self_in_concretizeXorCwR->machineCodeSize) = 4;
	/* end moveCw:intoR: */
	/* begin machineCodeAt:put: */
	_anOffset = (self_in_concretizeXorCwR->machineCodeSize);
	_aWord2 = exclusiveOrSizefirstRegistersecondRegisterdestinationRegister(self_in_concretizeXorCwR, 1, ConcreteIPReg, (self_in_concretizeXorCwR->operands)[1], ConcreteIPReg);
	(self_in_concretizeXorCwR->machineCode)[_anOffset / 4] = _aWord2;
	/* end machineCodeAt:put: */
	return ((self_in_concretizeXorCwR->machineCodeSize) = ((self_in_concretizeXorCwR->machineCodeSize)) + 4);
}
/* CogARMv8Compiler>>#concretizeXorRR */
static usqInt NoDbgRegParms
concretizeXorRR(AbstractInstruction * self_in_concretizeXorRR)
{
	sqInt _aWord;
	usqInt _registerOne;
	usqInt _registerTwo;

	_registerOne = (self_in_concretizeXorRR->operands)[0];
	_registerTwo = (self_in_concretizeXorRR->operands)[1];
	/* begin machineCodeAt:put: */
	_aWord = exclusiveOrSizefirstRegistersecondRegisterdestinationRegister(self_in_concretizeXorRR, 1, _registerOne, _registerTwo, _registerTwo);
	(self_in_concretizeXorRR->machineCode)[0 / 4] = _aWord;
	/* end machineCodeAt:put: */
	return ((self_in_concretizeXorRR->machineCodeSize) = 4);
}
/*	test for the NV condition code; this isn't allowed as an actual condition 
	and is used to encdoe many of the newer instructions */
/* CogARMv8Compiler>>#conditionIsNotNever: */
static sqInt NoDbgRegParms
conditionIsNotNever(AbstractInstruction * self_in_conditionIsNotNever, sqInt _instr)
{
	return (((usqInt) _instr ) >> 28) < 15;
}
/* CogARMv8Compiler>>#cStackPointer */
static sqInt NoDbgRegParms
cStackPointer(AbstractInstruction * self_in_cStackPointer)
{
	return SP;
}
/*	Attempt to generate concrete machine code for the instruction at address. 
	This is the inner dispatch of concretizeAt: actualAddress which exists 
	only to get around the branch size limits in the SqueakV3 (blue book 
	derived) bytecode set. */
/* CogARMv8Compiler>>#dispatchConcretize */
static void NoDbgRegParms
dispatchConcretize(AbstractInstruction * self_in_dispatchConcretize)
{
	sqInt _actualDestination;
	sqInt _actualSourceRegister;
	sqInt _actualSourceRegister2;
	usqInt _addressOperand;
	sqInt _anOffset;
	sqInt _anOffset2;
	sqInt _anOffset3;
	sqInt _anOffset4;
	sqInt _aWord;
	sqInt _aWord10;
	sqInt _aWord11;
	sqInt _aWord12;
	sqInt _aWord13;
	sqInt _aWord14;
	sqInt _aWord15;
	sqInt _aWord16;
	sqInt _aWord17;
	sqInt _aWord18;
	sqInt _aWord19;
	sqInt _aWord2;
	sqInt _aWord20;
	sqInt _aWord21;
	sqInt _aWord210;
	sqInt _aWord211;
	sqInt _aWord212;
	sqInt _aWord213;
	sqInt _aWord214;
	sqInt _aWord215;
	sqInt _aWord216;
	sqInt _aWord217;
	sqInt _aWord218;
	sqInt _aWord219;
	sqInt _aWord22;
	sqInt _aWord220;
	sqInt _aWord221;
	sqInt _aWord222;
	sqInt _aWord223;
	sqInt _aWord224;
	sqInt _aWord225;
	sqInt _aWord226;
	sqInt _aWord227;
	sqInt _aWord228;
	sqInt _aWord229;
	sqInt _aWord23;
	sqInt _aWord230;
	sqInt _aWord24;
	sqInt _aWord25;
	sqInt _aWord26;
	sqInt _aWord27;
	sqInt _aWord28;
	sqInt _aWord29;
	sqInt _aWord3;
	sqInt _aWord30;
	sqInt _aWord31;
	sqInt _aWord310;
	sqInt _aWord311;
	sqInt _aWord312;
	sqInt _aWord313;
	sqInt _aWord314;
	sqInt _aWord315;
	sqInt _aWord316;
	sqInt _aWord317;
	sqInt _aWord318;
	sqInt _aWord319;
	sqInt _aWord32;
	sqInt _aWord320;
	sqInt _aWord321;
	sqInt _aWord322;
	sqInt _aWord33;
	sqInt _aWord34;
	sqInt _aWord35;
	sqInt _aWord36;
	sqInt _aWord37;
	sqInt _aWord38;
	sqInt _aWord39;
	sqInt _aWord4;
	sqInt _aWord40;
	sqInt _aWord41;
	sqInt _aWord410;
	sqInt _aWord411;
	sqInt _aWord412;
	sqInt _aWord413;
	sqInt _aWord414;
	sqInt _aWord415;
	sqInt _aWord416;
	sqInt _aWord42;
	sqInt _aWord43;
	sqInt _aWord44;
	sqInt _aWord45;
	sqInt _aWord46;
	sqInt _aWord47;
	sqInt _aWord48;
	sqInt _aWord49;
	sqInt _aWord5;
	sqInt _aWord50;
	sqInt _aWord51;
	sqInt _aWord510;
	sqInt _aWord511;
	sqInt _aWord512;
	sqInt _aWord513;
	sqInt _aWord52;
	sqInt _aWord53;
	sqInt _aWord54;
	sqInt _aWord55;
	sqInt _aWord56;
	sqInt _aWord57;
	sqInt _aWord58;
	sqInt _aWord59;
	sqInt _aWord6;
	sqInt _aWord60;
	sqInt _aWord61;
	sqInt _aWord62;
	sqInt _aWord63;
	sqInt _aWord64;
	sqInt _aWord65;
	sqInt _aWord66;
	sqInt _aWord67;
	sqInt _aWord68;
	sqInt _aWord69;
	sqInt _aWord7;
	sqInt _aWord70;
	sqInt _aWord71;
	sqInt _aWord72;
	sqInt _aWord73;
	sqInt _aWord74;
	sqInt _aWord75;
	sqInt _aWord76;
	sqInt _aWord77;
	sqInt _aWord78;
	sqInt _aWord79;
	sqInt _aWord8;
	sqInt _aWord80;
	sqInt _aWord81;
	sqInt _aWord82;
	sqInt _aWord83;
	sqInt _aWord84;
	sqInt _aWord85;
	sqInt _aWord86;
	sqInt _aWord87;
	sqInt _aWord88;
	sqInt _aWord89;
	sqInt _aWord9;
	sqInt _aWord90;
	sqInt _aWord91;
	sqInt _aWord92;
	usqInt _base;
	usqInt _base2;
	usqInt _base3;
	usqInt _base4;
	usqInt _base5;
	usqInt _baseReg;
	usqInt _baseReg2;
	usqInt _baseReg3;
	usqInt _baseReg4;
	usqInt _baseRegister;
	usqInt _baseRegister2;
	usqInt _baseRegister3;
	usqInt _baseRegister4;
	usqInt _baseRegister5;
	sqInt _constant;
	sqInt _constant2;
	sqInt _constant3;
	sqInt _constant4;
	sqInt _constant5;
	AbstractInstruction *_dependentChain;
	usqInt _dest;
	usqInt _dest2;
	usqInt _destAddr;
	usqInt _destAddr2;
	usqInt _destinationReg;
	sqInt _destinationRegister;
	sqInt _destinationRegister2;
	sqInt _destinationRegister3;
	sqInt _destinationRegister4;
	sqInt _destinationRegister5;
	sqInt _destinationRegister6;
	usqInt _destinationRegister7;
	usqInt _destinationRegister8;
	usqInt _destinationScalerRegister;
	usqInt _destReg;
	usqInt _destReg10;
	usqInt _destReg11;
	usqInt _destReg12;
	usqInt _destReg13;
	usqInt _destReg14;
	usqInt _destReg15;
	usqInt _destReg2;
	usqInt _destReg3;
	usqInt _destReg4;
	usqInt _destReg5;
	usqInt _destReg6;
	usqInt _destReg7;
	usqInt _destReg8;
	usqInt _destReg9;
	sqInt _distance;
	sqInt _distance2;
	usqInt _dstReg;
	sqInt _encodedLogicalImmediate;
	sqInt _encodedValue;
	sqInt _encodedValue2;
	usqInt _factor1Reg;
	usqInt _factor2Reg;
	int _fits12Bits;
	int _fits12Bits2;
	int _fits12Bits3;
	int _fits12Bits4;
	int _fitsShifted12Bits;
	int _fitsShifted12Bits2;
	usqInt _fpReg;
	usqInt _fpReg2;
	sqInt _i;
	sqInt _i2;
	sqInt _i22;
	sqInt _i3;
	sqInt _i4;
	sqInt _i5;
	sqInt _i6;
	sqInt _immediate13LogicalValue;
	uint32_t _immr;
	uint32_t _immr2;
	uint32_t _immr3;
	uint32_t _immr4;
	usqInt _index;
	usqInt _index2;
	usqInt _index3;
	usqInt _index4;
	usqInt _index5;
	usqInt _indexRegister;
	usqInt _instrOffset;
	usqInt _instrOffset10;
	usqInt _instrOffset11;
	usqInt _instrOffset12;
	sqInt _instrOffset13;
	usqInt _instrOffset2;
	usqInt _instrOffset3;
	usqInt _instrOffset4;
	usqInt _instrOffset5;
	usqInt _instrOffset6;
	usqInt _instrOffset7;
	usqInt _instrOffset8;
	usqInt _instrOffset9;
	sqInt _instruction;
	sqInt _instruction2;
	sqInt _instruction3;
	sqInt _instruction4;
	sqInt _instruction5;
	sqInt _instruction6;
	sqInt _jumpTarget10;
	sqInt _jumpTarget11;
	sqInt _jumpTarget12;
	sqInt _jumpTarget13;
	sqInt _jumpTarget14;
	sqInt _jumpTarget15;
	sqInt _jumpTarget16;
	sqInt _jumpTarget17;
	sqInt _jumpTarget18;
	sqInt _jumpTarget19;
	AbstractInstruction *_jumpTarget2;
	sqInt _jumpTarget20;
	sqInt _jumpTarget21;
	AbstractInstruction *_jumpTarget210;
	AbstractInstruction *_jumpTarget211;
	AbstractInstruction *_jumpTarget212;
	AbstractInstruction *_jumpTarget213;
	AbstractInstruction *_jumpTarget214;
	AbstractInstruction *_jumpTarget215;
	AbstractInstruction *_jumpTarget216;
	AbstractInstruction *_jumpTarget217;
	AbstractInstruction *_jumpTarget218;
	AbstractInstruction *_jumpTarget219;
	AbstractInstruction *_jumpTarget22;
	AbstractInstruction *_jumpTarget220;
	AbstractInstruction *_jumpTarget221;
	AbstractInstruction *_jumpTarget222;
	AbstractInstruction *_jumpTarget223;
	AbstractInstruction *_jumpTarget224;
	AbstractInstruction *_jumpTarget225;
	AbstractInstruction *_jumpTarget23;
	AbstractInstruction *_jumpTarget24;
	AbstractInstruction *_jumpTarget25;
	AbstractInstruction *_jumpTarget26;
	AbstractInstruction *_jumpTarget27;
	AbstractInstruction *_jumpTarget28;
	AbstractInstruction *_jumpTarget29;
	sqInt _jumpTarget30;
	sqInt _jumpTarget31;
	sqInt _jumpTarget32;
	sqInt _jumpTarget33;
	sqInt _jumpTarget34;
	sqInt _jumpTarget4;
	sqInt _jumpTarget5;
	sqInt _jumpTarget6;
	sqInt _jumpTarget7;
	sqInt _jumpTarget8;
	sqInt _jumpTarget9;
	uint32_t _leadingOnes;
	uint32_t _leadingOnes2;
	uint32_t _leadingOnes3;
	uint32_t _leadingOnes4;
	uint64_t _mask;
	uint64_t _mask2;
	uint64_t _mask3;
	uint64_t _mask4;
	uint64_t _maskedImmediate;
	uint64_t _maskedImmediate2;
	uint64_t _maskedImmediate3;
	uint64_t _maskedImmediate4;
	usqInt _memoryR;
	usqInt _minuendReg;
	usqInt _minuendVectorRegister;
	uint32_t _n;
	uint32_t _n2;
	uint32_t _n3;
	uint32_t _n4;
	uint64_t _nimms;
	uint64_t _nimms2;
	uint64_t _nimms3;
	uint64_t _nimms4;
	usqInt _offset;
	sqInt _offset10;
	sqInt _offset11;
	sqInt _offset12;
	sqInt _offset13;
	sqInt _offset14;
	sqInt _offset15;
	sqInt _offset16;
	sqInt _offset17;
	sqInt _offset18;
	sqInt _offset19;
	usqInt _offset2;
	sqInt _offset20;
	sqInt _offset21;
	sqInt _offset22;
	sqInt _offset23;
	sqInt _offset24;
	sqInt _offset25;
	sqInt _offset26;
	sqInt _offset27;
	sqInt _offset28;
	sqInt _offset29;
	sqInt _offset3;
	sqInt _offset30;
	sqInt _offset31;
	sqInt _offset32;
	sqInt _offset33;
	sqInt _offset34;
	usqInt _offset35;
	sqInt _offset36;
	sqInt _offset37;
	sqInt _offset38;
	sqInt _offset39;
	sqInt _offset4;
	sqInt _offset40;
	sqInt _offset41;
	usqInt _offset42;
	usqInt _offset43;
	sqInt _offset5;
	sqInt _offset6;
	sqInt _offset7;
	sqInt _offset8;
	sqInt _offset9;
	int _opCode;
	int _opCode2;
	sqInt _p;
	int _q;
	int _q2;
	int _q3;
	int _q4;
	int _q5;
	sqInt _quickConstant;
	sqInt _quickConstant2;
	sqInt _quickImmediate;
	sqInt _quickImmediate2;
	sqInt _rd;
	sqInt _rd2;
	usqInt _reg;
	usqInt _reg2;
	usqInt _reg3;
	usqInt _reg4;
	usqInt _reg5;
	usqInt _reg6;
	usqInt _regA;
	usqInt _regB;
	usqInt _regDenominator;
	usqInt _regDestination;
	usqInt _register1;
	usqInt _register2;
	usqInt _registerA;
	usqInt _registerA2;
	usqInt _registerA3;
	usqInt _registerA4;
	usqInt _registerB;
	usqInt _registerB2;
	usqInt _registerB3;
	usqInt _registerB4;
	usqInt _registerToUse;
	usqInt _registerToUse2;
	usqInt _regLHS;
	usqInt _regLHS2;
	usqInt _regNumerator;
	usqInt _regRHS;
	usqInt _rn;
	usqInt _rn2;
	sqInt _rotation;
	sqInt _rotation2;
	sqInt _shiftedValue;
	sqInt _shiftedValue2;
	sqInt _shiftedValue22;
	sqInt _shiftedValue3;
	sqInt _shiftedValue4;
	sqInt _shiftedValue5;
	sqInt _shiftedValue6;
	int _shiftMagnitude;
	int _shiftMagnitude2;
	int _shiftMagnitude22;
	int _shiftMagnitude3;
	int _shiftMagnitude4;
	int _shiftMagnitude5;
	int _shiftMagnitude6;
	sqInt _shiftValue;
	sqInt _signedConstant;
	sqInt _signedConstant2;
	uint64_t _size;
	uint64_t _size2;
	uint64_t _size3;
	uint64_t _size4;
	usqInt _size5;
	usqInt _size6;
	usqInt _size7;
	usqInt _size8;
	usqInt _size9;
	usqInt _sourceDoublePrecisionRegister;
	usqInt _sourceRegister;
	usqInt _sourceRegister2;
	usqInt _sourceRegister3;
	usqInt _src;
	usqInt _src2;
	usqInt _src3;
	usqInt _srcAddr;
	usqInt _srcAddr2;
	usqInt _srcReg;
	usqInt _srcReg10;
	usqInt _srcReg11;
	usqInt _srcReg12;
	usqInt _srcReg13;
	usqInt _srcReg14;
	usqInt _srcReg15;
	usqInt _srcReg16;
	usqInt _srcReg17;
	usqInt _srcReg18;
	usqInt _srcReg19;
	usqInt _srcReg2;
	usqInt _srcReg3;
	usqInt _srcReg4;
	usqInt _srcReg5;
	usqInt _srcReg6;
	usqInt _srcReg7;
	usqInt _srcReg8;
	usqInt _srcReg9;
	usqInt _subtrahendVectorRegister;
	int _t;
	int _t2;
	int _t3;
	int _t4;
	int _t5;
	uint32_t _trailingOnes;
	uint32_t _trailingOnes2;
	uint32_t _trailingOnes3;
	uint32_t _trailingOnes4;
	uint32_t _trailingZeros;
	uint32_t _trailingZeros2;
	uint32_t _trailingZeros3;
	uint32_t _trailingZeros4;
	sqInt _twoComplement;
	sqInt _twoComplement2;
	sqInt _twoComplement3;
	sqInt _twoComplement4;
	sqInt _twoComplement5;
	sqInt _twoComplement6;
	sqInt _twoComplement7;
	sqInt _val;
	sqInt _val2;
	sqInt _val3;
	sqInt _value;
	sqInt _value2;
	usqInt _vectorR;
	usqInt _vectorR2;
	usqInt _vectorReg1;
	usqInt _vectorReg2;
	usqInt _vectorRegSum;
	usqInt _vectorRegSum2;
	usqInt _word;
	sqInt _word2;
	usqInt _word3;
	sqInt _word4;
	sqInt _word5;

	_instrOffset13 = 0;
	_q = 0;
	_q2 = 0;
	_q3 = 0;
	_q4 = 0;
	_q5 = 0;
	_t = 0;
	_t2 = 0;
	_t3 = 0;
	_t4 = 0;
	_t5 = 0;
	if ((self_in_dispatchConcretize->conditionOrNil)) {
		error("ARMv8 / aarch64 does not support conditions encoded in the instruction");
		{
			return;
		}
	}
	switch ((self_in_dispatchConcretize->opcode)) {
		case Label:
		{
			{
				/* begin concretizeLabel */
				_dependentChain = (self_in_dispatchConcretize->dependent);
				while (!(_dependentChain == null)) {
					/* begin updateLabel: */
					if (((_dependentChain->opcode)) != Literal) {
						assert((((_dependentChain->opcode)) == MoveCwR) || (((_dependentChain->opcode)) == PushCw));
						(_dependentChain->operands)[0] = ((self_in_dispatchConcretize->address)) + ((self_in_dispatchConcretize->operands)[1]);
					}
					/* end updateLabel: */
					_dependentChain = (_dependentChain->dependent);
				}
				(self_in_dispatchConcretize->machineCodeSize) = 0;
				/* end concretizeLabel */
				return;
			}
		}
		break;
		case Literal:
		{
			{
				concretizeLiteral(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case AlignmentNops:
		{
			{
				/* begin concretizeAlignmentNops */
				assert((((self_in_dispatchConcretize->machineCodeSize)) % 4) == 0);
				for (_p = 0; _p < ((self_in_dispatchConcretize->machineCodeSize)); _p += 4) {
					/* begin machineCodeAt:put: */
					_aWord = nop(self_in_dispatchConcretize);
					(self_in_dispatchConcretize->machineCode)[_p / 4] = _aWord;
					/* end machineCodeAt:put: */
				}
				/* end concretizeAlignmentNops */
				return;
			}
		}
		break;
		case Fill32:
		{
			{
				concretizeFill32(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case Nop:
		{
			{
				/* begin concretizeNop */
				/* begin machineCodeAt:put: */
				_aWord2 = nop(self_in_dispatchConcretize);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord2;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeNop */
				return;
			}
		}
		break;
		case Call:
		{
			{
				/* begin concretizeCall */
				assert(((self_in_dispatchConcretize->operands)[0]) != 0);
				assert((((self_in_dispatchConcretize->operands)[0]) % 4) == 0);
				_offset3 = ((int) ((self_in_dispatchConcretize->operands)[0]) ) - ((int) ((self_in_dispatchConcretize->address)) );
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset3));
				/* begin machineCodeAt:put: */
				_aWord3 = bl(self_in_dispatchConcretize, _offset3);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord3;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeCall */
				return;
			}
		}
		break;
		case CallFull:
		{
			{
				/* begin concretizeCallFull */
				/* begin longJumpTargetAddress */
				_jumpTarget2 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				if ((addressIsInInstructions(_jumpTarget2)) || (_jumpTarget2 == (methodLabel()))) {
					_jumpTarget2 = ((AbstractInstruction *) ((_jumpTarget2->address)) );
				}
				assert(_jumpTarget2 != 0);
				/* end longJumpTargetAddress */
				/* begin moveCw:intoR: */
				/* begin loadRelativeLiteralIn: */
				assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
				assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
				assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
				/* begin machineCodeAt:put: */
				_aWord4 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord4;
				/* end machineCodeAt:put: */
				/* end loadRelativeLiteralIn: */
				_instrOffset = ((self_in_dispatchConcretize->machineCodeSize) = 4);
				/* end moveCw:intoR: */
				/* begin machineCodeAt:put: */
				_aWord22 = blr(self_in_dispatchConcretize, ConcreteIPReg);
				(self_in_dispatchConcretize->machineCode)[_instrOffset / 4] = _aWord22;
				/* end machineCodeAt:put: */
				assert(_instrOffset == (literalLoadInstructionBytes(self_in_dispatchConcretize)));
				(self_in_dispatchConcretize->machineCodeSize) = _instrOffset + 4;
				/* end concretizeCallFull */
				return;
			}
		}
		break;
		case JumpR:
		{
			{
				/* begin concretizeJumpR */
				_reg = (self_in_dispatchConcretize->operands)[0];
				/* begin machineCodeAt:put: */
				_aWord5 = br(self_in_dispatchConcretize, _reg);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord5;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeJumpR */
				return;
			}
		}
		break;
		case JumpFull:
		{
			{
				/* begin concretizeJumpFull */
				/* begin longJumpTargetAddress */
				_jumpTarget22 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				if ((addressIsInInstructions(_jumpTarget22)) || (_jumpTarget22 == (methodLabel()))) {
					_jumpTarget22 = ((AbstractInstruction *) ((_jumpTarget22->address)) );
				}
				assert(_jumpTarget22 != 0);
				/* end longJumpTargetAddress */
				/* begin moveCw:intoR: */
				/* begin loadRelativeLiteralIn: */
				assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
				assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
				assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
				/* begin machineCodeAt:put: */
				_aWord6 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord6;
				/* end machineCodeAt:put: */
				/* end loadRelativeLiteralIn: */
				_instrOffset2 = ((self_in_dispatchConcretize->machineCodeSize) = 4);
				/* end moveCw:intoR: */
				/* begin machineCodeAt:put: */
				_aWord23 = br(self_in_dispatchConcretize, ConcreteIPReg);
				(self_in_dispatchConcretize->machineCode)[_instrOffset2 / 4] = _aWord23;
				/* end machineCodeAt:put: */
				assert(_instrOffset2 == (literalLoadInstructionBytes(self_in_dispatchConcretize)));
				(self_in_dispatchConcretize->machineCodeSize) = _instrOffset2 + 4;
				/* end concretizeJumpFull */
				return;
			}
		}
		break;
		case JumpLong:
		{
			{
				concretizeJumpLong(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case JumpLongZero:
		{
			{
				concretizeJumpLongZero(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case JumpLongNonZero:
		{
			{
				concretizeJumpLongNonZero(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case Jump:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget23 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget23);
				if ((addressIsInInstructions(_jumpTarget23)) || (_jumpTarget23 == (methodLabel()))) {
					_jumpTarget23 = ((AbstractInstruction *) ((_jumpTarget23->address)) );
				}
				assert(_jumpTarget23 != 0);
				_jumpTarget4 = ((sqInt) _jumpTarget23 );
				/* end jumpTargetAddress */
				_offset4 = _jumpTarget4 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset4));
				/* begin machineCodeAt:put: */
				_aWord7 = branchConditionoffset(self_in_dispatchConcretize, AL, _offset4);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord7;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpZero:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget24 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget24);
				if ((addressIsInInstructions(_jumpTarget24)) || (_jumpTarget24 == (methodLabel()))) {
					_jumpTarget24 = ((AbstractInstruction *) ((_jumpTarget24->address)) );
				}
				assert(_jumpTarget24 != 0);
				_jumpTarget5 = ((sqInt) _jumpTarget24 );
				/* end jumpTargetAddress */
				_offset5 = _jumpTarget5 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset5));
				/* begin machineCodeAt:put: */
				_aWord8 = branchConditionoffset(self_in_dispatchConcretize, EQ, _offset5);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord8;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpNonZero:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget25 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget25);
				if ((addressIsInInstructions(_jumpTarget25)) || (_jumpTarget25 == (methodLabel()))) {
					_jumpTarget25 = ((AbstractInstruction *) ((_jumpTarget25->address)) );
				}
				assert(_jumpTarget25 != 0);
				_jumpTarget6 = ((sqInt) _jumpTarget25 );
				/* end jumpTargetAddress */
				_offset6 = _jumpTarget6 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset6));
				/* begin machineCodeAt:put: */
				_aWord9 = branchConditionoffset(self_in_dispatchConcretize, NE, _offset6);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord9;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpNegative:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget26 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget26);
				if ((addressIsInInstructions(_jumpTarget26)) || (_jumpTarget26 == (methodLabel()))) {
					_jumpTarget26 = ((AbstractInstruction *) ((_jumpTarget26->address)) );
				}
				assert(_jumpTarget26 != 0);
				_jumpTarget7 = ((sqInt) _jumpTarget26 );
				/* end jumpTargetAddress */
				_offset7 = _jumpTarget7 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset7));
				/* begin machineCodeAt:put: */
				_aWord10 = branchConditionoffset(self_in_dispatchConcretize, MI, _offset7);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord10;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpNonNegative:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget27 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget27);
				if ((addressIsInInstructions(_jumpTarget27)) || (_jumpTarget27 == (methodLabel()))) {
					_jumpTarget27 = ((AbstractInstruction *) ((_jumpTarget27->address)) );
				}
				assert(_jumpTarget27 != 0);
				_jumpTarget8 = ((sqInt) _jumpTarget27 );
				/* end jumpTargetAddress */
				_offset8 = _jumpTarget8 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset8));
				/* begin machineCodeAt:put: */
				_aWord11 = branchConditionoffset(self_in_dispatchConcretize, PL, _offset8);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord11;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpOverflow:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget28 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget28);
				if ((addressIsInInstructions(_jumpTarget28)) || (_jumpTarget28 == (methodLabel()))) {
					_jumpTarget28 = ((AbstractInstruction *) ((_jumpTarget28->address)) );
				}
				assert(_jumpTarget28 != 0);
				_jumpTarget9 = ((sqInt) _jumpTarget28 );
				/* end jumpTargetAddress */
				_offset9 = _jumpTarget9 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset9));
				/* begin machineCodeAt:put: */
				_aWord12 = branchConditionoffset(self_in_dispatchConcretize, VS, _offset9);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord12;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpNoOverflow:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget29 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget29);
				if ((addressIsInInstructions(_jumpTarget29)) || (_jumpTarget29 == (methodLabel()))) {
					_jumpTarget29 = ((AbstractInstruction *) ((_jumpTarget29->address)) );
				}
				assert(_jumpTarget29 != 0);
				_jumpTarget10 = ((sqInt) _jumpTarget29 );
				/* end jumpTargetAddress */
				_offset10 = _jumpTarget10 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset10));
				/* begin machineCodeAt:put: */
				_aWord13 = branchConditionoffset(self_in_dispatchConcretize, VC, _offset10);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord13;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpCarry:
		case JumpAboveOrEqual:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget210 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget210);
				if ((addressIsInInstructions(_jumpTarget210)) || (_jumpTarget210 == (methodLabel()))) {
					_jumpTarget210 = ((AbstractInstruction *) ((_jumpTarget210->address)) );
				}
				assert(_jumpTarget210 != 0);
				_jumpTarget11 = ((sqInt) _jumpTarget210 );
				/* end jumpTargetAddress */
				_offset11 = _jumpTarget11 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset11));
				/* begin machineCodeAt:put: */
				_aWord14 = branchConditionoffset(self_in_dispatchConcretize, CS, _offset11);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord14;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpNoCarry:
		case JumpBelow:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget211 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget211);
				if ((addressIsInInstructions(_jumpTarget211)) || (_jumpTarget211 == (methodLabel()))) {
					_jumpTarget211 = ((AbstractInstruction *) ((_jumpTarget211->address)) );
				}
				assert(_jumpTarget211 != 0);
				_jumpTarget12 = ((sqInt) _jumpTarget211 );
				/* end jumpTargetAddress */
				_offset12 = _jumpTarget12 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset12));
				/* begin machineCodeAt:put: */
				_aWord15 = branchConditionoffset(self_in_dispatchConcretize, CC, _offset12);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord15;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpLess:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget212 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget212);
				if ((addressIsInInstructions(_jumpTarget212)) || (_jumpTarget212 == (methodLabel()))) {
					_jumpTarget212 = ((AbstractInstruction *) ((_jumpTarget212->address)) );
				}
				assert(_jumpTarget212 != 0);
				_jumpTarget13 = ((sqInt) _jumpTarget212 );
				/* end jumpTargetAddress */
				_offset13 = _jumpTarget13 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset13));
				/* begin machineCodeAt:put: */
				_aWord16 = branchConditionoffset(self_in_dispatchConcretize, LT, _offset13);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord16;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpGreaterOrEqual:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget213 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget213);
				if ((addressIsInInstructions(_jumpTarget213)) || (_jumpTarget213 == (methodLabel()))) {
					_jumpTarget213 = ((AbstractInstruction *) ((_jumpTarget213->address)) );
				}
				assert(_jumpTarget213 != 0);
				_jumpTarget14 = ((sqInt) _jumpTarget213 );
				/* end jumpTargetAddress */
				_offset14 = _jumpTarget14 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset14));
				/* begin machineCodeAt:put: */
				_aWord17 = branchConditionoffset(self_in_dispatchConcretize, GE, _offset14);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord17;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpGreater:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget214 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget214);
				if ((addressIsInInstructions(_jumpTarget214)) || (_jumpTarget214 == (methodLabel()))) {
					_jumpTarget214 = ((AbstractInstruction *) ((_jumpTarget214->address)) );
				}
				assert(_jumpTarget214 != 0);
				_jumpTarget15 = ((sqInt) _jumpTarget214 );
				/* end jumpTargetAddress */
				_offset15 = _jumpTarget15 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset15));
				/* begin machineCodeAt:put: */
				_aWord18 = branchConditionoffset(self_in_dispatchConcretize, GT, _offset15);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord18;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpLessOrEqual:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget215 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget215);
				if ((addressIsInInstructions(_jumpTarget215)) || (_jumpTarget215 == (methodLabel()))) {
					_jumpTarget215 = ((AbstractInstruction *) ((_jumpTarget215->address)) );
				}
				assert(_jumpTarget215 != 0);
				_jumpTarget16 = ((sqInt) _jumpTarget215 );
				/* end jumpTargetAddress */
				_offset16 = _jumpTarget16 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset16));
				/* begin machineCodeAt:put: */
				_aWord19 = branchConditionoffset(self_in_dispatchConcretize, LE, _offset16);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord19;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpAbove:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget216 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget216);
				if ((addressIsInInstructions(_jumpTarget216)) || (_jumpTarget216 == (methodLabel()))) {
					_jumpTarget216 = ((AbstractInstruction *) ((_jumpTarget216->address)) );
				}
				assert(_jumpTarget216 != 0);
				_jumpTarget17 = ((sqInt) _jumpTarget216 );
				/* end jumpTargetAddress */
				_offset17 = _jumpTarget17 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset17));
				/* begin machineCodeAt:put: */
				_aWord20 = branchConditionoffset(self_in_dispatchConcretize, HI, _offset17);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord20;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpBelowOrEqual:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget217 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget217);
				if ((addressIsInInstructions(_jumpTarget217)) || (_jumpTarget217 == (methodLabel()))) {
					_jumpTarget217 = ((AbstractInstruction *) ((_jumpTarget217->address)) );
				}
				assert(_jumpTarget217 != 0);
				_jumpTarget18 = ((sqInt) _jumpTarget217 );
				/* end jumpTargetAddress */
				_offset18 = _jumpTarget18 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset18));
				/* begin machineCodeAt:put: */
				_aWord21 = branchConditionoffset(self_in_dispatchConcretize, LS, _offset18);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord21;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpFPEqual:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget218 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget218);
				if ((addressIsInInstructions(_jumpTarget218)) || (_jumpTarget218 == (methodLabel()))) {
					_jumpTarget218 = ((AbstractInstruction *) ((_jumpTarget218->address)) );
				}
				assert(_jumpTarget218 != 0);
				_jumpTarget19 = ((sqInt) _jumpTarget218 );
				/* end jumpTargetAddress */
				_offset19 = _jumpTarget19 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset19));
				/* begin machineCodeAt:put: */
				_aWord24 = branchConditionoffset(self_in_dispatchConcretize, EQ, _offset19);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord24;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpFPNotEqual:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget219 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget219);
				if ((addressIsInInstructions(_jumpTarget219)) || (_jumpTarget219 == (methodLabel()))) {
					_jumpTarget219 = ((AbstractInstruction *) ((_jumpTarget219->address)) );
				}
				assert(_jumpTarget219 != 0);
				_jumpTarget20 = ((sqInt) _jumpTarget219 );
				/* end jumpTargetAddress */
				_offset20 = _jumpTarget20 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset20));
				/* begin machineCodeAt:put: */
				_aWord25 = branchConditionoffset(self_in_dispatchConcretize, NE, _offset20);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord25;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpFPLess:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget220 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget220);
				if ((addressIsInInstructions(_jumpTarget220)) || (_jumpTarget220 == (methodLabel()))) {
					_jumpTarget220 = ((AbstractInstruction *) ((_jumpTarget220->address)) );
				}
				assert(_jumpTarget220 != 0);
				_jumpTarget21 = ((sqInt) _jumpTarget220 );
				/* end jumpTargetAddress */
				_offset21 = _jumpTarget21 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset21));
				/* begin machineCodeAt:put: */
				_aWord26 = branchConditionoffset(self_in_dispatchConcretize, LT, _offset21);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord26;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpFPGreaterOrEqual:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget221 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget221);
				if ((addressIsInInstructions(_jumpTarget221)) || (_jumpTarget221 == (methodLabel()))) {
					_jumpTarget221 = ((AbstractInstruction *) ((_jumpTarget221->address)) );
				}
				assert(_jumpTarget221 != 0);
				_jumpTarget30 = ((sqInt) _jumpTarget221 );
				/* end jumpTargetAddress */
				_offset22 = _jumpTarget30 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset22));
				/* begin machineCodeAt:put: */
				_aWord27 = branchConditionoffset(self_in_dispatchConcretize, GE, _offset22);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord27;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpFPGreater:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget222 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget222);
				if ((addressIsInInstructions(_jumpTarget222)) || (_jumpTarget222 == (methodLabel()))) {
					_jumpTarget222 = ((AbstractInstruction *) ((_jumpTarget222->address)) );
				}
				assert(_jumpTarget222 != 0);
				_jumpTarget31 = ((sqInt) _jumpTarget222 );
				/* end jumpTargetAddress */
				_offset23 = _jumpTarget31 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset23));
				/* begin machineCodeAt:put: */
				_aWord28 = branchConditionoffset(self_in_dispatchConcretize, GT, _offset23);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord28;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpFPLessOrEqual:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget223 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget223);
				if ((addressIsInInstructions(_jumpTarget223)) || (_jumpTarget223 == (methodLabel()))) {
					_jumpTarget223 = ((AbstractInstruction *) ((_jumpTarget223->address)) );
				}
				assert(_jumpTarget223 != 0);
				_jumpTarget32 = ((sqInt) _jumpTarget223 );
				/* end jumpTargetAddress */
				_offset24 = _jumpTarget32 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset24));
				/* begin machineCodeAt:put: */
				_aWord29 = branchConditionoffset(self_in_dispatchConcretize, LE, _offset24);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord29;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpFPOrdered:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget224 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget224);
				if ((addressIsInInstructions(_jumpTarget224)) || (_jumpTarget224 == (methodLabel()))) {
					_jumpTarget224 = ((AbstractInstruction *) ((_jumpTarget224->address)) );
				}
				assert(_jumpTarget224 != 0);
				_jumpTarget33 = ((sqInt) _jumpTarget224 );
				/* end jumpTargetAddress */
				_offset25 = _jumpTarget33 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset25));
				/* begin machineCodeAt:put: */
				_aWord30 = branchConditionoffset(self_in_dispatchConcretize, VC, _offset25);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord30;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case JumpFPUnordered:
		{
			{
				/* begin concretizeConditionalJump: */
				/* begin computeJumpTargetOffsetPlus: */
				/* begin jumpTargetAddress */
				_jumpTarget225 = ((AbstractInstruction *) ((self_in_dispatchConcretize->operands)[0]) );
				assertSaneJumpTarget(_jumpTarget225);
				if ((addressIsInInstructions(_jumpTarget225)) || (_jumpTarget225 == (methodLabel()))) {
					_jumpTarget225 = ((AbstractInstruction *) ((_jumpTarget225->address)) );
				}
				assert(_jumpTarget225 != 0);
				_jumpTarget34 = ((sqInt) _jumpTarget225 );
				/* end jumpTargetAddress */
				_offset26 = _jumpTarget34 - ((sqInt) ((self_in_dispatchConcretize->address)) );
				/* end computeJumpTargetOffsetPlus: */
				assert(isInImmediateJumpRange(self_in_dispatchConcretize, _offset26));
				/* begin machineCodeAt:put: */
				_aWord31 = branchConditionoffset(self_in_dispatchConcretize, VS, _offset26);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord31;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConditionalJump: */
				return;
			}
		}
		break;
		case RetN:
		{
			{
				/* begin concretizeRetN */
				_offset27 = (self_in_dispatchConcretize->operands)[0];
				if (_offset27 == 0) {
					/* begin machineCodeAt:put: */
					_aWord32 = ret(self_in_dispatchConcretize);
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord32;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					goto l132;
				}
				assert(_offset27 < 0xFF);
				/* begin machineCodeAt:put: */
				_aWord210 = addrnimmror(self_in_dispatchConcretize, SPReg, SPReg, _offset27, 0);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord210;
				/* end machineCodeAt:put: */
				/* begin machineCodeAt:put: */
				_aWord33 = ret(self_in_dispatchConcretize);
				(self_in_dispatchConcretize->machineCode)[4 / 4] = _aWord33;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 8;
				l132:
				;
				/* end concretizeRetN */
				return;
			}
		}
		break;
		case Stop:
		{
			{
				/* begin concretizeStop */
				/* begin machineCodeAt:put: */
				_aWord34 = stop(self_in_dispatchConcretize);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord34;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeStop */
				return;
			}
		}
		break;
		case AddCqR:
		{
			{
				/* begin concretizeAddCqR */
				_word4 = (self_in_dispatchConcretize->operands)[0];
				if (((self_in_dispatchConcretize->operands)[1]) == SP) {
					/* begin notYetImplemented */
					/* begin notYetImplemented: */
					{
						logError("Not Yet Implemented!");
						abort();
					}
					/* end notYetImplemented: */
					/* end notYetImplemented */
					assert((_word4 & 0xFFF) == _word4);
					/* begin machineCodeAt:put: */
					_aWord83 = movSizesourceRegisterMaybeSPdestinationRegisterMaybeSP(self_in_dispatchConcretize, 1, SP, ConcreteIPReg);
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord83;
					/* end machineCodeAt:put: */
					/* begin machineCodeAt:put: */
					_aWord227 = addsSizesourceRegisterimmediate12BitValueshifteddestinationRegister(self_in_dispatchConcretize, 1, ConcreteIPReg, _word4, 0, ConcreteIPReg);
					(self_in_dispatchConcretize->machineCode)[4 / 4] = _aWord227;
					/* end machineCodeAt:put: */
					/* begin machineCodeAt:put: */
					_aWord319 = movSizesourceRegisterMaybeSPdestinationRegisterMaybeSP(self_in_dispatchConcretize, 1, ConcreteIPReg, SP);
					(self_in_dispatchConcretize->machineCode)[8 / 4] = _aWord319;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 12;
					goto l289;
				}
				if (_word4 < 0) {
					assembleSubCqR(self_in_dispatchConcretize, -_word4, (self_in_dispatchConcretize->operands)[1]);
					goto l289;
				}
				_fits12Bits4 = (_word4 & 0xFFF) == _word4;
				if (_fits12Bits4) {
					_reg6 = (self_in_dispatchConcretize->operands)[1];
					/* begin machineCodeAt:put: */
					_aWord414 = addsSizesourceRegisterimmediate12BitValueshifteddestinationRegister(self_in_dispatchConcretize, 1, _reg6, _word4, 0, _reg6);
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord414;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					goto l289;
				}
				concretizeAddCwR(self_in_dispatchConcretize);
				l289:
				;
				/* end concretizeAddCqR */
				return;
			}
		}
		break;
		case AndCqR:
		{
			{
				/* begin concretizeAndCqR */
				_val = (self_in_dispatchConcretize->operands)[0];
				_rn = (self_in_dispatchConcretize->operands)[1];
				_rd = _rn;
				/* begin encodeLogicalImmediate:registerSize:ifPossible:ifNotPossible: */
				if ((((uint64_t) _val ) == 0) || ((((uint64_t) _val ) == (~((usqIntptr_t) 0 ))) || 0)) {
					{
						/* begin moveCw:intoR: */
						/* begin loadRelativeLiteralIn: */
						assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
						assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
						assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
						/* begin machineCodeAt:put: */
						_aWord211 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord211;
						/* end machineCodeAt:put: */
						/* end loadRelativeLiteralIn: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						/* end moveCw:intoR: */
						/* begin machineCodeAt:put: */
						_aWord35 = andSetFlagsSizeshiftedRegistershiftTypeshiftValuewithRegisterdestinationRegister(self_in_dispatchConcretize, 1, ConcreteIPReg, 0, 0, _rn, _rd);
						(self_in_dispatchConcretize->machineCode)[4 / 4] = _aWord35;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 8;
						goto l141;
					}
					goto l137;
				}
				_size = sizeOfregisterSize(self_in_dispatchConcretize, ((uint64_t) _val ), 64);
				_mask = ((usqInt) 0xFFFFFFFFFFFFFFFFULL ) >> (64 - _size);
				_maskedImmediate = ((uint64_t) _val ) & _mask;
				if (isShiftedMask(self_in_dispatchConcretize, _maskedImmediate)) {
					_trailingZeros = trailingZerosOf(self_in_dispatchConcretize, _maskedImmediate);
					_trailingOnes = trailingOnesOf(self_in_dispatchConcretize, ((usqInt) _maskedImmediate ) >> _trailingZeros);
				} else {
					_maskedImmediate = _maskedImmediate | (~((usqIntptr_t) _mask ));
					if (!(isShiftedMask(self_in_dispatchConcretize, ~((usqIntptr_t) _maskedImmediate )))) {
						{
							/* begin moveCw:intoR: */
							/* begin loadRelativeLiteralIn: */
							assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
							assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
							assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
							/* begin machineCodeAt:put: */
							_aWord211 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
							(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord211;
							/* end machineCodeAt:put: */
							/* end loadRelativeLiteralIn: */
							(self_in_dispatchConcretize->machineCodeSize) = 4;
							/* end moveCw:intoR: */
							/* begin machineCodeAt:put: */
							_aWord35 = andSetFlagsSizeshiftedRegistershiftTypeshiftValuewithRegisterdestinationRegister(self_in_dispatchConcretize, 1, ConcreteIPReg, 0, 0, _rn, _rd);
							(self_in_dispatchConcretize->machineCode)[4 / 4] = _aWord35;
							/* end machineCodeAt:put: */
							(self_in_dispatchConcretize->machineCodeSize) = 8;
							goto l141;
						}
						goto l137;
					}
					_leadingOnes = leadingOnesOf(self_in_dispatchConcretize, _maskedImmediate);
					_trailingZeros = 64 - _leadingOnes;
					_trailingOnes = (_leadingOnes + (trailingOnesOf(self_in_dispatchConcretize, _maskedImmediate))) - (64 - _size);
				}
				_immr = (_size - _trailingZeros) & (_size - 1);
				_nimms = ((~((usqIntptr_t) (_size - 1) )) << 1) & 0xFFFFFFFFFFFFFFFFULL;
				_nimms = _nimms | (_trailingOnes - 1);
				_n = ((((usqInt) _nimms ) >> 6) & 1) ^ 1;
				{
					_encodedValue = (((usqInt) _n ) << 12) | ((((usqInt) _immr ) << 6) | (_nimms & 0x3F));
					/* begin machineCodeAt:put: */
					_aWord36 = andSetFlagsSizeimmediate13bitValuesourceRegisterdestinationRegister(self_in_dispatchConcretize, 1, _encodedValue, _rn, _rd);
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord36;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					goto l141;
				}
				l137:
				;
				/* end encodeLogicalImmediate:registerSize:ifPossible:ifNotPossible: */
				l141:
				;
				/* end concretizeAndCqR */
				return;
			}
		}
		break;
		case AndCqRR:
		{
			{
				/* begin concretizeAndCqRR */
				_val3 = (self_in_dispatchConcretize->operands)[0];
				_srcReg12 = (self_in_dispatchConcretize->operands)[1];
				_dstReg = (self_in_dispatchConcretize->operands)[2];
				assert((_val3 & 0x1FFF) == _val3);
				/* begin encodeLogicalImmediate:registerSize:ifPossible:ifNotPossible: */
				if ((((uint64_t) _val3 ) == 0) || ((((uint64_t) _val3 ) == (~((usqIntptr_t) 0 ))) || 0)) {
					{
						/* begin notYetImplemented */
						/* begin notYetImplemented: */
						logError("Not Yet Implemented!");
						abort();
						/* end notYetImplemented: */
						/* end notYetImplemented */
					}
					goto l290;
				}
				_size3 = sizeOfregisterSize(self_in_dispatchConcretize, ((uint64_t) _val3 ), 64);
				_mask3 = ((usqInt) 0xFFFFFFFFFFFFFFFFULL ) >> (64 - _size3);
				_maskedImmediate3 = ((uint64_t) _val3 ) & _mask3;
				if (isShiftedMask(self_in_dispatchConcretize, _maskedImmediate3)) {
					_trailingZeros3 = trailingZerosOf(self_in_dispatchConcretize, _maskedImmediate3);
					_trailingOnes3 = trailingOnesOf(self_in_dispatchConcretize, ((usqInt) _maskedImmediate3 ) >> _trailingZeros3);
				} else {
					_maskedImmediate3 = _maskedImmediate3 | (~((usqIntptr_t) _mask3 ));
					if (!(isShiftedMask(self_in_dispatchConcretize, ~((usqIntptr_t) _maskedImmediate3 )))) {
						{
							/* begin notYetImplemented */
							/* begin notYetImplemented: */
							logError("Not Yet Implemented!");
							abort();
							/* end notYetImplemented: */
							/* end notYetImplemented */
						}
						goto l290;
					}
					_leadingOnes3 = leadingOnesOf(self_in_dispatchConcretize, _maskedImmediate3);
					_trailingZeros3 = 64 - _leadingOnes3;
					_trailingOnes3 = (_leadingOnes3 + (trailingOnesOf(self_in_dispatchConcretize, _maskedImmediate3))) - (64 - _size3);
				}
				_immr3 = (_size3 - _trailingZeros3) & (_size3 - 1);
				_nimms3 = ((~((usqIntptr_t) (_size3 - 1) )) << 1) & 0xFFFFFFFFFFFFFFFFULL;
				_nimms3 = _nimms3 | (_trailingOnes3 - 1);
				_n3 = ((((usqInt) _nimms3 ) >> 6) & 1) ^ 1;
				{
					_encodedLogicalImmediate = (((usqInt) _n3 ) << 12) | ((((usqInt) _immr3 ) << 6) | (_nimms3 & 0x3F));
					/* begin machineCodeAt:put: */
					_aWord84 = andSetFlagsSizeimmediate13bitValuesourceRegisterdestinationRegister(self_in_dispatchConcretize, 1, _encodedLogicalImmediate, _srcReg12, _dstReg);
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord84;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					goto l292;
				}
				l290:
				;
				/* end encodeLogicalImmediate:registerSize:ifPossible:ifNotPossible: */
				goto l292;
				l292:
				;
				/* end concretizeAndCqRR */
				return;
			}
		}
		break;
		case CmpCqR:
		{
			{
				/* begin concretizeCmpCqR */
				_quickImmediate = (self_in_dispatchConcretize->operands)[0];
				_registerToUse = (self_in_dispatchConcretize->operands)[1];
				if (_quickImmediate >= 0) {
					_fits12Bits = (_quickImmediate & 0xFFF) == _quickImmediate;
					if (_fits12Bits) {
						/* begin machineCodeAt:put: */
						_aWord37 = cmpSizeimmediate12BitValueshiftFlagregister(self_in_dispatchConcretize, 1, _quickImmediate, 0, _registerToUse);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord37;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l150;
					}
					_fitsShifted12Bits = ((((usqInt) ((sqInt) (((usqInt) _quickImmediate ) << 12) ) ) >> 12) & 0xFFF) == _quickImmediate;
					if (_fitsShifted12Bits) {
						/* begin machineCodeAt:put: */
						_aWord212 = cmpSizeimmediate12BitValueshiftFlagregister(self_in_dispatchConcretize, 1, ((usqInt) _quickImmediate ) >> 12, 1, _registerToUse);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord212;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l150;
					}
				} else {
					_quickImmediate = SQABS(_quickImmediate);
					_fits12Bits = (_quickImmediate & 0xFFF) == _quickImmediate;
					if (_fits12Bits) {
						/* begin machineCodeAt:put: */
						_aWord38 = cmnSizeimmediate12BitValueshiftFlagregister(self_in_dispatchConcretize, 1, _quickImmediate, 0, _registerToUse);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord38;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l150;
					}
					_fitsShifted12Bits = ((((usqInt) ((sqInt) (((usqInt) _quickImmediate ) << 12) ) ) >> 12) & 0xFFF) == _quickImmediate;
					if (_fitsShifted12Bits) {
						/* begin machineCodeAt:put: */
						_aWord42 = cmnSizeimmediate12BitValueshiftFlagregister(self_in_dispatchConcretize, 1, ((usqInt) _quickImmediate ) >> 12, 1, _registerToUse);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord42;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l150;
					}
				}
				/* begin moveCw:intoR: */
				/* begin loadRelativeLiteralIn: */
				assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
				assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
				assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
				/* begin machineCodeAt:put: */
				_aWord52 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord52;
				/* end machineCodeAt:put: */
				/* end loadRelativeLiteralIn: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end moveCw:intoR: */
				/* begin machineCodeAt:put: */
				_anOffset = (self_in_dispatchConcretize->machineCodeSize);
				_aWord62 = cmpSizeshiftedRegistershiftTypeshiftValuesecondRegister(self_in_dispatchConcretize, 1, ConcreteIPReg, 0, 0, _registerToUse);
				(self_in_dispatchConcretize->machineCode)[_anOffset / 4] = _aWord62;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = ((self_in_dispatchConcretize->machineCodeSize)) + 4;
				l150:
				;
				/* end concretizeCmpCqR */
				return;
			}
		}
		break;
		case OrCqR:
		{
			{
				/* begin concretizeOrCqR */
				_val2 = (self_in_dispatchConcretize->operands)[0];
				_rn2 = (self_in_dispatchConcretize->operands)[1];
				_rd2 = _rn2;
				/* begin encodeLogicalImmediate:registerSize:ifPossible:ifNotPossible: */
				if ((((uint64_t) _val2 ) == 0) || ((((uint64_t) _val2 ) == (~((usqIntptr_t) 0 ))) || 0)) {
					{
						/* begin moveCw:intoR: */
						/* begin loadRelativeLiteralIn: */
						assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
						assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
						assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
						/* begin machineCodeAt:put: */
						_aWord213 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord213;
						/* end machineCodeAt:put: */
						/* end loadRelativeLiteralIn: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						/* end moveCw:intoR: */
						/* begin machineCodeAt:put: */
						_aWord39 = orSizeshiftedRegistershiftTypeshiftValuewithRegisterdestinationRegister(self_in_dispatchConcretize, 1, ConcreteIPReg, 0, 0, _rn2, _rd2);
						(self_in_dispatchConcretize->machineCode)[4 / 4] = _aWord39;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 8;
					}
					goto l153;
				}
				_size2 = sizeOfregisterSize(self_in_dispatchConcretize, ((uint64_t) _val2 ), 64);
				_mask2 = ((usqInt) 0xFFFFFFFFFFFFFFFFULL ) >> (64 - _size2);
				_maskedImmediate2 = ((uint64_t) _val2 ) & _mask2;
				if (isShiftedMask(self_in_dispatchConcretize, _maskedImmediate2)) {
					_trailingZeros2 = trailingZerosOf(self_in_dispatchConcretize, _maskedImmediate2);
					_trailingOnes2 = trailingOnesOf(self_in_dispatchConcretize, ((usqInt) _maskedImmediate2 ) >> _trailingZeros2);
				} else {
					_maskedImmediate2 = _maskedImmediate2 | (~((usqIntptr_t) _mask2 ));
					if (!(isShiftedMask(self_in_dispatchConcretize, ~((usqIntptr_t) _maskedImmediate2 )))) {
						{
							/* begin moveCw:intoR: */
							/* begin loadRelativeLiteralIn: */
							assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
							assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
							assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
							/* begin machineCodeAt:put: */
							_aWord213 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
							(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord213;
							/* end machineCodeAt:put: */
							/* end loadRelativeLiteralIn: */
							(self_in_dispatchConcretize->machineCodeSize) = 4;
							/* end moveCw:intoR: */
							/* begin machineCodeAt:put: */
							_aWord39 = orSizeshiftedRegistershiftTypeshiftValuewithRegisterdestinationRegister(self_in_dispatchConcretize, 1, ConcreteIPReg, 0, 0, _rn2, _rd2);
							(self_in_dispatchConcretize->machineCode)[4 / 4] = _aWord39;
							/* end machineCodeAt:put: */
							(self_in_dispatchConcretize->machineCodeSize) = 8;
						}
						goto l153;
					}
					_leadingOnes2 = leadingOnesOf(self_in_dispatchConcretize, _maskedImmediate2);
					_trailingZeros2 = 64 - _leadingOnes2;
					_trailingOnes2 = (_leadingOnes2 + (trailingOnesOf(self_in_dispatchConcretize, _maskedImmediate2))) - (64 - _size2);
				}
				_immr2 = (_size2 - _trailingZeros2) & (_size2 - 1);
				_nimms2 = ((~((usqIntptr_t) (_size2 - 1) )) << 1) & 0xFFFFFFFFFFFFFFFFULL;
				_nimms2 = _nimms2 | (_trailingOnes2 - 1);
				_n2 = ((((usqInt) _nimms2 ) >> 6) & 1) ^ 1;
				{
					_encodedValue2 = (((usqInt) _n2 ) << 12) | ((((usqInt) _immr2 ) << 6) | (_nimms2 & 0x3F));
					/* begin machineCodeAt:put: */
					_aWord40 = orSizeimmediate13bitValuesourceRegisterdestinationRegister(self_in_dispatchConcretize, 1, _encodedValue2, _rn2, _rd2);
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord40;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					goto l157;
				}
				l153:
				;
				/* end encodeLogicalImmediate:registerSize:ifPossible:ifNotPossible: */
				l157:
				;
				/* end concretizeOrCqR */
				return;
			}
		}
		break;
		case SubCqR:
		{
			{
				/* begin concretizeSubCqR */
				_word = (self_in_dispatchConcretize->operands)[0];
				_reg2 = (self_in_dispatchConcretize->operands)[1];
				if (_word < 0) {
					logError("Invalid constant");
					abort();
				}
				_fits12Bits2 = (_word & 0xFFF) == _word;
				if (_fits12Bits2) {
					/* begin machineCodeAt:put: */
					_aWord41 = subsSizesourceRegisterimmediate12BitValueshifteddestinationRegister(self_in_dispatchConcretize, 1, _reg2, _word, 0, _reg2);
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord41;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					goto l160;
				}
				_instrOffset3 = loadCwInto(self_in_dispatchConcretize, ConcreteIPReg);
				/* begin machineCodeAt:put: */
				_aWord214 = subsSizeleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister(self_in_dispatchConcretize, 1, _reg2, ConcreteIPReg, 0, 0, _reg2);
				(self_in_dispatchConcretize->machineCode)[4 / 4] = _aWord214;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = ((self_in_dispatchConcretize->machineCodeSize)) + 4;
				l160:
				;
				/* end concretizeSubCqR */
				return;
			}
		}
		break;
		case TstCqR:
		{
			{
				/* begin concretizeTstCqR */
				_word5 = (self_in_dispatchConcretize->operands)[0];
				/* begin encodeLogicalImmediate:registerSize:ifPossible:ifNotPossible: */
				if ((((uint64_t) _word5 ) == 0) || ((((uint64_t) _word5 ) == (~((usqIntptr_t) 0 ))) || 0)) {
					{
						/* begin notYetImplemented */
						/* begin notYetImplemented: */
						logError("Not Yet Implemented!");
						abort();
						/* end notYetImplemented: */
						/* end notYetImplemented */
					}
					goto l293;
				}
				_size4 = sizeOfregisterSize(self_in_dispatchConcretize, ((uint64_t) _word5 ), 64);
				_mask4 = ((usqInt) 0xFFFFFFFFFFFFFFFFULL ) >> (64 - _size4);
				_maskedImmediate4 = ((uint64_t) _word5 ) & _mask4;
				if (isShiftedMask(self_in_dispatchConcretize, _maskedImmediate4)) {
					_trailingZeros4 = trailingZerosOf(self_in_dispatchConcretize, _maskedImmediate4);
					_trailingOnes4 = trailingOnesOf(self_in_dispatchConcretize, ((usqInt) _maskedImmediate4 ) >> _trailingZeros4);
				} else {
					_maskedImmediate4 = _maskedImmediate4 | (~((usqIntptr_t) _mask4 ));
					if (!(isShiftedMask(self_in_dispatchConcretize, ~((usqIntptr_t) _maskedImmediate4 )))) {
						{
							/* begin notYetImplemented */
							/* begin notYetImplemented: */
							logError("Not Yet Implemented!");
							abort();
							/* end notYetImplemented: */
							/* end notYetImplemented */
						}
						goto l293;
					}
					_leadingOnes4 = leadingOnesOf(self_in_dispatchConcretize, _maskedImmediate4);
					_trailingZeros4 = 64 - _leadingOnes4;
					_trailingOnes4 = (_leadingOnes4 + (trailingOnesOf(self_in_dispatchConcretize, _maskedImmediate4))) - (64 - _size4);
				}
				_immr4 = (_size4 - _trailingZeros4) & (_size4 - 1);
				_nimms4 = ((~((usqIntptr_t) (_size4 - 1) )) << 1) & 0xFFFFFFFFFFFFFFFFULL;
				_nimms4 = _nimms4 | (_trailingOnes4 - 1);
				_n4 = ((((usqInt) _nimms4 ) >> 6) & 1) ^ 1;
				{
					_immediate13LogicalValue = (((usqInt) _n4 ) << 12) | ((((usqInt) _immr4 ) << 6) | (_nimms4 & 0x3F));
					/* begin machineCodeAt:put: */
					_aWord85 = tstSizeimmediate13bitValueregister(self_in_dispatchConcretize, 1, _immediate13LogicalValue, (self_in_dispatchConcretize->operands)[1]);
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord85;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					goto l295;
				}
				l293:
				;
				/* end encodeLogicalImmediate:registerSize:ifPossible:ifNotPossible: */
				l295:
				;
				/* end concretizeTstCqR */
				return;
			}
		}
		break;
		case XorCqR:
		{
			{
				concretizeInvertibleDataOperationCqR(self_in_dispatchConcretize, XorOpcode);
				return;
			}
		}
		break;
		case AddCwR:
		{
			{
				concretizeDataOperationCwR(self_in_dispatchConcretize, AddOpcode);
				return;
			}
		}
		break;
		case AndCwR:
		{
			{
				concretizeDataOperationCwR(self_in_dispatchConcretize, AndOpcode);
				return;
			}
		}
		break;
		case CmpCwR:
		{
			{
				concretizeCmpCwR(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case CmpC32R:
		{
			{
				/* begin concretizeCmpCqR */
				_quickImmediate2 = (self_in_dispatchConcretize->operands)[0];
				_registerToUse2 = (self_in_dispatchConcretize->operands)[1];
				if (_quickImmediate2 >= 0) {
					_fits12Bits3 = (_quickImmediate2 & 0xFFF) == _quickImmediate2;
					if (_fits12Bits3) {
						/* begin machineCodeAt:put: */
						_aWord43 = cmpSizeimmediate12BitValueshiftFlagregister(self_in_dispatchConcretize, 1, _quickImmediate2, 0, _registerToUse2);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord43;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l169;
					}
					_fitsShifted12Bits2 = ((((usqInt) ((sqInt) (((usqInt) _quickImmediate2 ) << 12) ) ) >> 12) & 0xFFF) == _quickImmediate2;
					if (_fitsShifted12Bits2) {
						/* begin machineCodeAt:put: */
						_aWord215 = cmpSizeimmediate12BitValueshiftFlagregister(self_in_dispatchConcretize, 1, ((usqInt) _quickImmediate2 ) >> 12, 1, _registerToUse2);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord215;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l169;
					}
				} else {
					_quickImmediate2 = SQABS(_quickImmediate2);
					_fits12Bits3 = (_quickImmediate2 & 0xFFF) == _quickImmediate2;
					if (_fits12Bits3) {
						/* begin machineCodeAt:put: */
						_aWord310 = cmnSizeimmediate12BitValueshiftFlagregister(self_in_dispatchConcretize, 1, _quickImmediate2, 0, _registerToUse2);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord310;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l169;
					}
					_fitsShifted12Bits2 = ((((usqInt) ((sqInt) (((usqInt) _quickImmediate2 ) << 12) ) ) >> 12) & 0xFFF) == _quickImmediate2;
					if (_fitsShifted12Bits2) {
						/* begin machineCodeAt:put: */
						_aWord44 = cmnSizeimmediate12BitValueshiftFlagregister(self_in_dispatchConcretize, 1, ((usqInt) _quickImmediate2 ) >> 12, 1, _registerToUse2);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord44;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l169;
					}
				}
				/* begin moveCw:intoR: */
				/* begin loadRelativeLiteralIn: */
				assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
				assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
				assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
				/* begin machineCodeAt:put: */
				_aWord53 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord53;
				/* end machineCodeAt:put: */
				/* end loadRelativeLiteralIn: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end moveCw:intoR: */
				/* begin machineCodeAt:put: */
				_anOffset2 = (self_in_dispatchConcretize->machineCodeSize);
				_aWord63 = cmpSizeshiftedRegistershiftTypeshiftValuesecondRegister(self_in_dispatchConcretize, 1, ConcreteIPReg, 0, 0, _registerToUse2);
				(self_in_dispatchConcretize->machineCode)[_anOffset2 / 4] = _aWord63;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = ((self_in_dispatchConcretize->machineCodeSize)) + 4;
				l169:
				;
				/* end concretizeCmpCqR */
				return;
			}
		}
		break;
		case OrCwR:
		{
			{
				concretizeDataOperationCwR(self_in_dispatchConcretize, OrOpcode);
				return;
			}
		}
		break;
		case SubCwR:
		{
			{
				concretizeDataOperationCwR(self_in_dispatchConcretize, SubOpcode);
				return;
			}
		}
		break;
		case XorCwR:
		{
			{
				concretizeXorCwR(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case AddRR:
		{
			{
				concretizeAddRR(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case AndRR:
		{
			{
				concretizeAndRR(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case CmpRR:
		{
			{
				/* begin concretizeCmpRR */
				_register1 = (self_in_dispatchConcretize->operands)[0];
				_register2 = (self_in_dispatchConcretize->operands)[1];
				if (_register1 == SP) {
					/* begin machineCodeAt:put: */
					_aWord45 = movToFromSPrn(self_in_dispatchConcretize, ConcreteIPReg, SP);
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord45;
					/* end machineCodeAt:put: */
					/* begin machineCodeAt:put: */
					_aWord216 = cmpSizeshiftedRegistershiftTypeshiftValuesecondRegister(self_in_dispatchConcretize, 1, ConcreteIPReg, 0, 0, _register2);
					(self_in_dispatchConcretize->machineCode)[4 / 4] = _aWord216;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 8;
					goto l175;
				}
				if (_register2 == SP) {
					/* begin machineCodeAt:put: */
					_aWord311 = movSizesourceRegisterMaybeSPdestinationRegisterMaybeSP(self_in_dispatchConcretize, 1, SP, ConcreteIPReg);
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord311;
					/* end machineCodeAt:put: */
					/* begin machineCodeAt:put: */
					_aWord46 = cmpSizeshiftedRegistershiftTypeshiftValuesecondRegister(self_in_dispatchConcretize, 1, _register1, 0, 0, ConcreteIPReg);
					(self_in_dispatchConcretize->machineCode)[4 / 4] = _aWord46;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 8;
					goto l175;
				}
				/* begin machineCodeAt:put: */
				_aWord54 = cmpSizeshiftedRegistershiftTypeshiftValuesecondRegister(self_in_dispatchConcretize, 1, _register1, 0, 0, _register2);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord54;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				l175:
				;
				/* end concretizeCmpRR */
				return;
			}
		}
		break;
		case OrRR:
		{
			{
				concretizeOrRR(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case SubRR:
		{
			{
				concretizeSubRR(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case XorRR:
		{
			{
				concretizeXorRR(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case AddRdRd:
		{
			{
				/* begin concretizeAddRdRd */
				_regRHS = (self_in_dispatchConcretize->operands)[0];
				_regLHS = (self_in_dispatchConcretize->operands)[1];
				(self_in_dispatchConcretize->machineCode)[0] = faddSizefirstSourceRegistersecondSourceRegisterdestinationRegister(self_in_dispatchConcretize, 1, _regLHS, _regRHS, _regLHS);
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeAddRdRd */
				return;
			}
		}
		break;
		case CmpRdRd:
		{
			{
				/* begin concretizeCmpRdRd */
				_regA = (self_in_dispatchConcretize->operands)[0];
				_regB = (self_in_dispatchConcretize->operands)[1];
				(self_in_dispatchConcretize->machineCode)[0] = fcmpFTypeleftRegisterrightRegister(self_in_dispatchConcretize, 1, _regB, _regA);
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeCmpRdRd */
				return;
			}
		}
		break;
		case DivRdRd:
		{
			{
				/* begin concretizeDivRdRd */
				_registerA = (self_in_dispatchConcretize->operands)[0];
				_destinationRegister = (_registerB = (self_in_dispatchConcretize->operands)[1]);
				(self_in_dispatchConcretize->machineCode)[0] = fDivFirstRegistersecondRegisterdestinationRegister(self_in_dispatchConcretize, _registerB, _registerA, _destinationRegister);
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeDivRdRd */
				return;
			}
		}
		break;
		case MulRdRd:
		{
			{
				/* begin concretizeMulRdRd */
				_registerA2 = (self_in_dispatchConcretize->operands)[0];
				_destinationRegister2 = (_registerB2 = (self_in_dispatchConcretize->operands)[1]);
				(self_in_dispatchConcretize->machineCode)[0] = fMulFirstRegistersecondRegisterdestinationRegister(self_in_dispatchConcretize, _registerA2, _registerB2, _destinationRegister2);
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeMulRdRd */
				return;
			}
		}
		break;
		case SubRdRd:
		{
			{
				/* begin concretizeSubRdRd */
				_registerA3 = (self_in_dispatchConcretize->operands)[0];
				_destinationRegister3 = (_registerB3 = (self_in_dispatchConcretize->operands)[1]);
				(self_in_dispatchConcretize->machineCode)[0] = fSubFirstRegistersecondRegisterdestinationRegister(self_in_dispatchConcretize, _registerB3, _registerA3, _destinationRegister3);
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeSubRdRd */
				return;
			}
		}
		break;
		case SqrtRd:
		{
			{
				/* begin concretizeSqrtRd */
				_regLHS2 = (self_in_dispatchConcretize->operands)[0];
				(self_in_dispatchConcretize->machineCode)[0] = fSqrtddestinationRegister(self_in_dispatchConcretize, _regLHS2, _regLHS2);
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeSqrtRd */
				return;
			}
		}
		break;
		case XorRdRd:
		{
			{
				/* begin concretizeXorRdRd */
				_registerA4 = (self_in_dispatchConcretize->operands)[0];
				_destinationRegister4 = (_registerB4 = (self_in_dispatchConcretize->operands)[1]);
				(self_in_dispatchConcretize->machineCode)[0] = fEorFirstRegistersecondRegisterdestinationRegister(self_in_dispatchConcretize, _registerA4, _registerB4, _destinationRegister4);
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeXorRdRd */
				return;
			}
		}
		break;
		case NegateR:
		{
			{
				/* begin concretizeNegateR */
				/* begin machineCodeAt:put: */
				_aWord47 = negateSizesourceRegistersourceRegisterShiftTypesourceRegisterShiftdestinationRegister(self_in_dispatchConcretize, 1, (self_in_dispatchConcretize->operands)[0], 0, 0, (self_in_dispatchConcretize->operands)[0]);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord47;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeNegateR */
				return;
			}
		}
		break;
		case LoadEffectiveAddressMwrR:
		{
			{
				/* begin concretizeLoadEffectiveAddressMwrR */
				_offset35 = (self_in_dispatchConcretize->operands)[0];
				_srcReg13 = (self_in_dispatchConcretize->operands)[1];
				_destReg12 = (self_in_dispatchConcretize->operands)[2];
				/* begin is12BitValue:ifTrue:ifFalse: */
				_signedConstant = ((sqInt) _offset35 );
				if ((SQABS(_signedConstant)) <= 0x7FF) {
					_twoComplement3 = ((_signedConstant >= 0)
						 ? _signedConstant
						 : (0xFFF - (SQABS(_signedConstant))) + 1);
					{
						/* begin machineCodeAt:put: */
						_aWord86 = addSizesourceRegistershiftimmediate12destinationRegister(self_in_dispatchConcretize, 1, _srcReg13, 0, _offset35, _destReg12);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord86;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l298;
					}
				} else {
					{
						/* begin notYetImplemented */
						/* begin notYetImplemented: */
						logError("Not Yet Implemented!");
						abort();
						/* end notYetImplemented: */
						/* end notYetImplemented */
					}
				}
				/* end is12BitValue:ifTrue:ifFalse: */
				goto l298;
				l298:
				;
				/* end concretizeLoadEffectiveAddressMwrR */
				return;
			}
		}
		break;
		case ArithmeticShiftRightCqR:
		{
			{
				/* begin concretizeArithmeticShiftRightCqR */
				_shiftValue = (self_in_dispatchConcretize->operands)[0];
				_reg3 = (self_in_dispatchConcretize->operands)[1];
				/* begin machineCodeAt:put: */
				_aWord48 = arithmeticShiftRightSizesourceRegistershiftValuedestinationRegister(self_in_dispatchConcretize, 1, _reg3, _shiftValue, _reg3);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord48;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeArithmeticShiftRightCqR */
				return;
			}
		}
		break;
		case LogicalShiftRightCqR:
		{
			{
				/* begin concretizeLogicalShiftRightCqR */
				_distance = ((((self_in_dispatchConcretize->operands)[0]) < 0x3F) ? (self_in_dispatchConcretize->operands)[0] : 0x3F);
				_reg4 = (self_in_dispatchConcretize->operands)[1];
				/* begin machineCodeAt:put: */
				_aWord49 = logicalShiftRightSizesourceRegistershiftValuedestinationRegister(self_in_dispatchConcretize, 1, _reg4, _distance, _reg4);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord49;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeLogicalShiftRightCqR */
				return;
			}
		}
		break;
		case LogicalShiftLeftCqR:
		{
			{
				/* begin concretizeLogicalShiftLeftCqR */
				_distance2 = ((((self_in_dispatchConcretize->operands)[0]) < 0x3F) ? (self_in_dispatchConcretize->operands)[0] : 0x3F);
				_reg5 = (self_in_dispatchConcretize->operands)[1];
				/* begin machineCodeAt:put: */
				_aWord50 = logicalShiftLeftSizesourceRegistershiftValuedestinationRegister(self_in_dispatchConcretize, 1, _reg5, _distance2, _reg5);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord50;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeLogicalShiftLeftCqR */
				return;
			}
		}
		break;
		case ArithmeticShiftRightRR:
		{
			{
				concretizeArithmeticShiftRightRR(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case LogicalShiftLeftRR:
		{
			{
				concretizeLogicalShiftLeftRR(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case LogicalShiftRightRR:
		{
			{
				concretizeLogicalShiftRightRR(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case RotateLeftCqR:
		{
			{
				/* begin concretizeRotateLeftCqR */
				_rotation = (self_in_dispatchConcretize->operands)[0];
				_destinationRegister5 = (_sourceRegister = (self_in_dispatchConcretize->operands)[1]);
				/* begin machineCodeAt:put: */
				_aWord51 = rorSizesourceRegisterrotationBitsdestinationRegister(self_in_dispatchConcretize, 1, _sourceRegister, 64 - _rotation, _destinationRegister5);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord51;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeRotateLeftCqR */
				return;
			}
		}
		break;
		case RotateRightCqR:
		{
			{
				/* begin concretizeRotateRightCqR */
				_rotation2 = (self_in_dispatchConcretize->operands)[0];
				_destinationRegister6 = (_sourceRegister2 = (self_in_dispatchConcretize->operands)[1]);
				/* begin machineCodeAt:put: */
				_aWord55 = rorSizesourceRegisterrotationBitsdestinationRegister(self_in_dispatchConcretize, 1, _sourceRegister2, _rotation2, _destinationRegister6);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord55;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeRotateRightCqR */
				return;
			}
		}
		break;
		case MUL:
		{
			{
				concretizeMUL(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case SMULH:
		{
			{
				concretizeSMULH(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case CMPMULOverflow:
		{
			{
				concretizeCMPMULOverflow(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case SDIV:
		{
			{
				/* begin concretizeSDIV */
				_regNumerator = (self_in_dispatchConcretize->operands)[0];
				_regDenominator = (self_in_dispatchConcretize->operands)[1];
				_regDestination = (self_in_dispatchConcretize->operands)[2];
				/* begin machineCodeAt:put: */
				_aWord56 = sdivSizenumeratorRegdenominatorRegdestinationRegister(self_in_dispatchConcretize, 1, _regNumerator, _regDenominator, _regDestination);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord56;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeSDIV */
				return;
			}
		}
		break;
		case MSUB:
		{
			{
				/* begin concretizeMSUB */
				_minuendReg = (self_in_dispatchConcretize->operands)[0];
				_factor1Reg = (self_in_dispatchConcretize->operands)[1];
				_factor2Reg = (self_in_dispatchConcretize->operands)[2];
				_destinationReg = (self_in_dispatchConcretize->operands)[3];
				/* begin machineCodeAt:put: */
				_aWord57 = msubSizeminuendRegfactor1Regfactor2RegdestinationRegister(self_in_dispatchConcretize, 1, _minuendReg, _factor1Reg, _factor2Reg, _destinationReg);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord57;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeMSUB */
				return;
			}
		}
		break;
		case MoveCqR:
		{
			{
				/* begin concretizeMoveCqR */
				/* begin concretizeMoveC32R */
				_quickConstant = (self_in_dispatchConcretize->operands)[0];
				if (_quickConstant < 0) {
					/* begin shiftable16bitImmediate:ifTrue:ifFalse: */
					if (((-_quickConstant - 1) & 0xFFFF) == (-_quickConstant - 1)) {
						{
							_value = -_quickConstant - 1;
							/* begin machineCodeAt:put: */
							_aWord58 = movSizedestinationRegisternegatedImmshift(self_in_dispatchConcretize, 1, (self_in_dispatchConcretize->operands)[1], _value, 0);
							(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord58;
							/* end machineCodeAt:put: */
							(self_in_dispatchConcretize->machineCodeSize) = 4;
							goto l196;
						}
						goto l195;
					}
					for (_i = 0; _i <= 1; _i += 1) {
						_shiftMagnitude = (1ULL << _i) * 16;
						_shiftedValue = ((usqInt) (-_quickConstant - 1) ) >> _shiftMagnitude;
						if ((((sqInt) (((usqInt) _shiftedValue ) << _shiftMagnitude) ) == (-_quickConstant - 1)) && ((_shiftedValue & 0xFFFF) == _shiftedValue)) {
							{
								/* begin machineCodeAt:put: */
								_aWord58 = movSizedestinationRegisternegatedImmshift(self_in_dispatchConcretize, 1, (self_in_dispatchConcretize->operands)[1], _shiftedValue, _shiftMagnitude);
								(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord58;
								/* end machineCodeAt:put: */
								(self_in_dispatchConcretize->machineCodeSize) = 4;
								goto l196;
							}
							goto l195;
						}
					}
					{
						loadCwInto(self_in_dispatchConcretize, (self_in_dispatchConcretize->operands)[1]);
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l196;
					}
					l195:
					;
					/* end shiftable16bitImmediate:ifTrue:ifFalse: */
				}
				/* begin shiftable16bitImmediate:ifTrue:ifFalse: */
				if ((_quickConstant & 0xFFFF) == _quickConstant) {
					{
						/* begin machineCodeAt:put: */
						_aWord217 = movSizedestinationRegisterimmshift(self_in_dispatchConcretize, 1, (self_in_dispatchConcretize->operands)[1], _quickConstant, 0);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord217;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l196;
					}
					goto l194;
				}
				for (_i2 = 0; _i2 <= 1; _i2 += 1) {
					_shiftMagnitude2 = (1ULL << _i2) * 16;
					_shiftedValue2 = ((usqInt) _quickConstant ) >> _shiftMagnitude2;
					if ((((sqInt) (((usqInt) _shiftedValue2 ) << _shiftMagnitude2) ) == _quickConstant) && ((_shiftedValue2 & 0xFFFF) == _shiftedValue2)) {
						{
							/* begin machineCodeAt:put: */
							_aWord217 = movSizedestinationRegisterimmshift(self_in_dispatchConcretize, 1, (self_in_dispatchConcretize->operands)[1], _shiftedValue2, _shiftMagnitude2);
							(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord217;
							/* end machineCodeAt:put: */
							(self_in_dispatchConcretize->machineCodeSize) = 4;
							goto l196;
						}
						goto l194;
					}
				}
				{
					loadCwInto(self_in_dispatchConcretize, (self_in_dispatchConcretize->operands)[1]);
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					goto l196;
				}
				l194:
				;
				/* end shiftable16bitImmediate:ifTrue:ifFalse: */
				goto l196;
				l196:
				;
				/* end concretizeMoveC32R */
				goto l197;
				l197:
				;
				/* end concretizeMoveCqR */
				return;
			}
		}
		break;
		case MoveCwR:
		{
			{
				/* begin concretizeMoveCwR */
				(self_in_dispatchConcretize->machineCodeSize) = loadCwInto(self_in_dispatchConcretize, (self_in_dispatchConcretize->operands)[1]);
				/* end concretizeMoveCwR */
				return;
			}
		}
		break;
		case MoveC32R:
		{
			{
				/* begin concretizeMoveC32R */
				_quickConstant2 = (self_in_dispatchConcretize->operands)[0];
				if (_quickConstant2 < 0) {
					/* begin shiftable16bitImmediate:ifTrue:ifFalse: */
					if (((-_quickConstant2 - 1) & 0xFFFF) == (-_quickConstant2 - 1)) {
						{
							_value2 = -_quickConstant2 - 1;
							/* begin machineCodeAt:put: */
							_aWord59 = movSizedestinationRegisternegatedImmshift(self_in_dispatchConcretize, 1, (self_in_dispatchConcretize->operands)[1], _value2, 0);
							(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord59;
							/* end machineCodeAt:put: */
							(self_in_dispatchConcretize->machineCodeSize) = 4;
							goto l202;
						}
						goto l198;
					}
					for (_i3 = 0; _i3 <= 1; _i3 += 1) {
						_shiftMagnitude3 = (1ULL << _i3) * 16;
						_shiftedValue3 = ((usqInt) (-_quickConstant2 - 1) ) >> _shiftMagnitude3;
						if ((((sqInt) (((usqInt) _shiftedValue3 ) << _shiftMagnitude3) ) == (-_quickConstant2 - 1)) && ((_shiftedValue3 & 0xFFFF) == _shiftedValue3)) {
							{
								/* begin machineCodeAt:put: */
								_aWord59 = movSizedestinationRegisternegatedImmshift(self_in_dispatchConcretize, 1, (self_in_dispatchConcretize->operands)[1], _shiftedValue3, _shiftMagnitude3);
								(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord59;
								/* end machineCodeAt:put: */
								(self_in_dispatchConcretize->machineCodeSize) = 4;
								goto l202;
							}
							goto l198;
						}
					}
					{
						loadCwInto(self_in_dispatchConcretize, (self_in_dispatchConcretize->operands)[1]);
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l202;
					}
					l198:
					;
					/* end shiftable16bitImmediate:ifTrue:ifFalse: */
				}
				/* begin shiftable16bitImmediate:ifTrue:ifFalse: */
				if ((_quickConstant2 & 0xFFFF) == _quickConstant2) {
					{
						/* begin machineCodeAt:put: */
						_aWord218 = movSizedestinationRegisterimmshift(self_in_dispatchConcretize, 1, (self_in_dispatchConcretize->operands)[1], _quickConstant2, 0);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord218;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l202;
					}
					goto l200;
				}
				for (_i22 = 0; _i22 <= 1; _i22 += 1) {
					_shiftMagnitude22 = (1ULL << _i22) * 16;
					_shiftedValue22 = ((usqInt) _quickConstant2 ) >> _shiftMagnitude22;
					if ((((sqInt) (((usqInt) _shiftedValue22 ) << _shiftMagnitude22) ) == _quickConstant2) && ((_shiftedValue22 & 0xFFFF) == _shiftedValue22)) {
						{
							/* begin machineCodeAt:put: */
							_aWord218 = movSizedestinationRegisterimmshift(self_in_dispatchConcretize, 1, (self_in_dispatchConcretize->operands)[1], _shiftedValue22, _shiftMagnitude22);
							(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord218;
							/* end machineCodeAt:put: */
							(self_in_dispatchConcretize->machineCodeSize) = 4;
							goto l202;
						}
						goto l200;
					}
				}
				{
					loadCwInto(self_in_dispatchConcretize, (self_in_dispatchConcretize->operands)[1]);
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					goto l202;
				}
				l200:
				;
				/* end shiftable16bitImmediate:ifTrue:ifFalse: */
				goto l202;
				l202:
				;
				/* end concretizeMoveC32R */
				return;
			}
		}
		break;
		case MoveRR:
		{
			{
				/* begin concretizeMoveRR */
				_srcReg6 = (self_in_dispatchConcretize->operands)[0];
				_destReg6 = (self_in_dispatchConcretize->operands)[1];
				_instruction = (((_srcReg6 == SP) || (_destReg6 == SP))
					 ? movToFromSPrn(self_in_dispatchConcretize, _destReg6, _srcReg6)
					 : movrn(self_in_dispatchConcretize, _destReg6, _srcReg6));
				/* begin machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _instruction;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeMoveRR */
				return;
			}
		}
		break;
		case MoveAwR:
		{
			{
				/* begin concretizeMoveAwR */
				_srcAddr = (self_in_dispatchConcretize->operands)[0];
				_destReg7 = (self_in_dispatchConcretize->operands)[1];
				if ((_srcAddr != null) && ((_srcAddr >= (varBaseAddress())) && ((_srcAddr - (varBaseAddress())) < (1U << 12)))) {
					_actualDestination = ((_destReg7 == SP)
						 ? ConcreteIPReg
						 : _destReg7);
					/* begin machineCodeAt:put: */
					_aWord219 = ldrSizebaseRegisterunsignedOffsetdestinationRegister(self_in_dispatchConcretize, 1, ConcreteVarBaseReg, _srcAddr - (varBaseAddress()), _actualDestination);
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord219;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					if (_destReg7 == SP) {
						/* begin machineCodeAt:put: */
						_aWord60 = movToFromSPrn(self_in_dispatchConcretize, SP, _actualDestination);
						(self_in_dispatchConcretize->machineCode)[4 / 4] = _aWord60;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = ((self_in_dispatchConcretize->machineCodeSize)) + 4;
					}
					goto l212;
				}
				/* begin moveCw:intoR: */
				/* begin loadRelativeLiteralIn: */
				assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
				assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
				assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
				/* begin machineCodeAt:put: */
				_aWord312 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord312;
				/* end machineCodeAt:put: */
				/* end loadRelativeLiteralIn: */
				_instrOffset4 = ((self_in_dispatchConcretize->machineCodeSize) = 4);
				/* end moveCw:intoR: */
				/* begin machineCodeAt:put: */
				_aWord410 = ldurSizebaseRegistersignedOffsetdestinationRegister(self_in_dispatchConcretize, 1, ConcreteIPReg, 0, ConcreteIPReg);
				(self_in_dispatchConcretize->machineCode)[_instrOffset4 / 4] = _aWord410;
				/* end machineCodeAt:put: */
				/* begin machineCodeAt:put: */
				_anOffset3 = _instrOffset4 + 4;
				_aWord510 = movSizesourceRegisterMaybeSPdestinationRegisterMaybeSP(self_in_dispatchConcretize, 1, ConcreteIPReg, _destReg7);
				(self_in_dispatchConcretize->machineCode)[_anOffset3 / 4] = _aWord510;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = _instrOffset4 + 8;
				l212:
				;
				/* end concretizeMoveAwR */
				return;
			}
		}
		break;
		case MoveRAw:
		{
			{
				/* begin concretizeMoveRAw */
				_srcReg7 = (self_in_dispatchConcretize->operands)[0];
				_destAddr = (self_in_dispatchConcretize->operands)[1];
				if ((_destAddr != null) && ((_destAddr >= (varBaseAddress())) && ((_destAddr - (varBaseAddress())) < (1U << 12)))) {
					(self_in_dispatchConcretize->machineCodeSize) = 0;
					if (_srcReg7 == SP) {
						/* begin machineCodeAt:put: */
						_aWord61 = movToFromSPrn(self_in_dispatchConcretize, ConcreteIPReg, SP);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord61;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						_actualSourceRegister2 = ConcreteIPReg;
					} else {
						_actualSourceRegister2 = _srcReg7;
					}
					/* begin machineCodeAt:put: */
					_anOffset4 = (self_in_dispatchConcretize->machineCodeSize);
					_aWord220 = strSizebaseRegisterpositiveOffsetdestinationRegister(self_in_dispatchConcretize, 1, ConcreteVarBaseReg, _destAddr - (varBaseAddress()), _actualSourceRegister2);
					(self_in_dispatchConcretize->machineCode)[_anOffset4 / 4] = _aWord220;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = ((self_in_dispatchConcretize->machineCodeSize)) + 4;
					goto l220;
				}
				/* begin moveCw:intoR: */
				/* begin loadRelativeLiteralIn: */
				assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
				assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
				assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
				/* begin machineCodeAt:put: */
				_aWord411 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord411;
				/* end machineCodeAt:put: */
				/* end loadRelativeLiteralIn: */
				_instrOffset5 = ((self_in_dispatchConcretize->machineCodeSize) = 4);
				/* end moveCw:intoR: */
				if (_srcReg7 == SP) {
					/* begin machineCodeAt:put: */
					_aWord313 = movToFromSPrn(self_in_dispatchConcretize, ConcreteIPReg2, SP);
					(self_in_dispatchConcretize->machineCode)[_instrOffset5 / 4] = _aWord313;
					/* end machineCodeAt:put: */
					_instrOffset5 += 4;
					_actualSourceRegister = ConcreteIPReg2;
				} else {
					_actualSourceRegister = _srcReg7;
				}
				/* begin machineCodeAt:put: */
				_aWord511 = strSizebaseRegisterpositiveOffsetdestinationRegister(self_in_dispatchConcretize, 1, ConcreteIPReg, 0, _actualSourceRegister);
				(self_in_dispatchConcretize->machineCode)[_instrOffset5 / 4] = _aWord511;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = _instrOffset5 + 4;
				l220:
				;
				/* end concretizeMoveRAw */
				return;
			}
		}
		break;
		case MoveAbR:
		{
			{
				/* begin concretizeMoveAbR */
				_srcAddr2 = (self_in_dispatchConcretize->operands)[0];
				_destReg8 = (self_in_dispatchConcretize->operands)[1];
				if ((_srcAddr2 != null) && ((_srcAddr2 >= (varBaseAddress())) && ((_srcAddr2 - (varBaseAddress())) < (1U << 12)))) {
					_offset28 = _srcAddr2 - (varBaseAddress());
					assert((_offset28 & 0xFFF) == _offset28);
					/* begin machineCodeAt:put: */
					_aWord64 = ldrbSourceRegisterdestinationRegisteroffset(self_in_dispatchConcretize, ConcreteVarBaseReg, _destReg8, _srcAddr2 - (varBaseAddress()));
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord64;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					goto l226;
				}
				/* begin moveCw:intoR: */
				/* begin loadRelativeLiteralIn: */
				assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
				assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
				assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
				/* begin machineCodeAt:put: */
				_aWord221 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord221;
				/* end machineCodeAt:put: */
				/* end loadRelativeLiteralIn: */
				_instrOffset6 = ((self_in_dispatchConcretize->machineCodeSize) = 4);
				/* end moveCw:intoR: */
				/* begin machineCodeAt:put: */
				_aWord314 = ldrbSourceRegisterdestinationRegister(self_in_dispatchConcretize, ConcreteIPReg, _destReg8);
				(self_in_dispatchConcretize->machineCode)[_instrOffset6 / 4] = _aWord314;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = _instrOffset6 + 4;
				l226:
				;
				/* end concretizeMoveAbR */
				return;
			}
		}
		break;
		case MoveRAb:
		{
			{
				/* begin concretizeMoveRAb */
				_srcReg8 = (self_in_dispatchConcretize->operands)[0];
				_destAddr2 = (self_in_dispatchConcretize->operands)[1];
				if ((_destAddr2 != null) && ((_destAddr2 >= (varBaseAddress())) && ((_destAddr2 - (varBaseAddress())) < (1U << 12)))) {
					_offset29 = _destAddr2 - (varBaseAddress());
					assert((_offset29 & 0xFFF) == _offset29);
					/* begin machineCodeAt:put: */
					_aWord65 = strbSourceRegisterdestinationRegisteroffset(self_in_dispatchConcretize, _srcReg8, ConcreteVarBaseReg, _offset29);
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord65;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					goto l232;
				}
				/* begin moveCw:intoR: */
				/* begin loadRelativeLiteralIn: */
				assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
				assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
				assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
				/* begin machineCodeAt:put: */
				_aWord222 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord222;
				/* end machineCodeAt:put: */
				/* end loadRelativeLiteralIn: */
				_instrOffset7 = ((self_in_dispatchConcretize->machineCodeSize) = 4);
				/* end moveCw:intoR: */
				/* begin machineCodeAt:put: */
				_aWord315 = strbSourceRegisterdestinationRegister(self_in_dispatchConcretize, _srcReg8, ConcreteIPReg);
				(self_in_dispatchConcretize->machineCode)[_instrOffset7 / 4] = _aWord315;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = _instrOffset7 + 4;
				l232:
				;
				/* end concretizeMoveRAb */
				return;
			}
		}
		break;
		case MoveMbrR:
		{
			{
				/* begin concretizeMoveMbrR */
				_offset36 = (self_in_dispatchConcretize->operands)[0];
				_srcReg14 = (self_in_dispatchConcretize->operands)[1];
				_destReg13 = (self_in_dispatchConcretize->operands)[2];
				/* begin is9BitValue:ifTrue:ifFalse: */
				_constant3 = ((sqInt) _offset36 );
				if (((SQABS(_constant3)) <= 0xFF) || (_constant3 == -256)) {
					_twoComplement4 = ((_constant3 >= 0)
						 ? _constant3
						 : (0x1FF - (SQABS(_constant3))) + 1);
					{
						/* begin machineCodeAt:put: */
						_aWord87 = ldurbSizebaseRegistersignedOffsetdestinationRegister(self_in_dispatchConcretize, 1, _srcReg14, _twoComplement4, _destReg13);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord87;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l304;
					}
				} else {
					{
						/* begin loadRelativeLiteralIn: */
						assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
						assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
						assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
						/* begin machineCodeAt:put: */
						_aWord320 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord320;
						/* end machineCodeAt:put: */
						/* end loadRelativeLiteralIn: */
						/* begin machineCodeAt:put: */
						_aWord228 = ldrbSourceRegisteroffsetRegisterdestinationRegister(self_in_dispatchConcretize, _srcReg14, ConcreteIPReg, _destReg13);
						(self_in_dispatchConcretize->machineCode)[4 / 4] = _aWord228;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 8;
						goto l304;
					}
				}
				/* end is9BitValue:ifTrue:ifFalse: */
				l304:
				;
				/* end concretizeMoveMbrR */
				return;
			}
		}
		break;
		case MoveRMbr:
		case MoveRM8r:
		{
			{
				/* begin concretizeMoveRMbr */
				_srcReg15 = (self_in_dispatchConcretize->operands)[0];
				_offset37 = (self_in_dispatchConcretize->operands)[1];
				_baseReg = (self_in_dispatchConcretize->operands)[2];
				if ((_offset37 >= 0) && ((_offset37 & 0xFFF) == _offset37)) {
					/* begin machineCodeAt:put: */
					_aWord88 = strbSourceRegisterdestinationRegisteroffset(self_in_dispatchConcretize, _srcReg15, _baseReg, _offset37);
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord88;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					goto l306;
				} else {
					/* begin notYetImplemented */
					/* begin notYetImplemented: */
					{
						logError("Not Yet Implemented!");
						abort();
					}
					/* end notYetImplemented: */
					/* end notYetImplemented */
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					goto l306;
				}
				l306:
				;
				/* end concretizeMoveRMbr */
				return;
			}
		}
		break;
		case MoveRM16r:
		{
			{
				/* begin concretizeMoveRM16r */
				_srcReg16 = (self_in_dispatchConcretize->operands)[0];
				_offset38 = (self_in_dispatchConcretize->operands)[1];
				_baseReg2 = (self_in_dispatchConcretize->operands)[2];
				assert(_offset38 >= 0);
				assert((_offset38 % 2) == 0);
				/* begin is12BitValue:ifTrue:ifFalse: */
				_signedConstant2 = ((sqInt) (_offset38 / 2) );
				if ((SQABS(_signedConstant2)) <= 0x7FF) {
					_twoComplement5 = ((_signedConstant2 >= 0)
						 ? _signedConstant2
						 : (0xFFF - (SQABS(_signedConstant2))) + 1);
					{
						/* begin machineCodeAt:put: */
						_aWord89 = strhSourceRegisterdestinationRegisteroffset(self_in_dispatchConcretize, _srcReg16, _baseReg2, _offset38 / 2);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord89;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l309;
					}
				} else {
					{
						/* begin notYetImplemented */
						/* begin notYetImplemented: */
						{
							logError("Not Yet Implemented!");
							abort();
						}
						/* end notYetImplemented: */
						/* end notYetImplemented */
						(self_in_dispatchConcretize->machineCodeSize) = _instrOffset13 + 4;
						goto l309;
					}
				}
				/* end is12BitValue:ifTrue:ifFalse: */
				l309:
				;
				/* end concretizeMoveRM16r */
				return;
			}
		}
		break;
		case MoveM16rR:
		{
			{
				/* begin concretizeMoveM16rR */
				_offset39 = (self_in_dispatchConcretize->operands)[0];
				_baseRegister4 = (self_in_dispatchConcretize->operands)[1];
				_destReg14 = (self_in_dispatchConcretize->operands)[2];
				if ((_offset39 >= 0) && (((_offset39 / 2) & 0xFFF) == (_offset39 / 2))) {
					/* begin machineCodeAt:put: */
					_aWord90 = ldrhBaseRegisteroffsetDividedBy2destinationRegister(self_in_dispatchConcretize, _baseRegister4, _offset39 / 2, _destReg14);
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord90;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					goto l311;
				}
				/* begin notYetImplemented */
				/* begin notYetImplemented: */
				{
					logError("Not Yet Implemented!");
					abort();
				}
				/* end notYetImplemented: */
				/* end notYetImplemented */
				l311:
				;
				/* end concretizeMoveM16rR */
				return;
			}
		}
		break;
		case MoveM32rRs:
		{
			{
				/* begin concretizeMoveM32rRs */
				_offset = (self_in_dispatchConcretize->operands)[0];
				_srcReg = (self_in_dispatchConcretize->operands)[1];
				_destReg = (self_in_dispatchConcretize->operands)[2];
				assert((((((usqInt) _offset ) >> 3) & 0xFFF) << 3) == _offset);
				(self_in_dispatchConcretize->machineCode)[0] = ldrSizebaseRegisterunsignedOffsetdestinationFloatingPointRegisteris128BitVariant(self_in_dispatchConcretize, 2, _srcReg, _offset / 8, _destReg, 0);
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeMoveM32rRs */
				return;
			}
		}
		break;
		case MoveM64rRd:
		{
			{
				/* begin concretizeMoveM64rRd */
				_offset2 = (self_in_dispatchConcretize->operands)[0];
				_srcReg2 = (self_in_dispatchConcretize->operands)[1];
				_destReg2 = (self_in_dispatchConcretize->operands)[2];
				assert((((((usqInt) _offset2 ) >> 3) & 0xFFF) << 3) == _offset2);
				(self_in_dispatchConcretize->machineCode)[0] = ldrSizebaseRegisterunsignedOffsetdestinationFloatingPointRegisteris128BitVariant(self_in_dispatchConcretize, 3, _srcReg2, _offset2 / 8, _destReg2, 0);
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeMoveM64rRd */
				return;
			}
		}
		break;
		case MoveM32rR:
		{
			{
				/* begin concretizeMoveM32rR */
				_offset30 = (self_in_dispatchConcretize->operands)[0];
				_srcReg9 = (self_in_dispatchConcretize->operands)[1];
				_destReg9 = (self_in_dispatchConcretize->operands)[2];
				if ((_offset30 >= 0) && ((_offset30 & 0xFFF) == _offset30)) {
					/* begin machineCodeAt:put: */
					_aWord66 = ldrSizebaseRegisterunsignedOffsetdestinationRegister(self_in_dispatchConcretize, 0, _srcReg9, _offset30, _destReg9);
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord66;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					goto l240;
				}
				/* begin is9BitValue:ifTrue:ifFalse: */
				_constant = ((sqInt) _offset30 );
				if (((SQABS(_constant)) <= 0xFF) || (_constant == -256)) {
					_twoComplement = ((_constant >= 0)
						 ? _constant
						 : (0x1FF - (SQABS(_constant))) + 1);
					{
						/* begin machineCodeAt:put: */
						_aWord223 = ldurSizebaseRegistersignedOffsetdestinationRegister(self_in_dispatchConcretize, 0, _srcReg9, _twoComplement, _destReg9);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord223;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l240;
					}
				} else {
					{
						assert(((self_in_dispatchConcretize->dependent)) != null);
						/* begin moveCw:intoR: */
						/* begin loadRelativeLiteralIn: */
						assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
						assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
						assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
						/* begin machineCodeAt:put: */
						_aWord316 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord316;
						/* end machineCodeAt:put: */
						/* end loadRelativeLiteralIn: */
						_instrOffset8 = ((self_in_dispatchConcretize->machineCodeSize) = 4);
						/* end moveCw:intoR: */
						/* begin machineCodeAt:put: */
						_aWord412 = ldrSizeindexRegisterbaseRegisterdestinationRegister(self_in_dispatchConcretize, 0, ConcreteIPReg, _srcReg9, _destReg9);
						(self_in_dispatchConcretize->machineCode)[_instrOffset8 / 4] = _aWord412;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = _instrOffset8 + 4;
						goto l240;
					}
				}
				/* end is9BitValue:ifTrue:ifFalse: */
				l240:
				;
				/* end concretizeMoveM32rR */
				return;
			}
		}
		break;
		case MoveMwrR:
		{
			{
				/* begin concretizeMoveMwrR */
				_offset31 = (self_in_dispatchConcretize->operands)[0];
				_srcReg10 = (self_in_dispatchConcretize->operands)[1];
				_destReg10 = (self_in_dispatchConcretize->operands)[2];
				if ((_offset31 >= 0) && ((_offset31 & 0xFFF) == _offset31)) {
					/* begin machineCodeAt:put: */
					_aWord67 = ldrSizebaseRegisterunsignedOffsetdestinationRegister(self_in_dispatchConcretize, 1, _srcReg10, _offset31, _destReg10);
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord67;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					goto l248;
				}
				/* begin is9BitValue:ifTrue:ifFalse: */
				_constant2 = ((sqInt) _offset31 );
				if (((SQABS(_constant2)) <= 0xFF) || (_constant2 == -256)) {
					_twoComplement2 = ((_constant2 >= 0)
						 ? _constant2
						 : (0x1FF - (SQABS(_constant2))) + 1);
					{
						/* begin machineCodeAt:put: */
						_aWord224 = ldurSizebaseRegistersignedOffsetdestinationRegister(self_in_dispatchConcretize, 1, _srcReg10, _twoComplement2, _destReg10);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord224;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l248;
					}
				} else {
					{
						assert(((self_in_dispatchConcretize->dependent)) != null);
						/* begin moveCw:intoR: */
						/* begin loadRelativeLiteralIn: */
						assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
						assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
						assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
						/* begin machineCodeAt:put: */
						_aWord317 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord317;
						/* end machineCodeAt:put: */
						/* end loadRelativeLiteralIn: */
						_instrOffset9 = ((self_in_dispatchConcretize->machineCodeSize) = 4);
						/* end moveCw:intoR: */
						/* begin machineCodeAt:put: */
						_aWord413 = ldrSizeindexRegisterbaseRegisterdestinationRegister(self_in_dispatchConcretize, 1, ConcreteIPReg, _srcReg10, _destReg10);
						(self_in_dispatchConcretize->machineCode)[_instrOffset9 / 4] = _aWord413;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = _instrOffset9 + 4;
						goto l248;
					}
				}
				/* end is9BitValue:ifTrue:ifFalse: */
				l248:
				;
				/* end concretizeMoveMwrR */
				return;
			}
		}
		break;
		case MoveXbrRR:
		{
			{
				/* begin concretizeMoveXbrRR */
				_index = (self_in_dispatchConcretize->operands)[0];
				_base = (self_in_dispatchConcretize->operands)[1];
				_dest = (self_in_dispatchConcretize->operands)[2];
				/* begin machineCodeAt:put: */
				_aWord68 = ldrbSourceRegisteroffsetRegisterdestinationRegister(self_in_dispatchConcretize, _base, _index, _dest);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord68;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeMoveXbrRR */
				return;
			}
		}
		break;
		case MoveRXbrR:
		{
			{
				/* begin concretizeMoveRXbrR */
				_src = (self_in_dispatchConcretize->operands)[0];
				_index2 = (self_in_dispatchConcretize->operands)[1];
				_base2 = (self_in_dispatchConcretize->operands)[2];
				/* begin machineCodeAt:put: */
				_aWord69 = strbBaseRegisteroffsetRegisterextensionshiftsrcRegister(self_in_dispatchConcretize, _base2, _index2, 3, 1, _src);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord69;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeMoveRXbrR */
				return;
			}
		}
		break;
		case MoveX32rRR:
		{
			{
				/* begin concretizeMoveX32rRR */
				_index3 = (self_in_dispatchConcretize->operands)[0];
				_base3 = (self_in_dispatchConcretize->operands)[1];
				_dest2 = (self_in_dispatchConcretize->operands)[2];
				/* begin machineCodeAt:put: */
				_aWord70 = ldrSizeindexRegisteroptionscalebaseRegisterdestinationRegister(self_in_dispatchConcretize, 0, _index3, 3, 1, _base3, _dest2);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord70;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeMoveX32rRR */
				return;
			}
		}
		break;
		case MoveRX32rR:
		{
			{
				/* begin concretizeMoveRX32rR */
				_src2 = (self_in_dispatchConcretize->operands)[0];
				_index4 = (self_in_dispatchConcretize->operands)[1];
				_base4 = (self_in_dispatchConcretize->operands)[2];
				/* begin machineCodeAt:put: */
				_aWord71 = strSizebaseRegisteroffsetRegisterextensionshiftstoredRegister(self_in_dispatchConcretize, 0, _base4, _index4, 3, 1, _src2);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord71;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeMoveRX32rR */
				return;
			}
		}
		break;
		case MoveXwrRR:
		{
			{
				/* begin concretizeMoveXwrRR */
				_indexRegister = (self_in_dispatchConcretize->operands)[0];
				_baseRegister = (self_in_dispatchConcretize->operands)[1];
				_destinationRegister7 = (self_in_dispatchConcretize->operands)[2];
				/* begin machineCodeAt:put: */
				_aWord72 = ldrSizeindexRegisteroptionscalebaseRegisterdestinationRegister(self_in_dispatchConcretize, 1, _indexRegister, 3, 1, _baseRegister, _destinationRegister7);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord72;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeMoveXwrRR */
				return;
			}
		}
		break;
		case MoveRXwrR:
		{
			{
				/* begin concretizeMoveRXwrR */
				_src3 = (self_in_dispatchConcretize->operands)[0];
				_index5 = (self_in_dispatchConcretize->operands)[1];
				_base5 = (self_in_dispatchConcretize->operands)[2];
				/* begin machineCodeAt:put: */
				_aWord73 = strSizebaseRegisteroffsetRegisterextensionshiftstoredRegister(self_in_dispatchConcretize, 1, _base5, _index5, 3, 1, _src3);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord73;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeMoveRXwrR */
				return;
			}
		}
		break;
		case MoveRM32r:
		{
			{
				/* begin concretizeMoveRM32r */
				_srcReg17 = (self_in_dispatchConcretize->operands)[0];
				_offset40 = (self_in_dispatchConcretize->operands)[1];
				_baseReg3 = (self_in_dispatchConcretize->operands)[2];
				/* begin is9BitValue:ifTrue:ifFalse: */
				_constant4 = ((sqInt) _offset40 );
				if (((SQABS(_constant4)) <= 0xFF) || (_constant4 == -256)) {
					_twoComplement6 = ((_constant4 >= 0)
						 ? _constant4
						 : (0x1FF - (SQABS(_constant4))) + 1);
					{
						/* begin machineCodeAt:put: */
						_aWord91 = sturSizebaseRegistersignedOffsetdestinationRegister(self_in_dispatchConcretize, 0, _baseReg3, _offset40, _srcReg17);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord91;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l320;
					}
				} else {
					{
						/* begin shiftable16bitImmediate:ifTrue:ifFalse: */
						if ((_offset40 & 0xFFFF) == _offset40) {
							{
								assert(0 == 0);
								/* begin machineCodeAt:put: */
								_aWord229 = movSizedestinationRegisterimmshift(self_in_dispatchConcretize, 1, ConcreteIPReg, _offset40, 0);
								(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord229;
								/* end machineCodeAt:put: */
								/* begin machineCodeAt:put: */
								_aWord321 = strSizebaseRegisteroffsetRegisterextensionshiftstoredRegister(self_in_dispatchConcretize, 0, _baseReg3, ConcreteIPReg, 3, 0, _srcReg17);
								(self_in_dispatchConcretize->machineCode)[4 / 4] = _aWord321;
								/* end machineCodeAt:put: */
								(self_in_dispatchConcretize->machineCodeSize) = 8;
								goto l320;
							}
							goto l340;
						}
						for (_i5 = 0; _i5 <= 1; _i5 += 1) {
							_shiftMagnitude5 = (1ULL << _i5) * 16;
							_shiftedValue5 = ((usqInt) _offset40 ) >> _shiftMagnitude5;
							if ((((sqInt) (((usqInt) _shiftedValue5 ) << _shiftMagnitude5) ) == _offset40) && ((_shiftedValue5 & 0xFFFF) == _shiftedValue5)) {
								{
									assert(_shiftMagnitude5 == 0);
									/* begin machineCodeAt:put: */
									_aWord229 = movSizedestinationRegisterimmshift(self_in_dispatchConcretize, 1, ConcreteIPReg, _shiftedValue5, _shiftMagnitude5);
									(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord229;
									/* end machineCodeAt:put: */
									/* begin machineCodeAt:put: */
									_aWord321 = strSizebaseRegisteroffsetRegisterextensionshiftstoredRegister(self_in_dispatchConcretize, 0, _baseReg3, ConcreteIPReg, 3, 0, _srcReg17);
									(self_in_dispatchConcretize->machineCode)[4 / 4] = _aWord321;
									/* end machineCodeAt:put: */
									(self_in_dispatchConcretize->machineCodeSize) = 8;
									goto l320;
								}
								goto l340;
							}
						}
						{
							/* begin loadRelativeLiteralIn: */
							assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
							assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
							assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
							/* begin machineCodeAt:put: */
							_aWord512 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
							(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord512;
							/* end machineCodeAt:put: */
							/* end loadRelativeLiteralIn: */
							/* begin machineCodeAt:put: */
							_aWord415 = strSizebaseRegisteroffsetRegisterextensionshiftstoredRegister(self_in_dispatchConcretize, 0, _baseReg3, ConcreteIPReg, 3, 0, _srcReg17);
							(self_in_dispatchConcretize->machineCode)[4 / 4] = _aWord415;
							/* end machineCodeAt:put: */
							(self_in_dispatchConcretize->machineCodeSize) = 8;
							goto l320;
						}
						l340:
						;
						/* end shiftable16bitImmediate:ifTrue:ifFalse: */
					}
				}
				/* end is9BitValue:ifTrue:ifFalse: */
				l320:
				;
				/* end concretizeMoveRM32r */
				return;
			}
		}
		break;
		case MoveRMwr:
		{
			{
				/* begin concretizeMoveRMwr */
				_srcReg18 = (self_in_dispatchConcretize->operands)[0];
				_offset41 = (self_in_dispatchConcretize->operands)[1];
				_baseReg4 = (self_in_dispatchConcretize->operands)[2];
				/* begin is9BitValue:ifTrue:ifFalse: */
				_constant5 = ((sqInt) _offset41 );
				if (((SQABS(_constant5)) <= 0xFF) || (_constant5 == -256)) {
					_twoComplement7 = ((_constant5 >= 0)
						 ? _constant5
						 : (0x1FF - (SQABS(_constant5))) + 1);
					{
						/* begin machineCodeAt:put: */
						_aWord92 = sturSizebaseRegistersignedOffsetdestinationRegister(self_in_dispatchConcretize, 1, _baseReg4, _offset41, _srcReg18);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord92;
						/* end machineCodeAt:put: */
						(self_in_dispatchConcretize->machineCodeSize) = 4;
						goto l329;
					}
				} else {
					{
						/* begin shiftable16bitImmediate:ifTrue:ifFalse: */
						if ((_offset41 & 0xFFFF) == _offset41) {
							{
								assert(0 == 0);
								/* begin machineCodeAt:put: */
								_aWord230 = movSizedestinationRegisterimmshift(self_in_dispatchConcretize, 1, ConcreteIPReg, _offset41, 0);
								(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord230;
								/* end machineCodeAt:put: */
								/* begin machineCodeAt:put: */
								_aWord322 = strSizebaseRegisteroffsetRegisterextensionshiftstoredRegister(self_in_dispatchConcretize, 1, _baseReg4, ConcreteIPReg, 3, 0, _srcReg18);
								(self_in_dispatchConcretize->machineCode)[4 / 4] = _aWord322;
								/* end machineCodeAt:put: */
								(self_in_dispatchConcretize->machineCodeSize) = 8;
								goto l329;
							}
							goto l341;
						}
						for (_i6 = 0; _i6 <= 1; _i6 += 1) {
							_shiftMagnitude6 = (1ULL << _i6) * 16;
							_shiftedValue6 = ((usqInt) _offset41 ) >> _shiftMagnitude6;
							if ((((sqInt) (((usqInt) _shiftedValue6 ) << _shiftMagnitude6) ) == _offset41) && ((_shiftedValue6 & 0xFFFF) == _shiftedValue6)) {
								{
									assert(_shiftMagnitude6 == 0);
									/* begin machineCodeAt:put: */
									_aWord230 = movSizedestinationRegisterimmshift(self_in_dispatchConcretize, 1, ConcreteIPReg, _shiftedValue6, _shiftMagnitude6);
									(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord230;
									/* end machineCodeAt:put: */
									/* begin machineCodeAt:put: */
									_aWord322 = strSizebaseRegisteroffsetRegisterextensionshiftstoredRegister(self_in_dispatchConcretize, 1, _baseReg4, ConcreteIPReg, 3, 0, _srcReg18);
									(self_in_dispatchConcretize->machineCode)[4 / 4] = _aWord322;
									/* end machineCodeAt:put: */
									(self_in_dispatchConcretize->machineCodeSize) = 8;
									goto l329;
								}
								goto l341;
							}
						}
						{
							/* begin loadRelativeLiteralIn: */
							assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
							assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
							assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
							/* begin machineCodeAt:put: */
							_aWord513 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
							(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord513;
							/* end machineCodeAt:put: */
							/* end loadRelativeLiteralIn: */
							/* begin machineCodeAt:put: */
							_aWord416 = strSizebaseRegisteroffsetRegisterextensionshiftstoredRegister(self_in_dispatchConcretize, 1, _baseReg4, ConcreteIPReg, 3, 0, _srcReg18);
							(self_in_dispatchConcretize->machineCode)[4 / 4] = _aWord416;
							/* end machineCodeAt:put: */
							(self_in_dispatchConcretize->machineCodeSize) = 8;
							goto l329;
						}
						l341:
						;
						/* end shiftable16bitImmediate:ifTrue:ifFalse: */
					}
				}
				/* end is9BitValue:ifTrue:ifFalse: */
				l329:
				;
				/* end concretizeMoveRMwr */
				return;
			}
		}
		break;
		case MoveRsM32r:
		{
			{
				/* begin concretizeMoveRsM32r */
				_fpReg = (self_in_dispatchConcretize->operands)[0];
				_offset32 = (self_in_dispatchConcretize->operands)[1];
				_baseRegister2 = (self_in_dispatchConcretize->operands)[2];
				assert(_offset32 >= 0);
				/* begin machineCodeAt:put: */
				_aWord74 = strBaseRegisterpositiveOffsetsourceFloatingPointRegisterprecision(self_in_dispatchConcretize, _baseRegister2, _offset32, _fpReg, 2);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord74;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeMoveRsM32r */
				return;
			}
		}
		break;
		case MoveRdM64r:
		{
			{
				/* begin concretizeMoveRdM64r */
				_fpReg2 = (self_in_dispatchConcretize->operands)[0];
				_offset33 = (self_in_dispatchConcretize->operands)[1];
				_baseRegister3 = (self_in_dispatchConcretize->operands)[2];
				assert(_offset33 >= 0);
				/* begin machineCodeAt:put: */
				_aWord75 = strBaseRegisterpositiveOffsetsourceFloatingPointRegisterprecision(self_in_dispatchConcretize, _baseRegister3, _offset33, _fpReg2, 3);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord75;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeMoveRdM64r */
				return;
			}
		}
		break;
		case PopR:
		{
			{
				/* begin concretizePopR */
				_destReg11 = (self_in_dispatchConcretize->operands)[0];
				/* begin machineCodeAt:put: */
				_aWord76 = popR(self_in_dispatchConcretize, _destReg11);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord76;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizePopR */
				return;
			}
		}
		break;
		case PushR:
		{
			{
				/* begin concretizePushR */
				_srcReg11 = (self_in_dispatchConcretize->operands)[0];
				/* begin machineCodeAt:put: */
				_aWord77 = pushR(self_in_dispatchConcretize, _srcReg11);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord77;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizePushR */
				return;
			}
		}
		break;
		case PushCq:
		{
			{
				/* begin concretizePushCq */
				_word2 = (self_in_dispatchConcretize->operands)[0];
				/* begin shiftable16bitImmediate:ifTrue:ifFalse: */
				if ((_word2 & 0xFFFF) == _word2) {
					{
						/* begin machineCodeAt:put: */
						_aWord78 = movSizedestinationRegisterimmshift(self_in_dispatchConcretize, 1, ConcreteIPReg, _word2, 0);
						(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord78;
						/* end machineCodeAt:put: */
						_instrOffset10 = 4;
					}
					goto l269;
				}
				for (_i4 = 0; _i4 <= 1; _i4 += 1) {
					_shiftMagnitude4 = (1ULL << _i4) * 16;
					_shiftedValue4 = ((usqInt) _word2 ) >> _shiftMagnitude4;
					if ((((sqInt) (((usqInt) _shiftedValue4 ) << _shiftMagnitude4) ) == _word2) && ((_shiftedValue4 & 0xFFFF) == _shiftedValue4)) {
						{
							/* begin machineCodeAt:put: */
							_aWord78 = movSizedestinationRegisterimmshift(self_in_dispatchConcretize, 1, ConcreteIPReg, _shiftedValue4, _shiftMagnitude4);
							(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord78;
							/* end machineCodeAt:put: */
							_instrOffset10 = 4;
						}
						goto l269;
					}
				}
				{
					_instrOffset10 = loadCwInto(self_in_dispatchConcretize, ConcreteIPReg);
				}
				l269:
				;
				/* end shiftable16bitImmediate:ifTrue:ifFalse: */
				/* begin machineCodeAt:put: */
				_aWord225 = pushR(self_in_dispatchConcretize, ConcreteIPReg);
				(self_in_dispatchConcretize->machineCode)[_instrOffset10 / 4] = _aWord225;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = _instrOffset10 + 4;
				/* end concretizePushCq */
				return;
			}
		}
		break;
		case PushCw:
		{
			{
				/* begin concretizePushCw */
				_word3 = (self_in_dispatchConcretize->operands)[0];
				_instrOffset11 = loadCwInto(self_in_dispatchConcretize, ConcreteIPReg);
				/* begin machineCodeAt:put: */
				_aWord79 = pushR(self_in_dispatchConcretize, ConcreteIPReg);
				(self_in_dispatchConcretize->machineCode)[_instrOffset11 / 4] = _aWord79;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = _instrOffset11 + 4;
				/* end concretizePushCw */
				return;
			}
		}
		break;
		case PrefetchAw:
		{
			{
				/* begin concretizePrefetchAw */
				_addressOperand = (self_in_dispatchConcretize->operands)[0];
				if ((_addressOperand != null) && ((_addressOperand >= (varBaseAddress())) && ((_addressOperand - (varBaseAddress())) < (1U << 12)))) {
					_offset34 = _addressOperand - (varBaseAddress());
					/* begin machineCodeAt:put: */
					_aWord80 = prefetchMemorysourceRegisteroffset(self_in_dispatchConcretize, 0, ConcreteVarBaseReg, _addressOperand - (varBaseAddress()));
					(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord80;
					/* end machineCodeAt:put: */
					(self_in_dispatchConcretize->machineCodeSize) = 4;
					goto l280;
				}
				/* begin moveCw:intoR: */
				/* begin loadRelativeLiteralIn: */
				assert(((((self_in_dispatchConcretize->dependent))->opcode)) == Literal);
				assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
				assert((SQABS(((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))) < (1U << 12));
				/* begin machineCodeAt:put: */
				_aWord226 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_dispatchConcretize, 1, ((((self_in_dispatchConcretize->dependent))->address)) - ((self_in_dispatchConcretize->address)), ConcreteIPReg);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord226;
				/* end machineCodeAt:put: */
				/* end loadRelativeLiteralIn: */
				_instrOffset12 = ((self_in_dispatchConcretize->machineCodeSize) = 4);
				/* end moveCw:intoR: */
				/* begin machineCodeAt:put: */
				_aWord318 = prefetchMemorysourceRegisteroffset(self_in_dispatchConcretize, 0, ConcreteIPReg, 0);
				(self_in_dispatchConcretize->machineCode)[_instrOffset12 / 4] = _aWord318;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = _instrOffset12 + 4;
				l280:
				;
				/* end concretizePrefetchAw */
				return;
			}
		}
		break;
		case ConvertRdRs:
		{
			{
				/* begin concretizeConvertRdRs */
				_srcReg3 = (self_in_dispatchConcretize->operands)[0];
				_destReg3 = (self_in_dispatchConcretize->operands)[1];
				(self_in_dispatchConcretize->machineCode)[0] = fConvertSourceRegistertoRegistersourcePrecisiontoPrecision(self_in_dispatchConcretize, _srcReg3, _destReg3, 1, 0);
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConvertRdRs */
				return;
			}
		}
		break;
		case ConvertRsRd:
		{
			{
				/* begin concretizeConvertRsRd */
				_srcReg4 = (self_in_dispatchConcretize->operands)[0];
				_destReg4 = (self_in_dispatchConcretize->operands)[1];
				(self_in_dispatchConcretize->machineCode)[0] = fConvertSourceRegistertoRegistersourcePrecisiontoPrecision(self_in_dispatchConcretize, _srcReg4, _destReg4, 0, 1);
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConvertRsRd */
				return;
			}
		}
		break;
		case ConvertRRd:
		{
			{
				/* begin concretizeConvertRRd */
				_srcReg5 = (self_in_dispatchConcretize->operands)[0];
				_destReg5 = (self_in_dispatchConcretize->operands)[1];
				(self_in_dispatchConcretize->machineCode)[0] = scalarConvertSizefromScalarRegistertoDoublePrecisionFloatRegister(self_in_dispatchConcretize, 1, _srcReg5, _destReg5);
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeConvertRRd */
				return;
			}
		}
		break;
		case MoveRdR:
		{
			{
				/* begin concretizeMoveRdR */
				_sourceDoublePrecisionRegister = (self_in_dispatchConcretize->operands)[0];
				_destinationScalerRegister = (self_in_dispatchConcretize->operands)[1];
				/* begin machineCodeAt:put: */
				_aWord81 = fMoveSizefromDoublePrecisionFloatRegistertoScalarRegister(self_in_dispatchConcretize, 1, _sourceDoublePrecisionRegister, _destinationScalerRegister);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord81;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeMoveRdR */
				return;
			}
		}
		break;
		case MoveRRd:
		{
			{
				/* begin concretizeMoveRRd */
				_sourceRegister3 = (self_in_dispatchConcretize->operands)[0];
				_destinationRegister8 = (self_in_dispatchConcretize->operands)[1];
				/* begin machineCodeAt:put: */
				_aWord82 = fMoveSizefromScalarRegistertoDoublePrecisionFloatRegister(self_in_dispatchConcretize, 1, _sourceRegister3, _destinationRegister8);
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _aWord82;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeMoveRRd */
				return;
			}
		}
		break;
		case MovePatcheableC32R:
		{
			{
				concretizeMovePatcheableC32R(self_in_dispatchConcretize);
				return;
			}
		}
		break;
		case DupRVr:
		{
			{
				/* begin concretizeDupRVr */
				_size5 = (self_in_dispatchConcretize->operands)[0];
				_srcReg19 = (self_in_dispatchConcretize->operands)[1];
				_destReg15 = (self_in_dispatchConcretize->operands)[2];
				if (_size5 == 64) {
					_t = 8;
					_q = 1;
				} else {
					/* begin notYetImplemented */
					/* begin notYetImplemented: */
					logError("Not Yet Implemented!");
					abort();
					/* end notYetImplemented: */
					/* end notYetImplemented */
				}
				_instruction2 = dupTqsourcedest(self_in_dispatchConcretize, _t, _q, _srcReg19, _destReg15);
				/* begin machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _instruction2;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeDupRVr */
				return;
			}
		}
		break;
		case St1VrRMw:
		{
			{
				/* begin concretizeSt1VrRMw */
				_size6 = (self_in_dispatchConcretize->operands)[0];
				_vectorR = (self_in_dispatchConcretize->operands)[1];
				_memoryR = (self_in_dispatchConcretize->operands)[2];
				_offset42 = (self_in_dispatchConcretize->operands)[3];
				_opCode = 7;
				if ((_offset42 == 0) || (_offset42 == 16)) {
					if (_size6 == 64) {
						_q2 = 1;
						_t2 = 11;
					} else {
						if (_size6 == 32) {
							_q2 = 1;
							_t2 = 10;
						} else {
							/* begin notYetImplemented */
							/* begin notYetImplemented: */
							logError("Not Yet Implemented!");
							abort();
							/* end notYetImplemented: */
							/* end notYetImplemented */
						}
					}
				} else {
					/* begin notYetImplemented */
					/* begin notYetImplemented: */
					logError("Not Yet Implemented!");
					abort();
					/* end notYetImplemented: */
					/* end notYetImplemented */
				}
				_instruction3 = ((_offset42 == 0)
					 ? st1QOpCodeSRnRt(self_in_dispatchConcretize, _q2, _opCode, _t2, _memoryR, _vectorR)
					 : st1QRmOpCodeSRnRt(self_in_dispatchConcretize, _q2, 0x1F, _opCode, _t2, _memoryR, _vectorR));
				/* begin machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _instruction3;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeSt1VrRMw */
				return;
			}
		}
		break;
		case Ld1VrRMw:
		{
			{
				/* begin concretizeLd1VrRMw */
				_size7 = (self_in_dispatchConcretize->operands)[0];
				_vectorR2 = (self_in_dispatchConcretize->operands)[1];
				_baseRegister5 = (self_in_dispatchConcretize->operands)[2];
				_offset43 = (self_in_dispatchConcretize->operands)[3];
				_opCode2 = 7;
				if ((_offset43 == 0) || (_offset43 == 16)) {
					if (_size7 == 64) {
						_q3 = 1;
						_t3 = 11;
					} else {
						if (_size7 == 32) {
							_q3 = 1;
							_t3 = 10;
						} else {
							/* begin notYetImplemented */
							/* begin notYetImplemented: */
							logError("Not Yet Implemented!");
							abort();
							/* end notYetImplemented: */
							/* end notYetImplemented */
						}
					}
				} else {
					/* begin notYetImplemented */
					/* begin notYetImplemented: */
					logError("Not Yet Implemented!");
					abort();
					/* end notYetImplemented: */
					/* end notYetImplemented */
				}
				_instruction4 = ((_offset43 == 0)
					 ? ld1QOpCodeSRnRt(self_in_dispatchConcretize, _q3, _opCode2, _t3, _baseRegister5, _vectorR2)
					 : ld1QRmOpCodeSRnRt(self_in_dispatchConcretize, _q3, 0x1F, _opCode2, _t3, _baseRegister5, _vectorR2));
				/* begin machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _instruction4;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeLd1VrRMw */
				return;
			}
		}
		break;
		case FaddSRvRvRv:
		{
			{
				/* begin concretizeFaddSRvRvRv */
				_size8 = (self_in_dispatchConcretize->operands)[0];
				_vectorReg1 = (self_in_dispatchConcretize->operands)[1];
				_vectorReg2 = (self_in_dispatchConcretize->operands)[2];
				_vectorRegSum = (self_in_dispatchConcretize->operands)[3];
				if (_size8 == 64) {
					_t4 = 1;
					_q4 = 1;
				} else {
					if (_size8 == 32) {
						_t4 = 0;
						_q4 = 1;
					} else {
						/* begin notYetImplemented */
						/* begin notYetImplemented: */
						logError("Not Yet Implemented!");
						abort();
						/* end notYetImplemented: */
						/* end notYetImplemented */
					}
				}
				_instruction5 = addTqterm1term2dest(self_in_dispatchConcretize, _t4, _q4, _vectorReg1, _vectorReg2, _vectorRegSum);
				/* begin machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _instruction5;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeFaddSRvRvRv */
				return;
			}
		}
		break;
		case FsubSRvRvRv:
		{
			{
				/* begin concretizeFsubSRvRvRv */
				_size9 = (self_in_dispatchConcretize->operands)[0];
				_minuendVectorRegister = (self_in_dispatchConcretize->operands)[1];
				_subtrahendVectorRegister = (self_in_dispatchConcretize->operands)[2];
				_vectorRegSum2 = (self_in_dispatchConcretize->operands)[3];
				if (_size9 == 64) {
					_t5 = 1;
					_q5 = 1;
				} else {
					if (_size9 == 32) {
						_t5 = 0;
						_q5 = 1;
					} else {
						/* begin notYetImplemented */
						/* begin notYetImplemented: */
						logError("Not Yet Implemented!");
						abort();
						/* end notYetImplemented: */
						/* end notYetImplemented */
					}
				}
				_instruction6 = subTqterm1term2dest(self_in_dispatchConcretize, _t5, _q5, _minuendVectorRegister, _subtrahendVectorRegister, _vectorRegSum2);
				/* begin machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCode)[0 / 4] = _instruction6;
				/* end machineCodeAt:put: */
				(self_in_dispatchConcretize->machineCodeSize) = 4;
				/* end concretizeFsubSRvRvRv */
				return;
			}
		}
		break;
		default:
		error("Case not found and no otherwise clause");
	}
	{
		return;
	}
}
/*	 
	C7.2.40 DUP (general) 
	 
	DUP <Vd>.<T>, <R><n> 
	 
	Duplicate general-purpose register to vector. This instruction duplicates 
	the contents of the source general-purpose 
	register into a scalar or each element in a vector, and writes the result 
	to the SIMD&FP destination register. 
	Depending on the settings in the CPACR_EL1, CPTR_EL2, and CPTR_EL3 
	registers, and the current Security state 
	and Exception level, an attempt to execute the instruction might be 
	trapped  */
/* CogARMv8Compiler>>#dupT:q:source:dest: */
static sqInt NoDbgRegParms
dupTqsourcedest(AbstractInstruction * self_in_dupTqsourcedest, sqInt _t, sqInt _q, sqInt _src, sqInt _dest)
{
	return ((sqInt) (((usqInt) _q ) << 30) ) | ((7U << 25) | (((sqInt) (((usqInt) (_t & 0x1F) ) << 16) ) | ((3U << 10) | (((sqInt) (((usqInt) (_src & 0x1F) ) << 5) ) | (_dest & 0x1F)))));
}
/*	C6.2.86 EOR (shifted register) 
	 
	Bitwise Exclusive OR (shifted register) performs a bitwise Exclusive OR of 
	a register value and an optionally-shifted register value, and writes the 
	result to the destination register. 
	 
	EOR <Xd>, <Xn>, <Xm>{, <shift> #<amount>} */
/* CogARMv8Compiler>>#exclusiveOrSize:firstRegister:secondRegister:destinationRegister: */
static sqInt NoDbgRegParms
exclusiveOrSizefirstRegistersecondRegisterdestinationRegister(AbstractInstruction * self_in_exclusiveOrSizefirstRegistersecondRegisterdestinationRegister, sqInt _is64Bits, sqInt _firstRegister, sqInt _secondRegister, sqInt _destinationRegister)
{
	return logicalShiftedRegisterSizeopcodefirstRegistershiftedRegistershiftOptionshiftValuenegateddestinationRegister(self_in_exclusiveOrSizefirstRegistersecondRegisterdestinationRegister, _is64Bits, 2, _firstRegister, _secondRegister, 0, 0, 0, _destinationRegister);
}
/*	Extract the offset inside a branch instruction of the formformat:  
	 
	C6.2.25 B.cond 
	 
	Branch conditionally to a label at a PC-relative offset, with a hint that 
	this is not a subroutine call or return. 
	 
	B.<cond> <label> 
	 
	The condition is encoded as the last 4 bits */
/* CogARMv8Compiler>>#extractConditionFromB: */
static sqInt NoDbgRegParms
extractConditionFromB(AbstractInstruction * self_in_extractConditionFromB, sqInt _instruction)
{
	seeAlso(self_in_extractConditionFromB, branchConditionoffset);
	return _instruction & 15;
}
/*	Extract the offset inside a branch instruction of the formformat:  
	 
	C6.2.25 B.cond 
	 
	Branch conditionally to a label at a PC-relative offset, with a hint that 
	this is not a subroutine call or return. 
	 
	B.<cond> <label> 
	 
	The offset is encoded as an immediate of 19 bits that should be multiplied 
	by 4 => so we do it by shifting it by 2 
	 */
/* CogARMv8Compiler>>#extractOffsetFromConditionalBranch: */
static sqInt NoDbgRegParms
extractOffsetFromConditionalBranch(AbstractInstruction * self_in_extractOffsetFromConditionalBranch, sqInt _instruction)
{
	sqInt _twoComplement;

	seeAlso(self_in_extractOffsetFromConditionalBranch, branchConditionoffset);
	_twoComplement = (((usqInt) _instruction ) >> 5) & 0x7FFFF;
	return (((_twoComplement & (1U << 18)) == (1U << 18))
		 ? (/* begin notYetImplemented */ /* begin notYetImplemented: */ (logError("Not Yet Implemented!"), abort()), null /* end notYetImplemented: */ /* end notYetImplemented */)
		 : ((sqInt) (((usqInt) _twoComplement ) << 2) ));
}
/*	C7.2.50 FADD (scalar) 
	 
	Floating-point Add (scalar). This instruction adds the floating-point 
	values of the two source SIMD&FP registers, and writes the result to the 
	destination SIMD&FP register. 
	 
	FADD <Dd>, <Dn>, <Dm> */
/* CogARMv8Compiler>>#faddSize:firstSourceRegister:secondSourceRegister:destinationRegister: */
static sqInt NoDbgRegParms
faddSizefirstSourceRegistersecondSourceRegisterdestinationRegister(AbstractInstruction * self_in_faddSizefirstSourceRegistersecondSourceRegisterdestinationRegister, sqInt _precision, sqInt _registerA, sqInt _registerB, sqInt _destinationRegister)
{
	return (30U << 24) | (((sqInt) (((usqInt) (_precision & 3) ) << 22) ) | ((1U << 21) | (((sqInt) (((usqInt) (_registerB & 0x1F) ) << 16) ) | ((5U << 11) | (((sqInt) (((usqInt) (_registerA & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F))))));
}
/*	C7.2.69 FCVT 
	 
	Floating-point Convert precision (scalar). This instruction converts the 
	floating-point value in the SIMD&FP source register to the precision for 
	the destination register data type using the rounding mode that is 
	determined by the FPCR and writes the result to the SIMD&FP destination 
	register.  
	FCVT <Dd>, <Sn> 
	 */
/* CogARMv8Compiler>>#fConvertSourceRegister:toRegister:sourcePrecision:toPrecision: */
static sqInt NoDbgRegParms
fConvertSourceRegistertoRegistersourcePrecisiontoPrecision(AbstractInstruction * self_in_fConvertSourceRegistertoRegistersourcePrecisiontoPrecision, sqInt _sourceRegister, sqInt _destRegister, sqInt _ftype, sqInt _opc)
{
	return (15U << 25) | (((sqInt) (((usqInt) (_ftype & 3) ) << 22) ) | ((17U << 17) | (((sqInt) (((usqInt) (_opc & 3) ) << 15) ) | ((1U << 14) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 5) ) | (_destRegister & 0x1F))))));
}
/*	C7.2.66 FCMP 
	 
	Floating-point quiet Compare (scalar). This instruction compares the two 
	SIMD&FP source register values, or the first SIMD&FP source register value 
	and zero. It writes the result to the PSTATE.{N, Z, C, V} flags. 
	 
	Double-precision variant 
	FCMP <Dn>, <Dm> 
	 
	ftype: 
	11 => half precision 
	00 => single precision 
	01 => double precision */
/* CogARMv8Compiler>>#fcmpFType:leftRegister:rightRegister: */
static sqInt NoDbgRegParms
fcmpFTypeleftRegisterrightRegister(AbstractInstruction * self_in_fcmpFTypeleftRegisterrightRegister, sqInt _ftype, sqInt _firstRegister, sqInt _secondRegister)
{
	return (15U << 25) | (((sqInt) (((usqInt) (_ftype & 3) ) << 22) ) | ((1U << 21) | (((sqInt) (((usqInt) (_secondRegister & 0x1F) ) << 16) ) | ((1U << 13) | ((sqInt) (((usqInt) (_firstRegister & 0x1F) ) << 5) )))));
}
/*	C7.2.98 FDIV (scalar) 
	 
	Floating-point Divide (scalar). This instruction divides the 
	floating-point value of the first source SIMD&FP register by the 
	floating-point value of the second source SIMD&FP register, and writes the 
	result to the destination SIMD&FP register. 
	 
	FDIV <Dd>, <Dn>, <Dm> */
/* CogARMv8Compiler>>#fDivFirstRegister:secondRegister:destinationRegister: */
static sqInt NoDbgRegParms
fDivFirstRegistersecondRegisterdestinationRegister(AbstractInstruction * self_in_fDivFirstRegistersecondRegisterdestinationRegister, sqInt _registerA, sqInt _registerB, sqInt _destinationRegister)
{
	return (15U << 25) | ((1U << 22) | ((1U << 21) | (((sqInt) (((usqInt) (_registerB & 0x1F) ) << 16) ) | ((3U << 11) | (((sqInt) (((usqInt) (_registerA & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F))))));
}
/*	C7.2.41 EOR (vector) 
	 
	Bitwise Exclusive OR (vector). This instruction performs a bitwise 
	Exclusive OR operation between the two source SIMD&FP registers, and 
	places the result in the destination SIMD&FP register. 
	 
	EOR <Vd>.<T>, <Vn>.<T>, <Vm>.<T> (We only implemented for 64 bits double 
	precision)  */
/* CogARMv8Compiler>>#fEorFirstRegister:secondRegister:destinationRegister: */
static sqInt NoDbgRegParms
fEorFirstRegistersecondRegisterdestinationRegister(AbstractInstruction * self_in_fEorFirstRegistersecondRegisterdestinationRegister, sqInt _registerA, sqInt _registerB, sqInt _destinationRegister)
{
	return (369U << 21) | (((sqInt) (((usqInt) (_registerB & 0x1F) ) << 16) ) | ((7U << 10) | (((sqInt) (((usqInt) (_registerA & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F))));
}
/* CogARMv8Compiler>>#fMoveSize:fromDoublePrecisionFloatRegister:toScalarRegister: */
static sqInt NoDbgRegParms
fMoveSizefromDoublePrecisionFloatRegistertoScalarRegister(AbstractInstruction * self_in_fMoveSizefromDoublePrecisionFloatRegistertoScalarRegister, sqInt _is64Bits, sqInt _sourceDoublePrecisionFloatRegister, sqInt _destinationScalarRegister)
{
	return fMoveSizefromScalarToDoublePrecisionsourceRegisterdestinationRegister(self_in_fMoveSizefromDoublePrecisionFloatRegistertoScalarRegister, _is64Bits, 0, _sourceDoublePrecisionFloatRegister, _destinationScalarRegister);
}
/* CogARMv8Compiler>>#fMoveSize:fromScalarRegister:toDoublePrecisionFloatRegister: */
static sqInt NoDbgRegParms
fMoveSizefromScalarRegistertoDoublePrecisionFloatRegister(AbstractInstruction * self_in_fMoveSizefromScalarRegistertoDoublePrecisionFloatRegister, sqInt _is64Bits, sqInt _sourceScalarRegister, sqInt _destinationDoublePrecisionFloatRegister)
{
	return fMoveSizefromScalarToDoublePrecisionsourceRegisterdestinationRegister(self_in_fMoveSizefromScalarRegistertoDoublePrecisionFloatRegister, _is64Bits, 1, _sourceScalarRegister, _destinationDoublePrecisionFloatRegister);
}
/*	C7.2.131 FMOV (general) 
	 
	Floating-point Move to or from general-purpose register without 
	conversion. This instruction transfers the contents of a SIMD&FP register 
	to a general-purpose register, or the contents of a general-purpose 
	register to a SIMD&FP register. 
	 
	Double-precision to 64-bit variant 
	FMOV <Xd>, <Dn> */
/* CogARMv8Compiler>>#fMoveSize:fromScalarToDoublePrecision:sourceRegister:destinationRegister: */
static sqInt NoDbgRegParms
fMoveSizefromScalarToDoublePrecisionsourceRegisterdestinationRegister(AbstractInstruction * self_in_fMoveSizefromScalarToDoublePrecisionsourceRegisterdestinationRegister, sqInt _is64Bits, sqInt _fromScalarToDoublePrecision, sqInt _sourceRegister, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) (_is64Bits & 1) ) << 0x1F) ) | ((15U << 25) | ((1U << 22) | ((19U << 17) | (((sqInt) (((usqInt) (_fromScalarToDoublePrecision & 1) ) << 16) ) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F))))));
}
/*	C7.2.136 FMUL (Scalar) 
	 
	Floating-point Multiply (scalar). This instruction multiplies the 
	floating-point values of the two source SIMD&FP registers, and writes the 
	result to the destination SIMD&FP register. 
	 
	FMUL <Dd>, <Dn>, <Dm> */
/* CogARMv8Compiler>>#fMulFirstRegister:secondRegister:destinationRegister: */
static sqInt NoDbgRegParms
fMulFirstRegistersecondRegisterdestinationRegister(AbstractInstruction * self_in_fMulFirstRegistersecondRegisterdestinationRegister, sqInt _registerA, sqInt _registerB, sqInt _destinationRegister)
{
	return (15U << 25) | ((1U << 22) | ((1U << 21) | (((sqInt) (((usqInt) (_registerB & 0x1F) ) << 16) ) | ((1U << 11) | (((sqInt) (((usqInt) (_registerA & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F))))));
}
/*	C7.2.172 FSQRT (scalar) 
	 
	Floating-point Square Root (scalar). This instruction calculates the 
	square root of the value in the SIMD&FP source register and writes the 
	result to the SIMD&FP destination register. 
	 
	FSQRT <Dd>, <Dn> 
	 */
/* CogARMv8Compiler>>#fSqrtd:destinationRegister: */
static sqInt NoDbgRegParms
fSqrtddestinationRegister(AbstractInstruction * self_in_fSqrtddestinationRegister, sqInt _sourceRegister, sqInt _destinationRegister)
{
	return (15U << 25) | ((1U << 22) | ((1U << 21) | ((7U << 14) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)))));
}
/*	C7.2.174 FSUB (scalar) 
	 
	Floating-point Subtract (scalar). This instruction subtracts the 
	floating-point value of the second source SIMD&FP register from the 
	floating-point value of the first source SIMD&FP register, and writes the 
	result to the destination SIMD&FP register. 
	 
	FSUB <Dd>, <Dn>, <Dm> */
/* CogARMv8Compiler>>#fSubFirstRegister:secondRegister:destinationRegister: */
static sqInt NoDbgRegParms
fSubFirstRegistersecondRegisterdestinationRegister(AbstractInstruction * self_in_fSubFirstRegistersecondRegisterdestinationRegister, sqInt _registerA, sqInt _registerB, sqInt _destinationRegister)
{
	return (15U << 25) | ((1U << 22) | ((1U << 21) | (((sqInt) (((usqInt) (_registerB & 0x1F) ) << 16) ) | ((7U << 11) | (((sqInt) (((usqInt) (_registerA & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F))))));
}
/*	Save the register to a caller-saved register. 
	The caller may have been using the same register for something else. 
	So we need to save it and restore it later. 
	Make sure to reuse a caller-saved register: we can reuse it freely */
/* CogARMv8Compiler>>#genCaptureCStackPointers: */
static AbstractInstruction * NoDbgRegParms
genCaptureCStackPointers(AbstractInstruction * self_in_genCaptureCStackPointers, sqInt _captureFramePointer)
{
	sqInt _address;
	sqInt _address2;
	AbstractInstruction *_anInstruction;
	sqInt _quickConstant;
	sqInt _reg;

	{
		{
			/* begin MoveR:R: */
			genoperandoperand(MoveRR, VarBaseReg, R1);
			/* end MoveR:R: */
			/* begin MoveCq:R: */
			_quickConstant = varBaseAddress();
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperand(MoveCqR, _quickConstant, VarBaseReg);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(_quickConstant));
			}
			/* end checkQuickConstant:forInstruction: */
			/* end MoveCq:R: */
		}
	}
	if (_captureFramePointer) {
		/* begin MoveR:Aw: */
		_address = cFramePointerAddress();
		/* begin gen:operand:literal: */
		checkLiteralforInstruction(_address, genoperandoperand(MoveRAw, FPReg, _address));
		/* end gen:operand:literal: */
		/* end MoveR:Aw: */
	}
	/* begin MoveR:Aw: */
	_reg = cStackPointer(self_in_genCaptureCStackPointers);
	_address2 = cStackPointerAddress();
	/* begin gen:operand:literal: */
	checkLiteralforInstruction(_address2, genoperandoperand(MoveRAw, _reg, _address2));
	/* end gen:operand:literal: */
	/* end MoveR:Aw: */
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, R1, VarBaseReg);
		/* end MoveR:R: */
	}
	genoperand(RetN, 0);
	return self_in_genCaptureCStackPointers;
}
/* CogARMv8Compiler>>#genDivR:R:Quo:Rem: */
static AbstractInstruction * NoDbgRegParms
genDivRRQuoRem(AbstractInstruction * self_in_genDivRRQuoRem, sqInt _abstractRegDenominator, sqInt _abstractRegNumerator, sqInt _abstractRegQuotient, sqInt _abstractRegRemainder)
{
	genoperandoperandoperand(SDIV, _abstractRegNumerator, _abstractRegDenominator, ConcreteIPReg);
	genoperandoperandoperandoperand(MSUB, _abstractRegNumerator, ConcreteIPReg, _abstractRegDenominator, _abstractRegRemainder);
	genoperandoperand(MoveRR, ConcreteIPReg, _abstractRegQuotient);
	return self_in_genDivRRQuoRem;
}
/*	Load the stack pointer register with that of the C stack, effecting 
	a switch to the C stack. Used when machine code calls into the 
	CoInterpreter run-time (e.g. to invoke interpreter primitives). */
/* CogARMv8Compiler>>#genLoadCStackPointer */
static sqInt NoDbgRegParms
genLoadCStackPointer(AbstractInstruction * self_in_genLoadCStackPointer)
{
	sqInt _address;

	/* begin MoveAw:R: */
	_address = cStackPointerAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, SP));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	return 0;
}
/*	Load the frame and stack pointer registers with those of the C stack, 
	effecting a switch to the C stack. Used when machine code calls into 
	the CoInterpreter run-time (e.g. to invoke interpreter primitives). */
/* CogARMv8Compiler>>#genLoadCStackPointers */
static sqInt NoDbgRegParms
genLoadCStackPointers(AbstractInstruction * self_in_genLoadCStackPointers)
{
	sqInt _address;
	sqInt _address2;

	/* begin MoveAw:R: */
	_address = cStackPointerAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, SP));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	/* begin MoveAw:R: */
	_address2 = cFramePointerAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address2, genoperandoperand(MoveAwR, _address2, FPReg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	return 0;
}
/*	Switch back to the Smalltalk stack. Assign SPReg first 
	because typically it is used immediately afterwards. */
/* CogARMv8Compiler>>#genLoadStackPointers */
static sqInt NoDbgRegParms
genLoadStackPointers(AbstractInstruction * self_in_genLoadStackPointers)
{
	sqInt _address;
	sqInt _address2;

	/* begin MoveAw:R: */
	_address = stackPointerAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, SPReg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	/* begin MoveAw:R: */
	_address2 = framePointerAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address2, genoperandoperand(MoveAwR, _address2, FPReg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	return 0;
}
/*	In ARMv8 the multiplication operation (MUL) does not set the overflow 
	flag. MUL multiplies two 64bit registers and produces the lower 64bit part 
	of the 128bit result into a register. 
	SMULH multiplies two 64bit registers and produces the higher 64bit part of 
	the 128bit result into a register, sign-extended. 
	An overflow happens in the higher part is just an extension of the sign of 
	the lower part. 
	In other words, an overflow does NOT happen if: 
	=> the number lower part is positive (sign = 0) and the higher part is all 
	0s or 
	=> the number lower part is negative (sign = 1) and the higher part is all 
	1s First get the high part in a temporary register */
/* CogARMv8Compiler>>#genMulR:R: */
static AbstractInstruction * NoDbgRegParms
genMulRR(AbstractInstruction * self_in_genMulRR, sqInt _regSource, sqInt _regDest)
{
	AbstractInstruction *_first;

	genoperandoperandoperand(SMULH, _regSource, _regDest, RISCTempReg);
	_first = genoperandoperandoperand(MUL, _regSource, _regDest, _regDest);
	genoperandoperand(CMPMULOverflow, _regDest, RISCTempReg);
	return _first;
}
/*	Ensure that the register args are pushed before the outer and 
	inner retpcs at an entry miss for arity <= self numRegArgs. The 
	outer retpc is that of a call at a send site. The inner is the call 
	from a method or PIC abort/miss to the trampoline.Putting the receiver and args above the return address means the 
	CoInterpreter has a single machine-code frame format which saves 
	us a lot of work.Iff there are register args convert 
	sp		->	outerRetpc			(send site retpc) 
	linkReg = innerRetpc			(PIC abort/miss retpc) 
	to 
	base	->	receiver 
	(arg0) 
	(arg1) 
	sp		->	outerRetpc			(send site retpc) 
	sp		->	linkReg/innerRetpc	(PIC abort/miss retpc) */
/* CogARMv8Compiler>>#genPushRegisterArgsForAbortMissNumArgs: */
static AbstractInstruction * NoDbgRegParms
genPushRegisterArgsForAbortMissNumArgs(AbstractInstruction * self_in_genPushRegisterArgsForAbortMissNumArgs, sqInt _numArgs)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;

	if (_numArgs <= 2) {
		assert((numRegArgs()) <= 2);
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMwrR, 0, SPReg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperandoperand(MoveRMwr, ReceiverResultReg, 0, SPReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		if (_numArgs > 0) {
			genoperand(PushR, Arg0Reg);
			if (_numArgs > 1) {
				genoperand(PushR, Arg1Reg);
			}
		}
		genoperand(PushR, TempReg);
	}
	genoperand(PushR, LinkReg);
	return self_in_genPushRegisterArgsForAbortMissNumArgs;
}
/*	Ensure that the register args are pushed before the retpc for arity <= 
	self numRegArgs.This is easy on a RISC like ARM because the return address is in the link 
	register. Putting 
	the receiver and args above the return address means the CoInterpreter has 
	a single 
	machine-code frame format which saves us a lot of work 
	NOTA BENE: we do NOT push the return address here, which means it must be 
	dealt with later. */
/* CogARMv8Compiler>>#genPushRegisterArgsForNumArgs:scratchReg: */
static AbstractInstruction * NoDbgRegParms
genPushRegisterArgsForNumArgsscratchReg(AbstractInstruction * self_in_genPushRegisterArgsForNumArgsscratchReg, sqInt _numArgs, sqInt ignored)
{
	if (_numArgs <= 2) {
		assert((numRegArgs()) <= 2);
		genoperand(PushR, ReceiverResultReg);
		if (_numArgs > 0) {
			genoperand(PushR, Arg0Reg);
			if (_numArgs > 1) {
				genoperand(PushR, Arg1Reg);
			}
		}
	}
	return self_in_genPushRegisterArgsForNumArgsscratchReg;
}
/*	Save the frame and stack pointer registers to the framePointer 
	and stackPointer variables. Used to save the machine code frame 
	for use by the run-time when calling into the CoInterpreter run-time. */
/* CogARMv8Compiler>>#genSaveStackPointers */
static sqInt NoDbgRegParms
genSaveStackPointers(AbstractInstruction * self_in_genSaveStackPointers)
{
	sqInt _address;
	sqInt _address2;

	/* begin MoveR:Aw: */
	_address = framePointerAddress();
	/* begin gen:operand:literal: */
	checkLiteralforInstruction(_address, genoperandoperand(MoveRAw, FPReg, _address));
	/* end gen:operand:literal: */
	/* end MoveR:Aw: */
	/* begin MoveR:Aw: */
	_address2 = stackPointerAddress();
	/* begin gen:operand:literal: */
	checkLiteralforInstruction(_address2, genoperandoperand(MoveRAw, SPReg, _address2));
	/* end gen:operand:literal: */
	/* end MoveR:Aw: */
	return 0;
}
/*	C6.2.206 OOR (shifted register) 
	 
	Bitwise inclusive OR (shifted register) performs a bitwise inclusive OR of 
	a register value and an optionally-shifted register value, and writes the 
	result to the destination register. 
	 
	OOR <Xd>, <Xn>, <Xm>{, <shift> #<amount>} */
/* CogARMv8Compiler>>#inclusiveOrSize:firstRegister:secondRegister:destinationRegister: */
static sqInt NoDbgRegParms
inclusiveOrSizefirstRegistersecondRegisterdestinationRegister(AbstractInstruction * self_in_inclusiveOrSizefirstRegistersecondRegisterdestinationRegister, sqInt _is64Bits, sqInt _firstRegister, sqInt _secondRegister, sqInt _destinationRegister)
{
	return logicalShiftedRegisterSizeopcodefirstRegistershiftedRegistershiftOptionshiftValuenegateddestinationRegister(self_in_inclusiveOrSizefirstRegistersecondRegisterdestinationRegister, _is64Bits, 1, _firstRegister, _secondRegister, 0, 0, 0, _destinationRegister);
}
/*	Answer the instruction immediately preceding followingAddress. */
/* CogARMv8Compiler>>#instructionBeforeAddress: */
static uint32_t NoDbgRegParms
instructionBeforeAddress(AbstractInstruction * self_in_instructionBeforeAddress, sqInt _followingAddress)
{
	return uint32AtPointer(_followingAddress - 4);
}
/*	is this a BLX <targetReg> instruction? */
/* CogARMv8Compiler>>#instructionIsBLX: */
static sqInt NoDbgRegParms
instructionIsBLX(AbstractInstruction * self_in_instructionIsBLX, sqInt _instr)
{
	return (conditionIsNotNever(self_in_instructionIsBLX, _instr)) && ((_instr & 0xFFFFFF0) == 19922736);
}
/*	is this a BL <label> instruction? */
/* CogARMv8Compiler>>#instructionIsBL: */
static sqInt NoDbgRegParms
instructionIsBL(AbstractInstruction * self_in_instructionIsBL, sqInt _instr)
{
	seeAlso(self_in_instructionIsBL, bl);
	return (_instr & (37U << 26)) == (37U << 26);
}
/*	is this a B <label> instruction? */
/* CogARMv8Compiler>>#instructionIsB: */
static sqInt NoDbgRegParms
instructionIsB(AbstractInstruction * self_in_instructionIsB, sqInt _instr)
{
	seeAlso(self_in_instructionIsB, b);
	return (_instr & (0x3FU << 26)) == (5U << 26);
}
/* CogARMv8Compiler>>#instructionIsConditionalBranch: */
static sqInt NoDbgRegParms
instructionIsConditionalBranch(AbstractInstruction * self_in_instructionIsConditionalBranch, sqInt _instruction)
{
	return (_instruction & (0xFFU << 24)) == (84U << 24);
}
/* CogARMv8Compiler>>#instructionIsLDR: */
static sqInt NoDbgRegParms
instructionIsLDR(AbstractInstruction * self_in_instructionIsLDR, sqInt _instr)
{
	return (_instr & (88U << 24)) == (88U << 24);
}
/*	is this a push R str r??, [sp, #-8] - instruction? */
/* CogARMv8Compiler>>#instructionIsPush: */
static sqInt NoDbgRegParms
instructionIsPush(AbstractInstruction * self_in_instructionIsPush, uint32_t _instr)
{
	return (pushR(self_in_instructionIsPush, 0)) == (_instr & 0xFFFFFFFFFFFFFFE0ULL);
}
/* CogARMv8Compiler>>#is64bitMask64: */
static sqInt NoDbgRegParms
is64bitMask64(AbstractInstruction * self_in_is64bitMask64, sqInt _aMask)
{
	return (_aMask != 0) && (((_aMask + 1) & _aMask) == 0);
}
/*	Assuming mcpc is a send return pc answer if the instruction before it is a 
	call (not a CallFull).There are two types of calls: BL and/BLX encoding */
/* CogARMv8Compiler>>#isCallPrecedingReturnPC: */
static sqInt NoDbgRegParms
isCallPrecedingReturnPC(AbstractInstruction * self_in_isCallPrecedingReturnPC, sqInt _mcpc)
{
	sqInt _call;

	/* begin instructionBeforeAddress: */
	_call = ((uint32_t) (uint32AtPointer(_mcpc - 4)) );
	/* end instructionBeforeAddress: */
	return (instructionIsBL(self_in_isCallPrecedingReturnPC, _call)) || (instructionIsBLX(self_in_isCallPrecedingReturnPC, _call));
}
/*	ARM calls and jumps span +/- 32 mb, more than enough for intra-zone calls 
	and jumps. */
/* CogARMv8Compiler>>#isInImmediateJumpRange: */
static sqInt NoDbgRegParms
isInImmediateJumpRange(AbstractInstruction * self_in_isInImmediateJumpRange, usqIntptr_t _operand)
{
	return (((int) _operand ) >= -33554432) && (((int) _operand ) <= 0x1FFFFFC);
}
/*	If ADR <Xd>, <label> */
/* CogARMv8Compiler>>#isPCRelativeValueLoad: */
static sqInt NoDbgRegParms
isPCRelativeValueLoad(AbstractInstruction * self_in_isPCRelativeValueLoad, unsigned int _instr)
{
	return (_instr & (159U << 24)) == (1U << 28);
}
/* CogARMv8Compiler>>#isShiftable16bitImmediate: */
static sqInt NoDbgRegParms
isShiftable16bitImmediate(AbstractInstruction * self_in_isShiftable16bitImmediate, sqInt _constant)
{
	sqInt _i;
	sqInt _shiftedValue;
	int _shiftMagnitude;

	/* begin shiftable16bitImmediate:ifTrue:ifFalse: */
	if ((_constant & 0xFFFF) == _constant) {
		return 1;
	}
	for (_i = 0; _i <= 1; _i += 1) {
		_shiftMagnitude = (1ULL << _i) * 16;
		_shiftedValue = ((usqInt) _constant ) >> _shiftMagnitude;
		if ((((sqInt) (((usqInt) _shiftedValue ) << _shiftMagnitude) ) == _constant) && ((_shiftedValue & 0xFFFF) == _shiftedValue)) {
			return 1;
		}
	}
	return 0;
	/* end shiftable16bitImmediate:ifTrue:ifFalse: */
}
/* CogARMv8Compiler>>#isShiftedMask: */
static sqInt NoDbgRegParms
isShiftedMask(AbstractInstruction * self_in_isShiftedMask, sqInt _aMask)
{
	return (_aMask != 0) && (is64bitMask64(self_in_isShiftedMask, (_aMask - 1) | _aMask));
}
/*	Branch/Call ranges. Jump[Cond] can be generated as short as possible. 
	Call/Jump[Cond]Long must be generated 
	in the same number of bytes irrespective of displacement since their 
	targets may be updated, but they need only 
	span 16Mb, the maximum size of the code zone. This allows e.g. ARM to use 
	single-word call and jump instructions 
	for most calls and jumps. CallFull/JumpFull must also be generated in the 
	same number of bytes irrespective of 
	displacement for the same reason, but they must be able to span the full 
	(32-bit or 64-bit) address space because 
	they are used to call code in the C runtime, which may be distant from the 
	code zone */
/* CogARMv8Compiler>>#jumpLongByteSize */
static sqInt NoDbgRegParms
jumpLongByteSize(AbstractInstruction * self_in_jumpLongByteSize)
{
	return 4;
}
/*	AArch64 does not have conditional long jumps. Be a short conditional jump 
	and a long jump */
/* CogARMv8Compiler>>#jumpLongConditionalByteSize */
static sqInt NoDbgRegParms
jumpLongConditionalByteSize(AbstractInstruction * self_in_jumpLongConditionalByteSize)
{
	return 8;
}
/*	Answer the target address for the long jump immediately preceding mcpc */
/* CogARMv8Compiler>>#jumpLongTargetBeforeFollowingAddress: */
static sqInt NoDbgRegParms
jumpLongTargetBeforeFollowingAddress(AbstractInstruction * self_in_jumpLongTargetBeforeFollowingAddress, sqInt _mcpc)
{
	return callTargetFromReturnAddress(self_in_jumpLongTargetBeforeFollowingAddress, _mcpc);
}
/*	 
	C7.2.177 LD1 (multiple structures) 
	 
	LD1 { <Vt>.<T> }, [<Xn|SP>] 
	 
	Load multiple single-element structures to one, two, three, or four 
	registers. This instruction loads multiple 
	single-element structures from memory and writes the result to one, two, 
	three, or four SIMD&FP registers.  
	Every element of each register is stored. */
/* CogARMv8Compiler>>#ld1Q:OpCode:S:Rn:Rt: */
static sqInt NoDbgRegParms
ld1QOpCodeSRnRt(AbstractInstruction * self_in_ld1QOpCodeSRnRt, sqInt _q, sqInt _opCode, sqInt _size, sqInt _rn, sqInt _rt)
{
	return ((sqInt) (((usqInt) _q ) << 30) ) | ((49U << 22) | (((sqInt) (((usqInt) (_opCode & 15) ) << 12) ) | (((sqInt) (((usqInt) (_size & 3) ) << 10) ) | (((sqInt) (((usqInt) (_rn & 0x1F) ) << 5) ) | (_rt & 0x1F)))));
}
/*	 
	C7.2.177 LD1 (multiple structures) 
	 
	LD1 { <Vt>.<T> }, [<Xn|SP>], <Xm> 
	 
	Load multiple single-element structures to one, two, three, or four 
	registers. This instruction loads multiple 
	single-element structures from memory and writes the result to one, two, 
	three, or four SIMD&FP registers.  
	Every element of each register is stored. */
/* CogARMv8Compiler>>#ld1Q:Rm:OpCode:S:Rn:Rt: */
static sqInt NoDbgRegParms
ld1QRmOpCodeSRnRt(AbstractInstruction * self_in_ld1QRmOpCodeSRnRt, sqInt _q, sqInt _rm, sqInt _opCode, sqInt _size, sqInt _rn, sqInt _rt)
{
	return ((sqInt) (((usqInt) _q ) << 30) ) | ((51U << 22) | (((sqInt) (((usqInt) (_rm & 0x1F) ) << 16) ) | (((sqInt) (((usqInt) (_opCode & 15) ) << 12) ) | (((sqInt) (((usqInt) (_size & 3) ) << 10) ) | (((sqInt) (((usqInt) (_rn & 0x1F) ) << 5) ) | (_rt & 0x1F))))));
}
/*	C6.2.135 LDRB (immediate) 
	 
	Load Register Byte (immediate) loads a byte from memory, zero-extends it, 
	and writes the result to a register. The address that is used for the load 
	is calculated from a base register and an immediate offset. For 
	information about memory accesses, see Load/Store addressing modes on page 
	C1-189.  
	Unsigned offset variant 
	LDRB <Wt>, [<Xn|SP>{, #<pimm>}] */
/* CogARMv8Compiler>>#ldrbSourceRegister:destinationRegister: */
static sqInt NoDbgRegParms
ldrbSourceRegisterdestinationRegister(AbstractInstruction * self_in_ldrbSourceRegisterdestinationRegister, sqInt _sourceRegister, sqInt _destinationRegister)
{
	return ldrbSourceRegisterdestinationRegisteroffset(self_in_ldrbSourceRegisterdestinationRegister, _sourceRegister, _destinationRegister, 0);
}
/*	C6.2.135 LDRB (immediate) 
	 
	Load Register Byte (immediate) loads a byte from memory, zero-extends it, 
	and writes the result to a register. The address that is used for the load 
	is calculated from a base register and an immediate offset. For 
	information about memory accesses, see Load/Store addressing modes on page 
	C1-189.  
	Unsigned offset variant 
	LDRB <Wt>, [<Xn|SP>{, #<pimm>}] */
/* CogARMv8Compiler>>#ldrbSourceRegister:destinationRegister:offset: */
static sqInt NoDbgRegParms
ldrbSourceRegisterdestinationRegisteroffset(AbstractInstruction * self_in_ldrbSourceRegisterdestinationRegisteroffset, sqInt _sourceRegister, sqInt _destinationRegister, sqInt _immediate12BitValue)
{
	return (7U << 27) | ((1U << 24) | ((1U << 22) | (((sqInt) (((usqInt) (_immediate12BitValue & 0xFFF) ) << 10) ) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)))));
}
/*	C6.2.136 LDRB (register) 
	 
	Load Register Byte (register) calculates an address from a base register 
	value and an offset register value, loads a byte from memory, zero-extends 
	it, and writes it to a register.  
	 
	Shifted register variant 
	LDRB <Wt>, [<Xn|SP>, <Xm>{, LSL <amount>}] */
/* CogARMv8Compiler>>#ldrbSourceRegister:offsetRegister:destinationRegister: */
static sqInt NoDbgRegParms
ldrbSourceRegisteroffsetRegisterdestinationRegister(AbstractInstruction * self_in_ldrbSourceRegisteroffsetRegisterdestinationRegister, sqInt _sourceRegister, sqInt _offsetRegister, sqInt _destinationRegister)
{
	return (7U << 27) | ((3U << 21) | (((sqInt) (((usqInt) (_offsetRegister & 0x1F) ) << 16) ) | ((13U << 11) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)))));
}
/*	C6.2.137 
	LDRH (immediate) 
	Load Register Halfword (immediate) loads a halfword from memory, 
	zero-extends it, and writes the result to a register. The address that is 
	used for the load is calculated from a base register and an immediate 
	offset. For information about memory accesses, see Load/Store addressing 
	modes on page C1-189.LDRH <Wt>, [<Xn|SP>{, #<pimm>}] */
/* CogARMv8Compiler>>#ldrhBaseRegister:offsetDividedBy2:destinationRegister: */
static sqInt NoDbgRegParms
ldrhBaseRegisteroffsetDividedBy2destinationRegister(AbstractInstruction * self_in_ldrhBaseRegisteroffsetDividedBy2destinationRegister, sqInt _baseRegister, sqInt _offset12Bits, sqInt _destinationRegister)
{
	return (485U << 22) | (((sqInt) (((usqInt) (_offset12Bits & 0xFFF) ) << 10) ) | (((sqInt) (((usqInt) (_baseRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)));
}
/*	Encodes a Load Register (immediate) instruction of the form 
	 
	LDR <Xt>, [<Xn|SP>, #<simm>]! */
/* CogARMv8Compiler>>#ldrSize:baseRegister:signedOffset:destinationRegister:preIndex: */
static sqInt NoDbgRegParms
ldrSizebaseRegistersignedOffsetdestinationRegisterpreIndex(AbstractInstruction * self_in_ldrSizebaseRegistersignedOffsetdestinationRegisterpreIndex, sqInt _is64Bits, sqInt _baseReg, sqInt _immediate9bitValue, sqInt _destinationRegister, sqInt _preIndex)
{
	assert(_immediate9bitValue > 0);
	return (1U << 0x1F) | (((sqInt) (((usqInt) (_is64Bits & 1) ) << 30) ) | ((450U << 21) | (((sqInt) (((usqInt) (_immediate9bitValue & 0x1FF) ) << 12) ) | (((sqInt) (((usqInt) _preIndex ) << 11) ) | ((1U << 10) | (((sqInt) (((usqInt) (_baseReg & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)))))));
}
/*	C7.2.191 LDR (immediate, SIMD&FP) 
	 
	Load SIMD&FP Register (immediate offset). This instruction loads an 
	element from memory, and writes the result as a scalar to the SIMD&FP 
	register. The address that is used for the load is calculated from a base 
	register value, a signed immediate offset, and an optional offset that is 
	a multiple of the element size. 
	 
	Unsigned offset Variant 
	LDR <Dt>, [<Xn|SP>{, #<pimm>}] */
/* CogARMv8Compiler>>#ldrSize:baseRegister:unsignedOffset:destinationFloatingPointRegister:is128BitVariant: */
static sqInt NoDbgRegParms
ldrSizebaseRegisterunsignedOffsetdestinationFloatingPointRegisteris128BitVariant(AbstractInstruction * self_in_ldrSizebaseRegisterunsignedOffsetdestinationFloatingPointRegisteris128BitVariant, sqInt _size, sqInt _baseReg, sqInt _immediate12bitValue, sqInt _destinationRegister, sqInt _is128BitVariant)
{
	return ((sqInt) (((usqInt) (_size & 3) ) << 30) ) | ((15U << 26) | ((1U << 24) | (((sqInt) (((usqInt) (_is128BitVariant & 1) ) << 23) ) | ((1U << 22) | (((sqInt) (((usqInt) (_immediate12bitValue & 0xFFF) ) << 10) ) | (((sqInt) (((usqInt) (_baseReg & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)))))));
}
/*	C6.2.131 LDR (immediate) 
	 
	oad Register (immediate) loads a word or doubleword from memory and writes 
	it to a register. The address that is used for the load is calculated from 
	a base register and an immediate offset. 
	 
	Unsigned offset variant 
	 
	LDR <Xt>, [<Xn|SP>{, #<pimm>}] */
/* CogARMv8Compiler>>#ldrSize:baseRegister:unsignedOffset:destinationRegister: */
static sqInt NoDbgRegParms
ldrSizebaseRegisterunsignedOffsetdestinationRegister(AbstractInstruction * self_in_ldrSizebaseRegisterunsignedOffsetdestinationRegister, sqInt _is64Bits, sqInt _baseReg, sqInt _immediate12bitValue, sqInt _destinationRegister)
{
	assert((_is64Bits == 0) || (_is64Bits == 1));
	assert(_immediate12bitValue >= 0);
	return (1U << 0x1F) | (((sqInt) (((usqInt) (_is64Bits & 1) ) << 30) ) | ((229U << 22) | (((sqInt) (((usqInt) ((_immediate12bitValue / (((_is64Bits == 1)
		 ? 8
		 : 4))) & 0xFFF) ) << 10) ) | (((sqInt) (((usqInt) (_baseReg & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)))));
}
/*	C6.2.133 LDR (register) 
	 
	Load Register (register) calculates an address from a base register value 
	and an offset register value, loads a word from memory, and writes it to a 
	register. The offset register value can optionally be shifted and extended 
	 
	LDR <Xt>, [<Xn|SP>, (<Wm>|<Xm>){, <extend> {<amount>}}] */
/* CogARMv8Compiler>>#ldrSize:indexRegister:baseRegister:destinationRegister: */
static sqInt NoDbgRegParms
ldrSizeindexRegisterbaseRegisterdestinationRegister(AbstractInstruction * self_in_ldrSizeindexRegisterbaseRegisterdestinationRegister, sqInt _is64Bits, sqInt _indexRegister, sqInt _baseRegister, sqInt _destinationRegister)
{
	return ldrSizeindexRegisteroptionscalebaseRegisterdestinationRegister(self_in_ldrSizeindexRegisterbaseRegisterdestinationRegister, _is64Bits, _indexRegister, 3, 0, _baseRegister, _destinationRegister);
}
/*	C6.2.133 LDR (register) 
	 
	Load Register (register) calculates an address from a base register value 
	and an offset register value, loads a word from memory, and writes it to a 
	register. The offset register value can optionally be shifted and extended 
	 
	LDR <Xt>, [<Xn|SP>, (<Wm>|<Xm>){, <extend> {<amount>}}] */
/* CogARMv8Compiler>>#ldrSize:indexRegister:option:scale:baseRegister:destinationRegister: */
static sqInt NoDbgRegParms
ldrSizeindexRegisteroptionscalebaseRegisterdestinationRegister(AbstractInstruction * self_in_ldrSizeindexRegisteroptionscalebaseRegisterdestinationRegister, sqInt _is64Bits, sqInt _indexRegister, sqInt _extendShiftOption, sqInt _isScaled, sqInt _baseRegister, sqInt _destinationRegister)
{
	return (1U << 0x1F) | (((sqInt) (((usqInt) (_is64Bits & 1) ) << 30) ) | ((451U << 21) | (((sqInt) (((usqInt) (_indexRegister & 0x1F) ) << 16) ) | (((sqInt) (((usqInt) (_extendShiftOption & 7) ) << 13) ) | (((sqInt) (((usqInt) (_isScaled & 1) ) << 12) ) | ((2U << 10) | (((sqInt) (((usqInt) (_baseRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F))))))));
}
/*	Encodes a Load Register (immediate) instruction of the form 
	 
	LDR <Xt>, <label> */
/* CogARMv8Compiler>>#ldrSize:programCounterRelativeOffset:destinationRegister: */
static sqInt NoDbgRegParms
ldrSizeprogramCounterRelativeOffsetdestinationRegister(AbstractInstruction * self_in_ldrSizeprogramCounterRelativeOffsetdestinationRegister, sqInt _is64Bits, sqInt _immediate19bitValue, sqInt _destinationRegister)
{
	sqInt _multiplier;
	sqInt _twoComplement;

	_multiplier = _immediate19bitValue / 4;
	_twoComplement = ((_multiplier > 0)
		 ? _multiplier
		 : (0x7FFFF - (SQABS(_multiplier))) + 1);
	return (0U << 0x1F) | (((sqInt) (((usqInt) (_is64Bits & 1) ) << 30) ) | ((24U << 24) | (((sqInt) (((usqInt) (_twoComplement & 0x7FFFF) ) << 5) ) | (_destinationRegister & 0x1F))));
}
/*	C6.2.168 LDURB 
	 
	Load Register Byte (unscaled) calculates an address from a base register 
	and an immediate offset, loads a byte from memory, zero-extends it, and 
	writes it to a register. 
	 
	LDURB <Wt>, [<Xn|SP>{, #<simm>}] */
/* CogARMv8Compiler>>#ldurbSize:baseRegister:signedOffset:destinationRegister: */
static sqInt NoDbgRegParms
ldurbSizebaseRegistersignedOffsetdestinationRegister(AbstractInstruction * self_in_ldurbSizebaseRegistersignedOffsetdestinationRegister, sqInt is64Bits, sqInt _baseRegister, sqInt _immediate9bitTwoComplementOffset, sqInt _destinationRegister)
{
	return (450U << 21) | (((sqInt) (((usqInt) (_immediate9bitTwoComplementOffset & 0x1FF) ) << 12) ) | (((sqInt) (((usqInt) (_baseRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)));
}
/*	C6.2.167 LDUR 
	 
	Load Register (unscaled) calculates an address from a base register and an 
	immediate offset, loads a 32-bit word or 64-bit doubleword from memory, 
	zero-extends it, and writes it to a register. 
	 
	LDUR <Xt>, [<Xn|SP>{, #<simm>}] */
/* CogARMv8Compiler>>#ldurSize:baseRegister:signedOffset:destinationRegister: */
static sqInt NoDbgRegParms
ldurSizebaseRegistersignedOffsetdestinationRegister(AbstractInstruction * self_in_ldurSizebaseRegistersignedOffsetdestinationRegister, sqInt _is64Bits, sqInt _baseReg, sqInt _immediate9bitValue, sqInt _destinationRegister)
{
	sqInt _twoComplement;

	_twoComplement = ((_immediate9bitValue > 0)
		 ? _immediate9bitValue
		 : (0x1FF - (SQABS(_immediate9bitValue))) + 1);
	assert(_twoComplement > 0);
	return (1U << 0x1F) | (((sqInt) (((usqInt) (_is64Bits & 1) ) << 30) ) | ((450U << 21) | (((sqInt) (((usqInt) (_twoComplement & 0x1FF) ) << 12) ) | (((sqInt) (((usqInt) (_baseReg & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)))));
}
/*	Return how many leading ones are in the 64bit bitString representation of 
	aNumber. That is, how many ones are in the most significant bits before 
	there is a zero. 
	For example, the 64bit binary number 2r11101101000110001111...00 has 3 
	leading onesCalculate it by calculating the leading zeros of the bit-inverted number */
/* CogARMv8Compiler>>#leadingOnesOf: */
static sqInt NoDbgRegParms
leadingOnesOf(AbstractInstruction * self_in_leadingOnesOf, sqInt _aNumber)
{
	return leadingZerosOf(self_in_leadingOnesOf, _aNumber ^ 0xFFFFFFFFFFFFFFFFULL);
}
/*	Return how many leading zeros are in the 64bit bitString representation of 
	aNumber. That is, how many zeros are in the most significant bits before 
	there is a one. 
	For example, the 64bit binary number 2r00010101000110001111000...00 has 3 
	trailing zeros. 
	 
	Uses a bisect method looking at the number by halfsWe take a look at the most significant part of the number by ignoring the 
	lower part (shifting it). 
	If the non ignored part is not all zeros, continue the procedure with the 
	non-ignored bits. 
	On each iteration, ignore less (dividing the shift by two) because there 
	may be more leading zeros. 
	 */
/* CogARMv8Compiler>>#leadingZerosOf: */
static sqInt NoDbgRegParms
leadingZerosOf(AbstractInstruction * self_in_leadingZerosOf, sqInt _aNumber)
{
	sqInt _currentNumber;
	sqInt _shift;
	sqInt _shiftedValue;
	int _zeroBits;

	_zeroBits = 0;
	_currentNumber = _aNumber;
	_shift = ((usqInt) 64 ) >> 1;
	while (_shift != 0) {
		_shiftedValue = ((usqInt) _currentNumber ) >> _shift;
		if (_shiftedValue != 0) {
			_currentNumber = _shiftedValue;
		} else {
			_zeroBits = _zeroBits | _shift;
		}
		_shift = ((usqInt) _shift ) >> 1;
	}
	return _zeroBits;
}
/* CogARMv8Compiler>>#literalBeforeInlineCacheTagAt: */
static sqInt NoDbgRegParms
literalBeforeInlineCacheTagAt(AbstractInstruction * self_in_literalBeforeInlineCacheTagAt, sqInt callSiteReturnAddress)
{
	/* begin notYetImplemented: */
	{
		logError("Should implement access to the class in directed super sends for ARMv8");
		abort();
	}
	/* end notYetImplemented: */
	return 0;
}
/*	Load the operand into the destination register, answering 
	the size of the instructions generated to do so. */
/* CogARMv8Compiler>>#loadCwInto: */
static usqInt NoDbgRegParms
loadCwInto(AbstractInstruction * self_in_loadCwInto, sqInt _destReg)
{
	sqInt _aWord;
	sqInt _aWord2;
	sqInt _distance;
	usqInt _operand;

	_operand = (self_in_loadCwInto->operands)[0];
	if ((addressIsInInstructions(((AbstractInstruction *) _operand ))) || (((AbstractInstruction *) _operand ) == (methodLabel()))) {
		_operand = ((((AbstractInstruction *) _operand ))->address);
	}
	if ((((usqInt) _operand ) >= ((methodLabel->address))) && (((usqInt) _operand ) < (youngReferrers()))) {
		_distance = _operand - ((self_in_loadCwInto->address));
		if (((SQABS(_distance)) & 0xFFFFF) == (SQABS(_distance))) {
			/* begin machineCodeAt:put: */
			_aWord = adrSignedImmediate21BitsValuedestinationRegister(self_in_loadCwInto, _distance, _destReg);
			(self_in_loadCwInto->machineCode)[0 / 4] = _aWord;
			/* end machineCodeAt:put: */
			return ((self_in_loadCwInto->machineCodeSize) = 4);
		} else {
			/* begin notYetImplemented */
			/* begin notYetImplemented: */
			{
				logError("Not Yet Implemented!");
				abort();
			}
			/* end notYetImplemented: */
			/* end notYetImplemented */
		}
	}
	/* begin moveCw:intoR: */
	/* begin loadRelativeLiteralIn: */
	assert(((((self_in_loadCwInto->dependent))->opcode)) == Literal);
	assert(addressIsInCurrentCompilation((((self_in_loadCwInto->dependent))->address)));
	assert((SQABS(((((self_in_loadCwInto->dependent))->address)) - (((self_in_loadCwInto->address)) + 8))) < (1U << 12));
	/* begin machineCodeAt:put: */
	_aWord2 = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_loadCwInto, 1, ((((self_in_loadCwInto->dependent))->address)) - ((self_in_loadCwInto->address)), _destReg);
	(self_in_loadCwInto->machineCode)[0 / 4] = _aWord2;
	/* end machineCodeAt:put: */
	/* end loadRelativeLiteralIn: */
	return ((self_in_loadCwInto->machineCodeSize) = 4);
	/* end moveCw:intoR: */
}
/*	Answer the byte size of a MoveCwR opcode's corresponding machine code 
	when the argument is a PIC. This is for the self-reference at the end of a 
	closed PIC. On ARM this is a single instruction pc-relative register load. */
/* CogARMv8Compiler>>#loadPICLiteralByteSize */
static sqInt NoDbgRegParms
loadPICLiteralByteSize(AbstractInstruction * self_in_loadPICLiteralByteSize)
{
	return 4;
}
/*	C3.3.2 Logical (immediate) 
	 
	The Logical (immediate) instructions accept a bitmask immediate value that 
	is a 32-bit pattern or a 64-bit pattern viewed as a vector of identical 
	elements of size e = 2, 4, 8, 16, 32 or, 64 bits. Each element contains 
	the same sub-pattern, that is a single run of 1 to (e - 1) nonzero bits 
	from bit 0 followed by zero bits, then rotated by 0 to (e - 1) bits. This 
	mechanism can generate 5334 unique 64-bit patterns as 2667 pairs of 
	pattern and their bitwise inverse. 
	 
	AND <Xd|SP>, <Xn>, #<imm> => opcode 00 
	ANDS <Xd|SP>, <Xn>, #<imm> => opcode 11 
	EOR <Xd|SP>, <Xn>, #<imm> => opcode 10 
	ORR <Xd|SP>, <Xn>, #<imm> => opcode 01 
	TST <Xd|SP>, <Xn>, #<imm> => alias of ANDS 
	 */
/* CogARMv8Compiler>>#logicalImmediate:opcode:immediate13bitValue:sourceRegister:destinationRegister: */
static sqInt NoDbgRegParms
logicalImmediateopcodeimmediate13bitValuesourceRegisterdestinationRegister(AbstractInstruction * self_in_logicalImmediateopcodeimmediate13bitValuesourceRegisterdestinationRegister, sqInt _is64Bits, sqInt _instructionOpcode, sqInt _logicalEncodedImmediate13BitValue, sqInt _sourceRegister, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) _is64Bits ) << 0x1F) ) | (((sqInt) (((usqInt) (_instructionOpcode & 3) ) << 29) ) | ((36U << 23) | (((sqInt) (((usqInt) (_logicalEncodedImmediate13BitValue & 0x1FFF) ) << 10) ) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)))));
}
/*	C3.4.5 Logical (shifted register) 
	 
	The Logical (shifted register) instructions apply an optional shift 
	operator to the second source register value before performing the main 
	operation. The register width of the instruction controls whether the new 
	bits are fed into the intermediate result on a right shift or rotate at 
	bit[63] or bit[31]. 
	The shift operators LSL, ASR, LSR, and ROR accept a constant immediate 
	shift amount in the range 0 to one less than the register width of the 
	instruction, inclusive. 
	Omitting the shift operator and amount implies LSL #0, which means that 
	there is no shift. A disassembler must not output LSL #0. However, a 
	disassembler must output all other shifts by zero. */
/* CogARMv8Compiler>>#logicalShiftedRegisterSize:opcode:firstRegister:shiftedRegister:shiftOption:shiftValue:negated:destinationRegister: */
static sqInt NoDbgRegParms
logicalShiftedRegisterSizeopcodefirstRegistershiftedRegistershiftOptionshiftValuenegateddestinationRegister(AbstractInstruction * self_in_logicalShiftedRegisterSizeopcodefirstRegistershiftedRegistershiftOptionshiftValuenegateddestinationRegister, sqInt _is64Bits, sqInt _logicalOpcode, sqInt _firstRegister, sqInt _shiftedRegister, sqInt _shiftOption, sqInt _immediate6BitsValue, sqInt _negatedFlag, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) _is64Bits ) << 0x1F) ) | (((sqInt) (((usqInt) (_logicalOpcode & 3) ) << 29) ) | ((10U << 24) | (((sqInt) (((usqInt) (_shiftOption & 3) ) << 22) ) | (((sqInt) (((usqInt) (_negatedFlag & 1) ) << 21) ) | (((sqInt) (((usqInt) (_shiftedRegister & 0x1F) ) << 16) ) | (((sqInt) (((usqInt) (_immediate6BitsValue & 0x3F) ) << 10) ) | (((sqInt) (((usqInt) (_firstRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F))))))));
}
/*	C6.2.177 LSL (register) 
	 
	Logical Shift Left (register) shifts a register value left by a variable 
	number of bits, shifting in zeros, and writes the result to the 
	destination register. The remainder obtained by dividing the second source 
	register by the data size defines the number of bits by which the first 
	source register is left-shifted. 
	 
	LSL <Xd>, <Xn>, <Xm> */
/* CogARMv8Compiler>>#logicalShiftLeftSize:sourceRegister:shiftRegister:destinationRegister: */
static sqInt NoDbgRegParms
logicalShiftLeftSizesourceRegistershiftRegisterdestinationRegister(AbstractInstruction * self_in_logicalShiftLeftSizesourceRegistershiftRegisterdestinationRegister, sqInt _is64bits, sqInt _sourceRegister, sqInt _shiftRegister, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) _is64bits ) << 0x1F) ) | ((214U << 21) | (((sqInt) (((usqInt) (_shiftRegister & 0x1F) ) << 16) ) | ((1U << 13) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)))));
}
/*	C6.2.178 LSL (immediate) 
	 
	Logical Shift Left (immediate) shifts a register value left by an 
	immediate number of bits, shifting in zeros, and writes the result to the 
	destination register. 
	 
	LSL <Xd>, <Xn>, #<shift> */
/* CogARMv8Compiler>>#logicalShiftLeftSize:sourceRegister:shiftValue:destinationRegister: */
static sqInt NoDbgRegParms
logicalShiftLeftSizesourceRegistershiftValuedestinationRegister(AbstractInstruction * self_in_logicalShiftLeftSizesourceRegistershiftValuedestinationRegister, sqInt _is64Bits, sqInt _sourceRegister, sqInt _shiftValue, sqInt _destinationRegister)
{
	int _base;

	_base = ((_is64Bits == 1)
		 ? 64
		 : 32);
	return unsignedBitfieldMoveSizeimmrimmssourceRegisterdestinationRegister(self_in_logicalShiftLeftSizesourceRegistershiftValuedestinationRegister, _is64Bits, -_shiftValue % _base, (_base - 1) - _shiftValue, _sourceRegister, _destinationRegister);
}
/*	C6.2.181 LSR (immediate) 
	 
	Logical Shift Right (immediate) shifts a register value right by an 
	immediate number of bits, shifting in zeros, and writes the result to the 
	destination register. 
	 
	LSR <Xd>, <Xn>, #<shift> */
/* CogARMv8Compiler>>#logicalShiftRightSize:sourceRegister:shiftValue:destinationRegister: */
static sqInt NoDbgRegParms
logicalShiftRightSizesourceRegistershiftValuedestinationRegister(AbstractInstruction * self_in_logicalShiftRightSizesourceRegistershiftValuedestinationRegister, sqInt _is64Bits, sqInt _sourceRegister, sqInt _shiftValue, sqInt _destinationRegister)
{
	return unsignedBitfieldMoveSizeimmrimmssourceRegisterdestinationRegister(self_in_logicalShiftRightSizesourceRegistershiftValuedestinationRegister, _is64Bits, _shiftValue, ((_is64Bits == 1)
		 ? 0x3F
		 : 0x1F), _sourceRegister, _destinationRegister);
}
/*	C6.2.187 
	 
	Move (wide immediate) moves a 16-bit immediate value to a register. 
	 
	MOV <Xd>, #<imm> 
	MOVZ <Xd>, #<imm16>, LSL #<shift> 
	 
	shift is a magnitude to shift left with values in (0, 16, 32, 64) encoded 
	as shift/16 
	 */
/* CogARMv8Compiler>>#movSize:destinationRegister:imm:shift: */
static sqInt NoDbgRegParms
movSizedestinationRegisterimmshift(AbstractInstruction * self_in_movSizedestinationRegisterimmshift, sqInt _is64Bits, sqInt _destinationRegister, sqInt _immediate16bitValue, sqInt _shift)
{
	return ((sqInt) (((usqInt) _is64Bits ) << 0x1F) ) | ((165U << 23) | (((sqInt) (((usqInt) ((_shift / 16) & 3) ) << 21) ) | (((sqInt) (((usqInt) _immediate16bitValue ) << 5) ) | (_destinationRegister & 0x1F))));
}
/*	C6.2.191 MOVN 
	 
	Complete me pliz 
	 */
/* CogARMv8Compiler>>#movSize:destinationRegister:negatedImm:shift: */
static sqInt NoDbgRegParms
movSizedestinationRegisternegatedImmshift(AbstractInstruction * self_in_movSizedestinationRegisternegatedImmshift, sqInt _is64Bits, sqInt _destinationRegister, sqInt _immediate16bitValue, sqInt _shift)
{
	return ((sqInt) (((usqInt) _is64Bits ) << 0x1F) ) | ((37U << 23) | (((sqInt) (((usqInt) ((_shift / 16) & 3) ) << 21) ) | (((sqInt) (((usqInt) _immediate16bitValue ) << 5) ) | (_destinationRegister & 0x1F))));
}
/*	C6.2.185 MOV (to/from SP) 
	 
	Move between register and stack pointer : Rd = Rn. 
	 
	MOV <Xd|SP>, <Xn|SP> 
	 
	 */
/* CogARMv8Compiler>>#movSize:sourceRegisterMaybeSP:destinationRegisterMaybeSP: */
static sqInt NoDbgRegParms
movSizesourceRegisterMaybeSPdestinationRegisterMaybeSP(AbstractInstruction * self_in_movSizesourceRegisterMaybeSPdestinationRegisterMaybeSP, sqInt _is64Bits, sqInt _sourceRegister, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) _is64Bits ) << 0x1F) ) | ((17U << 24) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)));
}
/*	C6.2.189 
	 
	Move (register) copies the value in a source register to the destination 
	register.  
	MOV <Xd>, <Xm> 
	 
	 */
/* CogARMv8Compiler>>#movSize:sourceRegister:destinationRegister: */
static sqInt NoDbgRegParms
movSizesourceRegisterdestinationRegister(AbstractInstruction * self_in_movSizesourceRegisterdestinationRegister, sqInt _is64Bits, sqInt _sourceRegister, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) _is64Bits ) << 0x1F) ) | ((336U << 21) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 16) ) | ((0x1FU << 5) | (_destinationRegister & 0x1F))));
}
/* CogARMv8Compiler>>#movToFromSP:rn: */
static sqInt NoDbgRegParms
movToFromSPrn(AbstractInstruction * self_in_movToFromSPrn, sqInt _destinationRegister, sqInt _sourceRegister)
{
	return movSizesourceRegisterMaybeSPdestinationRegisterMaybeSP(self_in_movToFromSPrn, 1, _sourceRegister, _destinationRegister);
}
/* CogARMv8Compiler>>#mov:rn: */
static sqInt NoDbgRegParms
movrn(AbstractInstruction * self_in_movrn, sqInt _destReg, sqInt _srcReg)
{
	return movSizesourceRegisterdestinationRegister(self_in_movrn, 1, _srcReg, _destReg);
}
/*	C6.2.196 MSUB 
	 
	Multiply-Subtract multiplies two register values, subtracts the product 
	from a third register value, and writes the result to the destination 
	register.  
	MSUB <Xd>, <Xn>, <Xm>, <Xa> */
/* CogARMv8Compiler>>#msubSize:minuendReg:factor1Reg:factor2Reg:destinationRegister: */
static sqInt NoDbgRegParms
msubSizeminuendRegfactor1Regfactor2RegdestinationRegister(AbstractInstruction * self_in_msubSizeminuendRegfactor1Regfactor2RegdestinationRegister, sqInt _is64Bits, sqInt _minuendReg, sqInt _factor1Reg, sqInt _factor2Reg, sqInt _destinationReg)
{
	return ((sqInt) (((usqInt) _is64Bits ) << 0x1F) ) | ((27U << 24) | (((sqInt) (((usqInt) (_factor2Reg & 0x1F) ) << 16) ) | ((1U << 15) | (((sqInt) (((usqInt) (_minuendReg & 0x1F) ) << 10) ) | (((sqInt) (((usqInt) (_factor1Reg & 0x1F) ) << 5) ) | (_destinationReg & 0x1F))))));
}
/*	C6.2.197 MUL 
	 
	Multiply : Rd = Rn * Rm 
	 
	MUL <Xd>, <Xn>, <Xm> */
/* CogARMv8Compiler>>#mulSize:firstRegister:secondRegister:destinationRegister: */
static sqInt NoDbgRegParms
mulSizefirstRegistersecondRegisterdestinationRegister(AbstractInstruction * self_in_mulSizefirstRegistersecondRegisterdestinationRegister, sqInt _is64bits, sqInt _registerA, sqInt _registerB, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) (_is64bits & 1) ) << 0x1F) ) | ((27U << 24) | (((sqInt) (((usqInt) (_registerB & 0x1F) ) << 16) ) | ((0x1FU << 10) | (((sqInt) (((usqInt) (_registerA & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)))));
}
/*	C6.2.199 NEG (shifted register) 
	 
	Negate (shifted register) negates an optionally-shifted register value, 
	and writes the result to the destination register. 
	 
	NEG <Xd>, <Xm>{, <shift> #<amount>} 
	 
	shiftType is the optional shift type to be applied to the second source 
	operand, defaulting to LSL and encoded in the shift field. It can have the 
	following values: 
	LSL when shift = 00 
	LSR when shift = 01 
	ASR when shift = 10 
	 */
/* CogARMv8Compiler>>#negateSize:sourceRegister:sourceRegisterShiftType:sourceRegisterShift:destinationRegister: */
static sqInt NoDbgRegParms
negateSizesourceRegistersourceRegisterShiftTypesourceRegisterShiftdestinationRegister(AbstractInstruction * self_in_negateSizesourceRegistersourceRegisterShiftTypesourceRegisterShiftdestinationRegister, sqInt _is64Bits, sqInt _sourceRegister, sqInt _immediate2bitShiftType, sqInt _immediate6bitsShiftValue, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) _is64Bits ) << 0x1F) ) | ((75U << 24) | (((sqInt) (((usqInt) (_immediate2bitShiftType & 3) ) << 22) ) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 16) ) | (((sqInt) (((usqInt) (_immediate6bitsShiftValue & 0x3F) ) << 10) ) | ((0x1FU << 5) | (_destinationRegister & 0x1F))))));
}
/*	C6.2.203 NOP 
	 
	No Operation does nothing, other than advance the value of the program 
	counter by 4. This instruction can be used for instruction alignment 
	purposes  
	NOP */
/* CogARMv8Compiler>>#nop */
static sqInt NoDbgRegParms
nop(AbstractInstruction * self_in_nop)
{
	return 3573751839U;
}
/* CogARMv8Compiler>>#numIntRegArgs */
static sqInt NoDbgRegParms
numIntRegArgs(AbstractInstruction * self_in_numIntRegArgs)
{
	return 4;
}
/*	C6.2.205 ORR (immediate) 
	 
	Bitwise OR (immediate) performs a bitwise (inclusive) OR of a register 
	value and an immediate register value, and writes the result to the 
	destination register. 
	 
	ORR <Xd|SP>, <Xn>, #<imm> */
/* CogARMv8Compiler>>#orSize:immediate13bitValue:sourceRegister:destinationRegister: */
static sqInt NoDbgRegParms
orSizeimmediate13bitValuesourceRegisterdestinationRegister(AbstractInstruction * self_in_orSizeimmediate13bitValuesourceRegisterdestinationRegister, sqInt _is64Bits, sqInt _logicalEncodedImmediate13BitValue, sqInt _sourceRegister, sqInt _destinationRegister)
{
	return logicalImmediateopcodeimmediate13bitValuesourceRegisterdestinationRegister(self_in_orSizeimmediate13bitValuesourceRegisterdestinationRegister, _is64Bits, 1, _logicalEncodedImmediate13BitValue, _sourceRegister, _destinationRegister);
}
/*	C6.2.206 Bitwise OR (shifted register)  
	performs a bitwise (inclusive) OR of a register value and an 
	optionally-shifted register value, and writes the result to the 
	destination register. */
/* CogARMv8Compiler>>#orSize:shiftedRegister:shiftType:shiftValue:withRegister:destinationRegister: */
static sqInt NoDbgRegParms
orSizeshiftedRegistershiftTypeshiftValuewithRegisterdestinationRegister(AbstractInstruction * self_in_orSizeshiftedRegistershiftTypeshiftValuewithRegisterdestinationRegister, sqInt _is64Bits, sqInt _shiftedRegister, sqInt _shiftType, sqInt _immediate6bitValue, sqInt _sourceRegister2, sqInt _destinationRegister)
{
	return logicalShiftedRegisterSizeopcodefirstRegistershiftedRegistershiftOptionshiftValuenegateddestinationRegister(self_in_orSizeshiftedRegistershiftTypeshiftValuewithRegisterdestinationRegister, _is64Bits, 1, _sourceRegister2, _shiftedRegister, _shiftType, _immediate6bitValue, 0, _destinationRegister);
}
/* CogARMv8Compiler>>#padIfPossibleWithStopsFrom:to: */
static AbstractInstruction * NoDbgRegParms
padIfPossibleWithStopsFromto(AbstractInstruction * self_in_padIfPossibleWithStopsFromto, sqInt _startAddr, sqInt _endAddr)
{
	sqInt _nullBytes;
	sqInt _p;

	_nullBytes = ((_endAddr - _startAddr) + 1) % 4;
	stopsFromto(self_in_padIfPossibleWithStopsFromto, _startAddr, _endAddr - _nullBytes);
	for (_p = (_endAddr - _nullBytes) + 1; _p <= _endAddr; _p += 1) {
		byteAtput(_p, 0xFF);
	}
	return self_in_padIfPossibleWithStopsFromto;
}
/*	pop word off TOS 
	LDR srcReg, [sp] #4 - ARM_ARM v7 DDI10406 pp. A8-120-1 */
/* CogARMv8Compiler>>#popR: */
static sqInt NoDbgRegParms
popR(AbstractInstruction * self_in_popR, sqInt _dstReg)
{
	return ldrSizebaseRegistersignedOffsetdestinationRegisterpreIndex(self_in_popR, 1, SPReg, 8, _dstReg, 0);
}
/*	C6.2.212 PRFM (immediate) 
	 
	Prefetch Memory (immediate) signals the memory system that data memory 
	accesses from a specified address are likely to occur in the near future. 
	The memory system can respond by taking actions that are expected to speed 
	up the memory accesses when they do occur, such as preloading the cache 
	line containing the specified address into one or more caches. 
	 
	PRFM (<prfop>|#<imm5>), [<Xn|SP>{, #<pimm>}] */
/* CogARMv8Compiler>>#prefetchMemory:sourceRegister:offset: */
static sqInt NoDbgRegParms
prefetchMemorysourceRegisteroffset(AbstractInstruction * self_in_prefetchMemorysourceRegisteroffset, sqInt _prefetchOperationFlags, sqInt _sourceRegister, sqInt _offset)
{
	return (998U << 22) | (((sqInt) (((usqInt) (_offset & 0xFFF) ) << 10) ) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 5) ) | (_prefetchOperationFlags & 0x1F)));
}
/*	In ARMv8 we are using an alternative SPReg that is not the machine SP. 
	We need to sync the SP register to the Smalltalk stackPointer, so the 
	called function  
	will execute correctly. */
/* CogARMv8Compiler>>#prepareStackToCallCFunctionInSmalltalkStack: */
static AbstractInstruction * NoDbgRegParms
prepareStackToCallCFunctionInSmalltalkStack(AbstractInstruction * self_in_prepareStackToCallCFunctionInSmalltalkStack, sqInt anObject)
{
	AbstractInstruction *_anInstruction;

	genoperandoperand(MoveRR, SPReg, Extra2Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(AndCqR, 0xFFFFFFFFFFFFFFF0ULL, Extra2Reg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(0xFFFFFFFFFFFFFFF0ULL));
	}
	/* end checkQuickConstant:forInstruction: */
	genoperandoperand(MoveRR, Extra2Reg, SP);
	return self_in_prepareStackToCallCFunctionInSmalltalkStack;
}
/* CogARMv8Compiler>>#pushLinkRegisterByteSize */
static sqInt NoDbgRegParms
pushLinkRegisterByteSize(AbstractInstruction * self_in_pushLinkRegisterByteSize)
{
	return 4;
}
/* CogARMv8Compiler>>#pushR: */
static sqInt NoDbgRegParms
pushR(AbstractInstruction * self_in_pushR, sqInt _srcReg)
{
	return strSizebaseRegistersignedOffsetsourceRegisterpreIndex(self_in_pushR, 1, SPReg, -8, _srcReg, 1);
}
/* CogARMv8Compiler>>#relocateCallBeforeReturnPC:by: */
static AbstractInstruction * NoDbgRegParms
relocateCallBeforeReturnPCby(AbstractInstruction * self_in_relocateCallBeforeReturnPCby, sqInt _retpc, sqInt _delta)
{
	sqInt _distanceDiv4;
	sqInt _instr;

	assert((_delta % 4) == 0);
	if (_delta != 0) {
		/* begin instructionBeforeAddress: */
		_instr = ((uint32_t) (uint32AtPointer(_retpc - 4)) );
		/* end instructionBeforeAddress: */
		assert((instructionIsB(self_in_relocateCallBeforeReturnPCby, _instr)) || (instructionIsBL(self_in_relocateCallBeforeReturnPCby, _instr)));
		_distanceDiv4 = _instr & 0xFFFFFF;
		_distanceDiv4 += _delta / 4;
		uint32AtPointerput(_retpc - 4, (_instr & 0xFF000000U) | (_distanceDiv4 & 0xFFFFFF));
	}
	return self_in_relocateCallBeforeReturnPCby;
}
/*	C6.2.219 RET 
	 
	Return from subroutine branches unconditionally to an address in a 
	register, with a hint that this is a subroutine return. */
/* CogARMv8Compiler>>#ret */
static sqInt NoDbgRegParms
ret(AbstractInstruction * self_in_ret)
{
	return (3512256U << 10) | ((sqInt) (((usqInt) LR ) << 5) );
}
/*	In ARMv8 I don't need to do nothing */
/* CogARMv8Compiler>>#returnFromCallCFunctionInSmalltalkStack: */
static AbstractInstruction * NoDbgRegParms
returnFromCallCFunctionInSmalltalkStack(AbstractInstruction * self_in_returnFromCallCFunctionInSmalltalkStack, sqInt anObject)
{
	return self_in_returnFromCallCFunctionInSmalltalkStack;
}
/*	Rewrite a call instruction to call a different target. This variant is 
	used to link PICs 
	in ceSendMiss et al,.  
	Answer the extent of the code change which is used to compute the range of 
	the icache to flush. */
/* CogARMv8Compiler>>#rewriteCallAt:target: */
static sqInt NoDbgRegParms
rewriteCallAttarget(AbstractInstruction * self_in_rewriteCallAttarget, usqInt _callSiteReturnAddress, usqInt _callTargetAddress)
{
	return rewriteTransferAttarget(self_in_rewriteCallAttarget, _callSiteReturnAddress, _callTargetAddress);
}
/*	Rewrite a jump instruction to call a different target. This variant is 
	used to reset the  
	jumps in the prototype CPIC to suit each use,.  
	Answer the extent of the code change which is used to compute the range of 
	the icache to flush. */
/* CogARMv8Compiler>>#rewriteCPICJumpAt:target: */
static sqInt NoDbgRegParms
rewriteCPICJumpAttarget(AbstractInstruction * self_in_rewriteCPICJumpAttarget, usqInt _callSiteReturnAddress, usqInt _callTargetAddress)
{
	sqInt _callDistance;
	sqInt _instr;

	if (!(_callTargetAddress >= (minCallAddress()))) {
		error("linking callsite to invalid address");
	}
	_callDistance = _callTargetAddress - (_callSiteReturnAddress - 4);
	assert(isInImmediateJumpRange(self_in_rewriteCPICJumpAttarget, _callDistance));
	/* begin instructionBeforeAddress: */
	_instr = ((uint32_t) (uint32AtPointer(_callSiteReturnAddress - 4)) );
	/* end instructionBeforeAddress: */
	assert(instructionIsConditionalBranch(self_in_rewriteCPICJumpAttarget, _instr));
	long32Atput(_callSiteReturnAddress - 4, branchConditionoffset(self_in_rewriteCPICJumpAttarget, extractConditionFromB(self_in_rewriteCPICJumpAttarget, _instr), _callDistance));
	assert((extractOffsetFromConditionalBranch(self_in_rewriteCPICJumpAttarget, branchConditionoffset(self_in_rewriteCPICJumpAttarget, extractConditionFromB(self_in_rewriteCPICJumpAttarget, _instr), _callDistance))) == _callDistance);
	return 4;
}
/*	Rewrite a jump instruction to call a different target. This variant is 
	used to reset the  
	jumps in the prototype CPIC to suit each use,.  
	Answer the extent of the code change which is used to compute the range of 
	the icache to flush. */
/* CogARMv8Compiler>>#rewriteJumpLongAt:target: */
static sqInt NoDbgRegParms
rewriteJumpLongAttarget(AbstractInstruction * self_in_rewriteJumpLongAttarget, usqInt _callSiteReturnAddress, usqInt _callTargetAddress)
{
	return rewriteTransferAttarget(self_in_rewriteJumpLongAttarget, _callSiteReturnAddress, _callTargetAddress);
}
/*	Rewrite a call/jump instruction to call a different target. This variant 
	is used to link PICs 
	in ceSendMiss et al, and to rewrite call/jumps in CPICs. 
	Answer the extent of 
	the code change which is used to compute the range of the icache to flush. */
/* CogARMv8Compiler>>#rewriteTransferAt:target: */
static sqInt NoDbgRegParms
rewriteTransferAttarget(AbstractInstruction * self_in_rewriteTransferAttarget, usqInt _callSiteReturnAddress, usqInt _callTargetAddress)
{
	sqInt _callDistance;
	sqInt _instr;

	if (!(_callTargetAddress >= (minCallAddress()))) {
		error("linking callsite to invalid address");
	}
	_callDistance = _callTargetAddress - (_callSiteReturnAddress - 4);
	assert(isInImmediateJumpRange(self_in_rewriteTransferAttarget, _callDistance));
	/* begin instructionBeforeAddress: */
	_instr = ((uint32_t) (uint32AtPointer(_callSiteReturnAddress - 4)) );
	/* end instructionBeforeAddress: */
	assert((instructionIsB(self_in_rewriteTransferAttarget, _instr)) || (instructionIsBL(self_in_rewriteTransferAttarget, _instr)));
	uint32AtPointerput(_callSiteReturnAddress - 4, bwithLink(self_in_rewriteTransferAttarget, _callDistance, instructionIsBL(self_in_rewriteTransferAttarget, _instr)));
	assert((callTargetFromReturnAddress(self_in_rewriteTransferAttarget, _callSiteReturnAddress)) == _callTargetAddress);
	return 4;
}
/*	C6.2.226 ROR (immediate) 
	 
	Rotate right (immediate) provides the value of the contents of a register 
	rotated by a variable number of bits. The bits that are rotated off the 
	right end are inserted into the vacated bit positions on the left. 
	 
	ROR <Xd>, <Xs>, #<shift> */
/* CogARMv8Compiler>>#rorSize:sourceRegister:rotationBits:destinationRegister: */
static sqInt NoDbgRegParms
rorSizesourceRegisterrotationBitsdestinationRegister(AbstractInstruction * self_in_rorSizesourceRegisterrotationBitsdestinationRegister, sqInt _is64bits, sqInt _sourceRegister, sqInt _immediate6bitValue, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) (_is64bits & 1) ) << 0x1F) ) | ((39U << 23) | (((sqInt) (((usqInt) (_is64bits & 1) ) << 22) ) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 16) ) | (((sqInt) (((usqInt) (_immediate6bitValue & 0x3F) ) << 10) ) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F))))));
}
/*	C7.2.236 SCVTF (scalar, integer) 
	 
	Signed integer Convert to Floating-point (scalar). This instruction 
	converts the signed integer value in the general-purpose source register 
	to a floating-point value using the rounding mode that is specified by the 
	FPCR, and writes the result to the SIMD&FP destination register. 
	 
	64-bit to double-precision variant 
	 
	SCVTF <Dd>, <Xn> */
/* CogARMv8Compiler>>#scalarConvertSize:fromScalarRegister:toDoublePrecisionFloatRegister: */
static sqInt NoDbgRegParms
scalarConvertSizefromScalarRegistertoDoublePrecisionFloatRegister(AbstractInstruction * self_in_scalarConvertSizefromScalarRegistertoDoublePrecisionFloatRegister, sqInt _is64Bits, sqInt _scalarRegister, sqInt _doublePrecisionFloatingPointRegister)
{
	return ((sqInt) (((usqInt) (_is64Bits & 1) ) << 0x1F) ) | ((15U << 25) | ((1U << 22) | ((17U << 17) | (((sqInt) (((usqInt) (_scalarRegister & 0x1F) ) << 5) ) | (_doublePrecisionFloatingPointRegister & 0x1F)))));
}
/*	C6.2.235 SDIV 
	A64 Base Instruction Descriptions C6.2 Alphabetical list of A64 base 
	instructions Signed Divide divides a signed integer register value by 
	another signed integer register value, and writes the result to the 
	destination register. The condition flags are not affected. 
	 
	SDIV <Xd>, <Xn>, <Xm> */
/* CogARMv8Compiler>>#sdivSize:numeratorReg:denominatorReg:destinationRegister: */
static sqInt NoDbgRegParms
sdivSizenumeratorRegdenominatorRegdestinationRegister(AbstractInstruction * self_in_sdivSizenumeratorRegdenominatorRegdestinationRegister, sqInt _is64Bits, sqInt _numeratorReg, sqInt _denominatorReg, sqInt _destinationReg)
{
	return ((sqInt) (((usqInt) _is64Bits ) << 0x1F) ) | ((214U << 21) | (((sqInt) (((usqInt) (_denominatorReg & 0x1F) ) << 16) ) | ((3U << 10) | (((sqInt) (((usqInt) (_numeratorReg & 0x1F) ) << 5) ) | (_destinationReg & 0x1F)))));
}
/*	to save Slang from having to be a real compiler (it can't inline switches 
	that return)Answer if the receiver's opcode sets the condition codes correctly for the 
	given conditional jump opcode. 
	ARM has to check carefully since the V flag is not affected by 
	non-comparison instructions */
/* CogARMv8Compiler>>#setsConditionCodesFor: */
static sqInt NoDbgRegParms
setsConditionCodesFor(AbstractInstruction * self_in_setsConditionCodesFor, sqInt aConditionalJumpOpcode)
{
	switch ((self_in_setsConditionCodesFor->opcode)) {
		case ArithmeticShiftRightCqR:
		case ArithmeticShiftRightRR:
		case LogicalShiftLeftCqR:
		case LogicalShiftLeftRR:
		case LogicalShiftRightCqR:
		case XorRR:
		{
			return 0;
		}
		default:
		{
			logError("unhandled opcode in setsConditionCodesFor:");
			abort();
			return 0;
		}
	}
}
/*	First, determine the element size. */
/* CogARMv8Compiler>>#sizeOf:registerSize: */
static sqInt NoDbgRegParms
sizeOfregisterSize(AbstractInstruction * self_in_sizeOfregisterSize, sqInt _immediate, sqInt _registerSize)
{
	int _mask;
	sqInt _size;

	_size = _registerSize;
	do {
		_size = _size / 2;
		_mask = (1ULL << _size) - 1;
		if ((_immediate & _mask) != ((((usqInt) _immediate ) >> _size) & _mask)) {
			return _size * 2;
		}
	} while (_size > 2);
	return _size;
}
/*	C6.2.243 SMULH 
	 
	Signed Multiply High multiplies two 64-bit register values, and writes 
	bits[127:64] of the 128-bit result to the 64-bit destination register. 
	 
	SMULH <Xd>, <Xn>, <Xm> */
/* CogARMv8Compiler>>#smulhSize:firstRegister:secondRegister:destinationRegister: */
static sqInt NoDbgRegParms
smulhSizefirstRegistersecondRegisterdestinationRegister(AbstractInstruction * self_in_smulhSizefirstRegistersecondRegisterdestinationRegister, sqInt is64bits, sqInt _registerA, sqInt _registerB, sqInt _destinationRegister)
{
	return (621U << 22) | (((sqInt) (((usqInt) (_registerB & 0x1F) ) << 16) ) | ((0x1FU << 10) | (((sqInt) (((usqInt) (_registerA & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F))));
}
/*	 
	C7.2.321 ST1 (multiple structures) 
	 
	ST1 { <Vt>.<T> }, [<Xn|SP>] 
	 
	Store multiple single-element structures from one, two, three, or four 
	registers. This instruction stores elements to memory from one, two, 
	three, or four SIMD&FP registers, without interleaving. Every element of 
	each register is stored. */
/* CogARMv8Compiler>>#st1Q:OpCode:S:Rn:Rt: */
static sqInt NoDbgRegParms
st1QOpCodeSRnRt(AbstractInstruction * self_in_st1QOpCodeSRnRt, sqInt _q, sqInt _opCode, sqInt _size, sqInt _rn, sqInt _rt)
{
	return ((sqInt) (((usqInt) _q ) << 30) ) | ((24U << 23) | (((sqInt) (((usqInt) (_opCode & 15) ) << 12) ) | (((sqInt) (((usqInt) (_size & 3) ) << 10) ) | (((sqInt) (((usqInt) (_rn & 0x1F) ) << 5) ) | (_rt & 0x1F)))));
}
/*	 
	C7.2.321 ST1 (multiple structures) 
	 
	ST1 { <Vt>.<T> }, [<Xn|SP>], <Xm> 
	 
	Store multiple single-element structures from one, two, three, or four 
	registers. This instruction stores elements to memory from one, two, 
	three, or four SIMD&FP registers, without interleaving. Every element of 
	each register is stored. */
/* CogARMv8Compiler>>#st1Q:Rm:OpCode:S:Rn:Rt: */
static sqInt NoDbgRegParms
st1QRmOpCodeSRnRt(AbstractInstruction * self_in_st1QRmOpCodeSRnRt, sqInt _q, sqInt _rm, sqInt _opCode, sqInt _size, sqInt _rn, sqInt _rt)
{
	return ((sqInt) (((usqInt) _q ) << 30) ) | ((25U << 23) | (((sqInt) (((usqInt) (_rm & 0x1F) ) << 16) ) | (((sqInt) (((usqInt) (_opCode & 15) ) << 12) ) | (((sqInt) (((usqInt) (_size & 3) ) << 10) ) | (((sqInt) (((usqInt) (_rn & 0x1F) ) << 5) ) | (_rt & 0x1F))))));
}
/*	C6.2.38 BRK 
	 
	Breakpoint instruction. A BRK instruction generates a Breakpoint 
	Instruction exception. 
	 
	BRK #<imm>This is a BRK 0... */
/* CogARMv8Compiler>>#stop */
static sqInt NoDbgRegParms
stop(AbstractInstruction * self_in_stop)
{
	return 1697U << 21;
}
/* CogARMv8Compiler>>#stopsFrom:to: */
static AbstractInstruction * NoDbgRegParms
stopsFromto(AbstractInstruction * self_in_stopsFromto, sqInt _startAddr, sqInt _endAddr)
{
	sqInt _addr;

	assert((((_endAddr - _startAddr) + 1) % 4) == 0);
	for (_addr = _startAddr; _addr <= _endAddr; _addr += 4) {
		uint32AtPointerput(_addr, stop(self_in_stopsFromto));
	}
	return self_in_stopsFromto;
}
/*	C7.2.331 STR (immediate, SIMD&FP) 
	 
	Store SIMD&FP register (immediate offset). This instruction stores a 
	single SIMD&FP register to memory. The address that is used for the store 
	is calculated from a base register value and an immediate offset. 
	 
	Unsigned offset Variant 
	 
	STR <Dt>, [<Xn|SP>{, #<pimm>}] 
	 */
/* CogARMv8Compiler>>#strBaseRegister:positiveOffset:sourceFloatingPointRegister:precision: */
static sqInt NoDbgRegParms
strBaseRegisterpositiveOffsetsourceFloatingPointRegisterprecision(AbstractInstruction * self_in_strBaseRegisterpositiveOffsetsourceFloatingPointRegisterprecision, sqInt _baseReg, sqInt _immediate12bitValue, sqInt _sourceRegister, sqInt _size)
{
	return ((sqInt) (((usqInt) (_size & 3) ) << 30) ) | ((61U << 24) | (((sqInt) (((usqInt) ((_immediate12bitValue / 8) & 0xFFF) ) << 10) ) | (((sqInt) (((usqInt) (_baseReg & 0x1F) ) << 5) ) | (_sourceRegister & 0x1F))));
}
/*	C6.2.277 STRB (register) 
	 
	Store Register Byte (register) calculates an address from a base register 
	value and an offset register value, and stores a byte from a  
	32-bit register to the calculated address. For information about memory 
	accesses, see Load/Store addressing modes on page C1-189. 
	The instruction uses an offset addressing mode, that calculates the 
	address used for the memory access from a base register value and  
	an offset register value. The offset can be optionally shifted and 
	extended.  
	STRB <Wt>, [<Xn|SP>, <Xm>{, LSL <amount>}] */
/* CogARMv8Compiler>>#strbBaseRegister:offsetRegister:extension:shift:srcRegister: */
static sqInt NoDbgRegParms
strbBaseRegisteroffsetRegisterextensionshiftsrcRegister(AbstractInstruction * self_in_strbBaseRegisteroffsetRegisterextensionshiftsrcRegister, sqInt _baseRegister, sqInt _offsetRegister, sqInt _extensionType, sqInt _shiftFlag, sqInt _srcRegister)
{
	return (449U << 21) | (((sqInt) (((usqInt) (_offsetRegister & 0x1F) ) << 16) ) | (((sqInt) (((usqInt) (_extensionType & 7) ) << 13) ) | (((sqInt) (((usqInt) (_shiftFlag & 1) ) << 12) ) | ((2U << 10) | (((sqInt) (((usqInt) (_baseRegister & 0x1F) ) << 5) ) | (_srcRegister & 0x1F))))));
}
/*	C6.2.276 STRB (immediate) 
	 
	Store Register Byte (immediate) stores the least significant byte of a 
	32-bit register to memory. The address that is used for the store is 
	calculated from a base register and an immediate offset.  
	 
	Unsigned offset variant 
	STRB <Wt>, [<Xn|SP>{, #<pimm>}] */
/* CogARMv8Compiler>>#strbSourceRegister:destinationRegister: */
static sqInt NoDbgRegParms
strbSourceRegisterdestinationRegister(AbstractInstruction * self_in_strbSourceRegisterdestinationRegister, sqInt _sourceRegister, sqInt _destinationRegister)
{
	return strbSourceRegisterdestinationRegisteroffset(self_in_strbSourceRegisterdestinationRegister, _sourceRegister, _destinationRegister, 0);
}
/*	C6.2.276 STRB (immediate) 
	 
	Store Register Byte (immediate) stores the least significant byte of a 
	32-bit register to memory. The address that is used for the store is 
	calculated from a base register and an immediate offset.  
	 
	Unsigned offset variant 
	STRB <Wt>, [<Xn|SP>{, #<pimm>}] */
/* CogARMv8Compiler>>#strbSourceRegister:destinationRegister:offset: */
static sqInt NoDbgRegParms
strbSourceRegisterdestinationRegisteroffset(AbstractInstruction * self_in_strbSourceRegisterdestinationRegisteroffset, sqInt _sourceRegister, sqInt _destinationRegister, sqInt _immediate12BitValue)
{
	return (7U << 27) | ((1U << 24) | (((sqInt) (((usqInt) (_immediate12BitValue & 0xFFF) ) << 10) ) | (((sqInt) (((usqInt) (_destinationRegister & 0x1F) ) << 5) ) | (_sourceRegister & 0x1F))));
}
/*	C6.2.278 STRH (immediate) 
	 
	Store Register Halfword (immediate) stores the least significant halfword 
	of a 32-bit register to memory. The address that is used for the store is 
	calculated from a base register and an immediate offset. 
	 
	Unsigned offset variant 
	STRH <Wt>, [<Xn|SP>{, #<pimm>}] */
/* CogARMv8Compiler>>#strhSourceRegister:destinationRegister:offset: */
static sqInt NoDbgRegParms
strhSourceRegisterdestinationRegisteroffset(AbstractInstruction * self_in_strhSourceRegisterdestinationRegisteroffset, sqInt _sourceRegister, sqInt _destinationRegister, sqInt _immediate12BitValue)
{
	return (15U << 27) | ((1U << 24) | (((sqInt) (((usqInt) (_immediate12BitValue & 0xFFF) ) << 10) ) | (((sqInt) (((usqInt) (_destinationRegister & 0x1F) ) << 5) ) | (_sourceRegister & 0x1F))));
}
/*	C6.2.275 STR (register) 
	 
	Store Register (register) calculates an address from a base register value 
	and an offset register value, and stores a 32-bit word or a 64-bit 
	doubleword to the calculated address, from a register. For information 
	about memory accesses, see Load/Store addressing modes on page C1-189. 
	 
	The instruction uses an offset addressing mode, that calculates the 
	address used for the memory access from a base register value and an 
	offset register value. The offset can be optionally shifted and extended 
	 
	STR <Xt>, [<Xn|SP>, (<Wm>|<Xm>){, <extend> {<amount>}}] */
/* CogARMv8Compiler>>#strSize:baseRegister:offsetRegister:extension:shift:storedRegister: */
static sqInt NoDbgRegParms
strSizebaseRegisteroffsetRegisterextensionshiftstoredRegister(AbstractInstruction * self_in_strSizebaseRegisteroffsetRegisterextensionshiftstoredRegister, sqInt _is64Bits, sqInt _baseRegister, sqInt _offsetRegister, sqInt _extensionType, sqInt _shiftFlag, sqInt _storedRegister)
{
	return (1U << 0x1F) | (((sqInt) (((usqInt) (_is64Bits & 1) ) << 30) ) | ((449U << 21) | (((sqInt) (((usqInt) (_offsetRegister & 0x1F) ) << 16) ) | (((sqInt) (((usqInt) (_extensionType & 7) ) << 13) ) | (((sqInt) (((usqInt) (_shiftFlag & 1) ) << 12) ) | ((2U << 10) | (((sqInt) (((usqInt) (_baseRegister & 0x1F) ) << 5) ) | (_storedRegister & 0x1F))))))));
}
/*	Encodes a Load Register (immediate) instruction of the form 
	 
	STR <Xt>, [<Xn|SP>{, #<pimm>}] */
/* CogARMv8Compiler>>#strSize:baseRegister:positiveOffset:destinationRegister: */
static sqInt NoDbgRegParms
strSizebaseRegisterpositiveOffsetdestinationRegister(AbstractInstruction * self_in_strSizebaseRegisterpositiveOffsetdestinationRegister, sqInt _is64Bits, sqInt _baseReg, sqInt _immediate12bitValue, sqInt _destinationRegister)
{
	assert(_immediate12bitValue >= 0);
	return (1U << 0x1F) | (((sqInt) (((usqInt) (_is64Bits & 1) ) << 30) ) | ((228U << 22) | (((sqInt) (((usqInt) ((_immediate12bitValue / 8) & 0xFFF) ) << 10) ) | (((sqInt) (((usqInt) (_baseReg & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)))));
}
/*	Encodes a Load Register (immediate) instruction of the form 
	 
	STR <Xt>, [<Xn|SP>, #<simm>]! */
/* CogARMv8Compiler>>#strSize:baseRegister:signedOffset:sourceRegister:preIndex: */
static sqInt NoDbgRegParms
strSizebaseRegistersignedOffsetsourceRegisterpreIndex(AbstractInstruction * self_in_strSizebaseRegistersignedOffsetsourceRegisterpreIndex, sqInt _is64Bits, sqInt _baseRegister, sqInt _immediate9bitValue, sqInt _sourceRegister, sqInt _preIndex)
{
	sqInt _twoComplement;

	_twoComplement = ((_immediate9bitValue > 0)
		 ? _immediate9bitValue
		 : (0x1FF - (SQABS(_immediate9bitValue))) + 1);
	return (1U << 0x1F) | (((sqInt) (((usqInt) (_is64Bits & 1) ) << 30) ) | ((448U << 21) | (((sqInt) (((usqInt) (_twoComplement & 0x1FF) ) << 12) ) | (((sqInt) (((usqInt) _preIndex ) << 11) ) | ((1U << 10) | (((sqInt) (((usqInt) (_baseRegister & 0x1F) ) << 5) ) | (_sourceRegister & 0x1F)))))));
}
/*	C6.2.298 STUR 
	 
	Store Register (unscaled) calculates an address from a base register value 
	and an immediate offset, and stores a 32-bit word or a 64-bit doubleword 
	to the calculated address, from a register. For information about memory 
	accesses  
	STUR <Xt>, [<Xn|SP>{, #<simm>}] */
/* CogARMv8Compiler>>#sturSize:baseRegister:signedOffset:destinationRegister: */
static sqInt NoDbgRegParms
sturSizebaseRegistersignedOffsetdestinationRegister(AbstractInstruction * self_in_sturSizebaseRegistersignedOffsetdestinationRegister, sqInt _is64Bits, sqInt _baseReg, sqInt _immediate9bitValue, sqInt _destinationRegister)
{
	sqInt _twoComplement;

	_twoComplement = ((_immediate9bitValue > 0)
		 ? _immediate9bitValue
		 : (0x1FF - (SQABS(_immediate9bitValue))) + 1);
	assert(_twoComplement > 0);
	return (1U << 0x1F) | (((sqInt) (((usqInt) (_is64Bits & 1) ) << 30) ) | ((448U << 21) | (((sqInt) (((usqInt) (_twoComplement & 0x1FF) ) << 12) ) | (((sqInt) (((usqInt) (_baseReg & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F)))));
}
/*	C6.2.314 SUBS (extended register) 
	 
	Subtract (extended register), setting flags, subtracts a sign or 
	zero-extended register value, followed by an optional left shift amount, 
	from a register value, and writes the result to the destination register. 
	The argument that is extended from the <Rm> register can be a byte, 
	halfword, word, or doubleword. It updates the condition flags based on the 
	result  
	SUBS <Xd>, <Xn|SP>, <R><m>{, <extend> {#<amount>}} */
/* CogARMv8Compiler>>#subsExtendedSize:leftRegisterMaybeSP:shiftedRightRegister:option:shiftOffset:destinationRegister: */
static sqInt NoDbgRegParms
subsExtendedSizeleftRegisterMaybeSPshiftedRightRegisteroptionshiftOffsetdestinationRegister(AbstractInstruction * self_in_subsExtendedSizeleftRegisterMaybeSPshiftedRightRegisteroptionshiftOffsetdestinationRegister, sqInt _is64Bits, sqInt _leftRegister, sqInt _rightRegister, sqInt _option, sqInt _immediate3bitValue, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) _is64Bits ) << 0x1F) ) | ((857U << 21) | (((sqInt) (((usqInt) (_rightRegister & 0x1F) ) << 16) ) | (((sqInt) (((usqInt) (_option & 3) ) << 13) ) | (((sqInt) (((usqInt) (_immediate3bitValue & 7) ) << 10) ) | (((sqInt) (((usqInt) (_leftRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F))))));
}
/*	C6.2.316 SUBS (shifted register) 
	 
	Subtract (shifted register), setting flags, subtracts an 
	optionally-shifted register value from a register value, and writes the 
	result to the destination register. It updates the condition flags based 
	on the result. 
	 
	SUBS <Xd>, <Xn>, <Xm>{, <shift> #<amount>} 
	 
	LSL when shift = 00 
	LSR when shift = 01 
	ASR when shift = 10 */
/* CogARMv8Compiler>>#subsSize:leftRegister:shiftedRightRegister:shiftType:shiftOffset:destinationRegister: */
static sqInt NoDbgRegParms
subsSizeleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister(AbstractInstruction * self_in_subsSizeleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister, sqInt _is64Bits, sqInt _leftRegister, sqInt _rightRegister, sqInt _shiftType, sqInt _immediate6bitValue, sqInt _destinationRegister)
{
	return arithmeticShiftedRegisterSizeisSubstractionsetFlagsleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister(self_in_subsSizeleftRegistershiftedRightRegistershiftTypeshiftOffsetdestinationRegister, _is64Bits, 1, 1, _leftRegister, _rightRegister, _shiftType, _immediate6bitValue, _destinationRegister);
}
/*	C6.2.315 SUBS (immediate) 
	 
	Subtract (immediate), setting flags, subtracts an optionally-shifted 
	immediate value from a register value, and writes the result to the 
	destination register. It updates the condition flags based on the result. 
	 
	SUBS <Xd>, <Xn|SP>, #<imm>{, <shift>} */
/* CogARMv8Compiler>>#subsSize:sourceRegister:immediate12BitValue:shifted:destinationRegister: */
static sqInt NoDbgRegParms
subsSizesourceRegisterimmediate12BitValueshifteddestinationRegister(AbstractInstruction * self_in_subsSizesourceRegisterimmediate12BitValueshifteddestinationRegister, sqInt _is64Bits, sqInt _leftRegister, sqInt _immediate12BitValue, sqInt _shiftedFlag, sqInt _destinationRegister)
{
	return arithmeticImmediateSizeisSubstractionsetFlagssourceRegisterimmediate12BitValueshifteddestinationRegister(self_in_subsSizesourceRegisterimmediate12BitValueshifteddestinationRegister, _is64Bits, 1, 1, _leftRegister, _immediate12BitValue, _shiftedFlag, _destinationRegister);
}
/*	 
	C7.2.49 FSUB (vector) 
	 
	FSUB <Vd>.<T>, <Vn>.<T>, <Vm>.<T> 
	 
	This instruction subtracts the elements in the vector in the second source 
	SIMD&FP register, from the corresponding elements in the vector in the 
	first source SIMD&FP register, places each result into elements of a 
	vector, and writes the vector to the destination SIMD&FP register. */
/* CogARMv8Compiler>>#subT:q:term1:term2:dest: */
static sqInt NoDbgRegParms
subTqterm1term2dest(AbstractInstruction * self_in_subTqterm1term2dest, sqInt _t, sqInt _q, sqInt _vectorReg1, sqInt _vectorReg2, sqInt _vectorRegSum)
{
	return ((sqInt) (((usqInt) _q ) << 30) ) | ((14U << 24) | ((1U << 23) | (((sqInt) (((usqInt) (_t & 1) ) << 22) ) | ((1U << 21) | (((sqInt) (((usqInt) (_vectorReg2 & 0x1F) ) << 16) ) | ((53U << 10) | (((sqInt) (((usqInt) (_vectorReg1 & 0x1F) ) << 5) ) | (_vectorRegSum & 0x1F))))))));
}
/*	Return how many trailing ones are in the 64bit bitString representation of 
	aNumber. That is, how many ones are in the least significant bits before 
	there is a zero. 
	For example, the 64bit binary number 2r10101000110001111 has 4 trailing 
	ones Calculate it by calculating the trailing zeros of the bit-inverted number */
/* CogARMv8Compiler>>#trailingOnesOf: */
static sqInt NoDbgRegParms
trailingOnesOf(AbstractInstruction * self_in_trailingOnesOf, sqInt _aNumber)
{
	return trailingZerosOf(self_in_trailingOnesOf, ~((usqIntptr_t) _aNumber ));
}
/*	Return how many trailing zeros are in the 64bit bitString representation 
	of aNumber. 
	That is, how many zeros are in the least significant bits before there is 
	a one. 
	For example, the 64bit binary number 2r10101000110001111000 has 3 trailing 
	zeros.  
	Uses a bisect method looking at the number by halfsFirst two fast cases. If 1 or 0, return some quick constants */
/* CogARMv8Compiler>>#trailingZerosOf: */
static sqInt NoDbgRegParms
trailingZerosOf(AbstractInstruction * self_in_trailingZerosOf, sqInt _aNumber)
{
	sqInt _currentNumber;
	unsigned long long _mask;
	sqInt _shift;
	int _zeroBits;

	if (_aNumber == 0) {
		return 64;
	}
	if ((_aNumber & 1) == 1) {
		return 0;
	}
	_zeroBits = 0;
	_shift = ((usqInt) 64 ) >> 1;
	_mask = ((usqInt) 0xFFFFFFFFFFFFFFFFULL ) >> _shift;
	_currentNumber = _aNumber;
	while (_shift != 0) {
		if ((_currentNumber & _mask) == 0) {
			_currentNumber = ((usqInt) _currentNumber ) >> _shift;
			_zeroBits = _zeroBits | _shift;
		}
		_shift = ((usqInt) _shift ) >> 1;
		_mask = _mask >> _shift;
	}
	return _zeroBits;
}
/*	C6.2.330 TST (immediate) 
	 
	Test bits (immediate) , setting the condition flags and discarding the 
	result : Rn AND imm 
	 
	TST <Xn>, #<imm> 
	 */
/* CogARMv8Compiler>>#tstSize:immediate13bitValue:register: */
static sqInt NoDbgRegParms
tstSizeimmediate13bitValueregister(AbstractInstruction * self_in_tstSizeimmediate13bitValueregister, sqInt _is64bits, sqInt _immediate13bitValue, sqInt _registerToUse)
{
	return ((sqInt) (((usqInt) _is64bits ) << 0x1F) ) | ((228U << 23) | (((sqInt) (((usqInt) _immediate13bitValue ) << 10) ) | (((sqInt) (((usqInt) (_registerToUse & 0x1F) ) << 5) ) | 0x1F)));
}
/*	C6.2.333 UBFM 
	 
	Unsigned Bitfield Move is usually accessed via one of its aliases, which 
	are always preferred for disassembly. 
	If <imms> is greater than or equal to <immr>, this copies a bitfield of 
	(<imms>-<immr>+1) bits starting from bit position <immr> in the source 
	register to the least significant bits of the destination register. 
	 
	If <imms> is less than <immr>, this copies a bitfield of (<imms>+1) bits 
	from the least significant bits of the source register to bit position 
	(regsize-<immr>) of the destination register, where regsize is the 
	destination register size of 32 or 64 bits. 
	 
	In both cases the destination bits below and above the bitfield are set to 
	zero  
	UBFM <Xd>, <Xn>, #<immr>, #<imms> 
	 */
/* CogARMv8Compiler>>#unsignedBitfieldMoveSize:immr:imms:sourceRegister:destinationRegister: */
static sqInt NoDbgRegParms
unsignedBitfieldMoveSizeimmrimmssourceRegisterdestinationRegister(AbstractInstruction * self_in_unsignedBitfieldMoveSizeimmrimmssourceRegisterdestinationRegister, sqInt _is64Bits, sqInt _immr, sqInt _imms, sqInt _sourceRegister, sqInt _destinationRegister)
{
	return ((sqInt) (((usqInt) _is64Bits ) << 0x1F) ) | ((166U << 23) | (((sqInt) (((usqInt) (_is64Bits & 1) ) << 22) ) | (((sqInt) (((usqInt) (_immr & 0x3F) ) << 16) ) | (((sqInt) (((usqInt) (_imms & 0x3F) ) << 10) ) | (((sqInt) (((usqInt) (_sourceRegister & 0x1F) ) << 5) ) | (_destinationRegister & 0x1F))))));
}
/* CogBytecodeDescriptor>>#isBranch */
static sqInt NoDbgRegParms
isBranch(BytecodeDescriptor * self_in_isBranch)
{
	return ((self_in_isBranch->spanFunction)) != null;
}
/* Cogit>>#AddCq:R: */
static AbstractInstruction * NoDbgRegParms
gAddCqR(sqInt _quickConstant, sqInt _reg)
{
	AbstractInstruction *_anInstruction;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(AddCqR, _quickConstant, _reg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_quickConstant));
	}
	return _anInstruction;
	/* end checkQuickConstant:forInstruction: */
}
/* Cogit>>#AndCq:R: */
static AbstractInstruction * NoDbgRegParms
gAndCqR(sqInt _quickConstant, sqInt _reg)
{
	AbstractInstruction *_anInstruction;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(AndCqR, _quickConstant, _reg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_quickConstant));
	}
	return _anInstruction;
	/* end checkQuickConstant:forInstruction: */
}
/* Cogit>>#AndCq:R:R: */
static AbstractInstruction * NoDbgRegParms
gAndCqRR(sqInt _quickConstant, sqInt _srcReg, sqInt _destReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_first;

	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperandoperand(AndCqRR, _quickConstant, _srcReg, _destReg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(_quickConstant));
		}
		return _anInstruction3;
		/* end checkQuickConstant:forInstruction: */
	}
	if (_srcReg == _destReg) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(AndCqR, _quickConstant, _destReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_quickConstant));
		}
		return _anInstruction;
		/* end checkQuickConstant:forInstruction: */
	}
	_first = genoperandoperand(MoveRR, _srcReg, _destReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(AndCqR, _quickConstant, _destReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	return _first;
}
/* Cogit>>#abortOffset */
sqInt
abortOffset(void)
{
	return missOffset;
}
/*	Perform an integrity/leak check using the heapMap. 
	Set a bit at each cog method's header. */
/* Cogit>>#addCogMethodsToHeapMap */
void
addCogMethodsToHeapMap(void)
{
	CogMethod *_cogMethod;

	_cogMethod = ((CogMethod *) methodZoneBase );
	while (_cogMethod < (limitZony())) {
		if (((_cogMethod->cmType)) == CMMethod) {
			heapMapAtWordPut(_cogMethod, 1);
		}
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
	}
}
/* Cogit>>#addressIsInCurrentCompilation: */
static sqInt NoDbgRegParms
addressIsInCurrentCompilation(sqInt _address)
{
	return (((usqInt) _address ) >= ((methodLabel->address))) && (((usqInt) _address ) < (youngReferrers()));
}
/*	Hardcode renaming to _address */
/* Cogit>>#addressIsInFixups: */
static sqInt NoDbgRegParms
addressIsInFixups(BytecodeFixup *_address)
{
	return (BytecodeFixup *)_address >= fixups && (BytecodeFixup *)_address < (fixups + numAbstractOpcodes);
}
/*	Hardcode renaming to _address */
/* Cogit>>#addressIsInInstructions: */
static sqInt NoDbgRegParms
addressIsInInstructions(AbstractInstruction *_address)
{
	return !((usqInt)(_address) & BytesPerWord-1) \
				&& (_address) >= &abstractOpcodes[0] \
				&& (_address) < &abstractOpcodes[opcodeIndex];
}
/*	calculate the end of the n'th case statement - which is complicated 
	because we have case 1 right at the top of our CPIC and then build up from 
	the last one. Yes I know this sounds strange, but trust me - I'm an 
	Engineer, we do things backwards all the emit */
/* Cogit>>#addressOfEndOfCase:inCPIC: */
static sqInt NoDbgRegParms
addressOfEndOfCaseinCPIC(sqInt _n, CogMethod *_cPIC)
{
	assert((_n >= 1) && (_n <= MaxCPICCases));
	return ((_n == 1)
		 ? ((sqInt) _cPIC ) + firstCPICCaseOffset
		 : (((sqInt) _cPIC ) + firstCPICCaseOffset) + (((MaxCPICCases + 1) - _n) * cPICCaseSize));
}
/* Cogit>>#alignUptoRoutineBoundary: */
static sqInt NoDbgRegParms
alignUptoRoutineBoundary(sqInt _anAddress)
{
	return ((_anAddress + 7) | 7) - 7;
}
/*	Check that all methods have valid selectors, and that all linked sends are 
	to valid targets and have valid cache tags */
/* Cogit>>#allMachineCodeObjectReferencesValid */
static sqInt
allMachineCodeObjectReferencesValid(void)
{
	CogMethod *_cogMethod;
	int _ok;

	_ok = 1;
	_cogMethod = ((CogMethod *) methodZoneBase );
	while (_cogMethod < (limitZony())) {
		if (((_cogMethod->cmType)) != CMFree) {
			if (!(asserta(checkValidOopReference((_cogMethod->selector))))) {
				_ok = 0;
			}
			if (!(asserta((cogMethodDoesntLookKosher(_cogMethod)) == 0))) {
				_ok = 0;
			}
		}
		if ((((_cogMethod->cmType)) == CMMethod) || (((_cogMethod->cmType)) == CMMegamorphicIC)) {
			if (!(asserta((mapForperformUntilarg(_cogMethod, checkIfValidOopRefAndTargetpccogMethod, ((sqInt) _cogMethod ))) == 0))) {
				_ok = 0;
			}
		}
		if (((_cogMethod->cmType)) == CMPolymorphicIC) {
			if (!(asserta(noTargetsFreeInClosedPIC(_cogMethod)))) {
				_ok = 0;
			}
		}
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
	}
	return _ok;
}
/* Cogit>>#allMethodsHaveCorrectHeader */
static sqInt
allMethodsHaveCorrectHeader(void)
{
	CogMethod *_cogMethod;

	_cogMethod = ((CogMethod *) methodZoneBase );
	while (_cogMethod < (limitZony())) {
		if (((_cogMethod->cmType)) == CMMethod) {
			if (!(((_cogMethod->objectHeader)) == (nullHeaderForMachineCodeMethod()))) {
				return 0;
			}
		}
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
	}
	return 1;
}
/* Cogit>>#annotateAbsolutePCRef: */
static AbstractInstruction * NoDbgRegParms
annotateAbsolutePCRef(AbstractInstruction *_abstractInstruction)
{
	(_abstractInstruction->annotation = IsAbsPCReference);
	return _abstractInstruction;
}
/* Cogit>>#annotateBytecode: */
static AbstractInstruction * NoDbgRegParms
annotateBytecode(AbstractInstruction *_abstractInstruction)
{
	(_abstractInstruction->annotation = HasBytecodePC);
	return _abstractInstruction;
}
/* Cogit>>#annotate:objRef: */
static AbstractInstruction * NoDbgRegParms
annotateobjRef(AbstractInstruction *_abstractInstruction, sqInt _anOop)
{
	if (shouldAnnotateObjectReference(_anOop)) {
		if (isYoungObject(getMemoryMap(), _anOop)) {
			hasYoungReferent = 1;
		}
		(_abstractInstruction->annotation = IsObjectReference);
	}
	return _abstractInstruction;
}
/* Cogit>>#assertSaneJumpTarget: */
static void NoDbgRegParms
assertSaneJumpTarget(AbstractInstruction *_jumpTarget)
{
	assert((closedPICSize == null) || ((openPICSize == null) || ((addressIsInInstructions(_jumpTarget)) || ((((usqInt) _jumpTarget ) >= codeBase) && (((usqInt) _jumpTarget ) <= (((sqInt) (limitZony()) ) + (((closedPICSize < openPICSize) ? openPICSize : closedPICSize))))))));
}
/*	Answer the zero-relative bytecode pc matching the machine code pc argument 
	in cogMethod, given the start of the bytecodes for cogMethod's method 
	object.  */
/* Cogit>>#bytecodePCFor:startBcpc:in: */
sqInt
bytecodePCForstartBcpcin(sqInt _mcpc, sqInt _startbcpc, CogMethod *_cogMethod)
{
	sqInt _aMethodObj;
	sqInt _annotation;
	sqInt _bcpc;
	sqInt _byte;
	BytecodeDescriptor *_descriptor;
	sqInt _distance;
	sqInt _endbcpc;
	CogMethod *_homeMethod;
	sqInt _isBackwardBranch;
	usqInt _isInBlock;
	sqInt _latestContinuation;
	usqInt _map;
	sqInt _mapByte;
	usqInt _mcpc2;
	sqInt _nExts;
	sqInt _nextBcpc;
	sqInt _result;
	sqInt _targetPC;

	/* begin mapFor:bcpc:performUntil:arg: */
	assert(((_cogMethod->stackCheckOffset)) > 0);
	_mcpc2 = ((usqInt) _cogMethod ) + ((_cogMethod->stackCheckOffset));
	_result = findIsBackwardBranchMcpcBcpcMatchingMcpc(null, 0 + ((sqInt) (((usqInt) HasBytecodePC ) << 1) ), ((char *) _mcpc2 ), _startbcpc, ((void *) _mcpc ));
	if (_result != 0) {
		return _result;
	}
	_bcpc = _startbcpc;
	_isInBlock = (_cogMethod->cpicHasMNUCaseOrCMIsFullBlock);
	_homeMethod = ((CogMethod *) _cogMethod );
	assert(_startbcpc == (startPCOfMethodHeader((_homeMethod->methodHeader))));
	_map = (((usqInt) _homeMethod ) + ((_homeMethod->blockSize))) - 1;
	_annotation = ((usqInt) (byteAt(_map)) ) >> AnnotationShift;
	assert((_annotation == IsAbsPCReference) || ((_annotation == IsObjectReference) || ((_annotation == IsRelativeCall) || (_annotation == IsDisplacementX2N))));
	_latestContinuation = _startbcpc;
	_aMethodObj = (_homeMethod->methodObject);
	_endbcpc = (numBytesOf(_aMethodObj)) - 1;
	_bcpc += deltaToSkipPrimAndErrorStoreInheader(_aMethodObj, (_homeMethod->methodHeader));
	_nExts = 0;
	{
		enumeratingCogMethod = _homeMethod;
	}
	while ((((usqInt) (byteAt(_map)) ) >> AnnotationShift) != HasBytecodePC) {
		_map -= 1;
	}
	_map -= 1;
	while (((_mapByte = byteAt(_map))) != MapEnd) {
		if (_mapByte >= FirstAnnotation) {
			_annotation = ((usqInt) _mapByte ) >> AnnotationShift;
			_mcpc2 += (_mapByte & DisplacementMask) * 4;
			if (_annotation >= HasBytecodePC) {
				if ((_annotation == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
					_annotation += _mapByte & DisplacementMask;
					_map -= 1;
				}
				while (1) {
					_byte = fetchByteofObject(_bcpc, _aMethodObj);
					_descriptor = generatorAt(_byte);
					if (_isInBlock) {
						if (_bcpc >= _endbcpc) {
							return 0;
						}
					} else {
						if (((_descriptor->isReturn)) && (_bcpc >= _latestContinuation)) {
							return 0;
						}
						if (isBranch(_descriptor)) {
							/* begin latestContinuationPCFor:at:exts:in: */
							_distance = ((_descriptor->spanFunction))(_descriptor, _bcpc, _nExts, _aMethodObj);
							_targetPC = (_bcpc + ((_descriptor->numBytes))) + (((_distance < 0) ? 0 : _distance));
							/* end latestContinuationPCFor:at:exts:in: */
							_latestContinuation = ((_latestContinuation < _targetPC) ? _targetPC : _latestContinuation);
						}
					}
					_nextBcpc = _bcpc + ((_descriptor->numBytes));
					if (((_descriptor->isMapped)) || (_isInBlock && ((_descriptor->isMappedInBlock)))) 
						break;
					_bcpc = _nextBcpc;
					_nExts = (((_descriptor->isExtension))
						 ? _nExts + 1
						 : 0);
				}
				_isBackwardBranch = (isBranch(_descriptor)) && ((assert(((_descriptor->spanFunction)) != null), (((_descriptor->spanFunction))(_descriptor, _bcpc, _nExts, _aMethodObj)) < 0));
				_result = findIsBackwardBranchMcpcBcpcMatchingMcpc(_descriptor, ((_isBackwardBranch)
					 ? ((sqInt) (((usqInt) _annotation ) << 1) ) + 1
					 : ((sqInt) (((usqInt) _annotation ) << 1) )), ((char *) _mcpc2 ), ((_isBackwardBranch)
					 ? _bcpc - (2 * _nExts)
					 : _bcpc), ((void *) _mcpc ));
				if (_result != 0) {
					return _result;
				}
				_bcpc = _nextBcpc;
				_nExts = (((_descriptor->isExtension))
					 ? _nExts + 1
					 : 0);
			}
		} else {
			assert(((((usqInt) _mapByte ) >> AnnotationShift) == IsDisplacementX2N) || ((((usqInt) _mapByte ) >> AnnotationShift) == IsAnnotationExtension));
			if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
				_mcpc2 += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
			}
		}
		_map -= 1;
	}
	return 0;
	/* end mapFor:bcpc:performUntil:arg: */
}
/* Cogit>>#CallRT:registersToBeSavedMask: */
static AbstractInstruction * NoDbgRegParms
CallRTregistersToBeSavedMask(sqInt _callTarget, sqInt _registersToBeSaved)
{
	AbstractInstruction *_abstractInstruction;
	sqInt _callerSavedRegsToBeSaved;
	AbstractInstruction *_lastInst;
	int _reg;
	sqInt _registersToBePushed;

	_reg = 0;
	_callerSavedRegsToBeSaved = CallerSavedRegisterMask & _registersToBeSaved;
	{
		_registersToBePushed = _callerSavedRegsToBeSaved;
		_reg = 0;
		while (_registersToBePushed != 0) {
			if (_registersToBePushed & 1) {
				genoperand(PushR, _reg);
			}
			_reg += 1;
			_registersToBePushed = ((sqInt) _registersToBePushed ) >> 1;
		}
	}
	/* begin CallRT: */
	/* begin annotateCall: */
	_abstractInstruction = genoperand(Call, _callTarget);
	(_abstractInstruction->annotation = IsRelativeCall);
	_lastInst = _abstractInstruction;
	/* end annotateCall: */
	/* end CallRT: */
	{
		while (_reg > 0) {
			_reg -= 1;
			if (_callerSavedRegsToBeSaved & (1ULL << _reg)) {
				_lastInst = genoperand(PopR, _reg);
			}
		}
		return _lastInst;
	}
}
/* Cogit>>#Call: */
static AbstractInstruction * NoDbgRegParms
gCall(sqInt _callTarget)
{
	return genoperand(Call, _callTarget);
}
/* Cogit>>#CmpCq:R: */
static AbstractInstruction * NoDbgRegParms
gCmpCqR(sqInt _quickConstant, sqInt _reg)
{
	AbstractInstruction *_anInstruction;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(CmpCqR, _quickConstant, _reg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_quickConstant));
	}
	return _anInstruction;
	/* end checkQuickConstant:forInstruction: */
}
/* Cogit>>#CmpCw:R: */
static AbstractInstruction * NoDbgRegParms
gCmpCwR(sqInt _wordConstant, sqInt _reg)
{
	return checkLiteralforInstruction(_wordConstant, genoperandoperand(CmpCwR, _wordConstant, _reg));
}
/*	in-line cache tags are selectors on unlinked sends, super sends and 
	megamorphically linked sends */
/* Cogit>>#cacheTagIsSelectorForAnnotation:andEntryPoint: */
static sqInt NoDbgRegParms
cacheTagIsSelectorForAnnotationandEntryPoint(sqInt _annotation, sqInt _entryPoint)
{
	return (_entryPoint < methodZoneBase) || (((_annotation == IsSuperSend) || ((_annotation >= IsDirectedSuperSend) && (_annotation <= IsDirectedSuperBindingSend))) || ((((((CogMethod *) (_entryPoint - cmEntryOffset) ))->cmType)) == CMMegamorphicIC));
}
/*	This is a static version of ceCallCogCodePopReceiverReg 
	for break-pointing when debugging in C.This exists only for break-pointing. */
/* Cogit>>#callCogCodePopReceiver */
void
callCogCodePopReceiver(void)
{
	realCECallCogCodePopReceiverReg();
	{
		error("what??");
	}
}
/*	This is a static version of ceCallCogCodePopReceiverAndClassRegs 
	for break-pointing when debugging in C.This exists only for break-pointing. */
/* Cogit>>#callCogCodePopReceiverAndClassRegs */
void
callCogCodePopReceiverAndClassRegs(void)
{
	realCECallCogCodePopReceiverAndClassRegs();
}
/*	Code entry closed PIC miss. A send has fallen 
	through a closed (finite) polymorphic inline cache. 
	Either extend it or patch the send site to an open PIC. 
	The stack looks like: 
	receiver 
	args 
	sp=>	sender return address */
/* Cogit>>#ceCPICMiss:receiver: */
sqInt
ceCPICMissreceiver(CogMethod *_cPIC, sqInt _receiver)
{
	sqInt _callerReturnAddress;
	sqInt _errorSelectorOrNil;
	sqInt _methodOrSelectorIndex;
	sqInt _newTargetMethodOrNil;
	sqInt _selector;

	/* begin simulationOnly: */
	/* end simulationOnly: */
	if (isOopForwarded(_receiver)) {
		return ceSendFromInLineCacheMiss(_cPIC);
	}
	_callerReturnAddress = stackTop();
	assert(!((inlineCacheTagAt(backEnd, _callerReturnAddress)) == (isMNUPicAbortDiscriminatorValue())));
	if (MaxCPICCases <= ((_cPIC->cPICNumCases))) {
		patchToMegamorphicICFornumArgsreceiver((_cPIC->selector), (_cPIC->cmNumArgs), _receiver);
		return ceSendFromInLineCacheMiss(_cPIC);
	}
	/* begin lookup:for:methodAndErrorSelectorInto: */
	_selector = (_cPIC->selector);
	_methodOrSelectorIndex = lookupMethodWithoutMNUProcessingForSelectorreceiver(_selector, _receiver);
	if (_methodOrSelectorIndex == SelectorCannotInterpret) {
		{
			_newTargetMethodOrNil = null;
			_errorSelectorOrNil = SelectorCannotInterpret;
		}
		goto l2;
	}
	if (_methodOrSelectorIndex == SelectorDoesNotUnderstand) {
		_methodOrSelectorIndex = lookupMethodWithoutMNUProcessingForSelectorreceiver(splObj(SelectorDoesNotUnderstand), _receiver);
		if (((usqInt) _methodOrSelectorIndex ) <= (maxLookupNoMNUErrorCode())) {
			{
				_newTargetMethodOrNil = null;
				_errorSelectorOrNil = SelectorDoesNotUnderstand;
			}
			goto l2;
		}
		assert(isOopCompiledMethod(_methodOrSelectorIndex));
		cogMethodIfPossibleselector(_methodOrSelectorIndex, splObj(SelectorDoesNotUnderstand));
		{
			_newTargetMethodOrNil = _methodOrSelectorIndex;
			_errorSelectorOrNil = SelectorDoesNotUnderstand;
		}
		goto l2;
	}
	assert(couldBeObject(((usqInt) _methodOrSelectorIndex )));
	if (!(isOopCompiledMethod(_methodOrSelectorIndex))) {
		{
			_newTargetMethodOrNil = _methodOrSelectorIndex;
			_errorSelectorOrNil = SelectorCannotInterpret;
		}
		goto l2;
	}
	cogMethodIfPossibleselector(_methodOrSelectorIndex, _selector);
	{
		_newTargetMethodOrNil = _methodOrSelectorIndex;
		_errorSelectorOrNil = null;
	}
	l2:
	;
	/* end lookup:for:methodAndErrorSelectorInto: */
	if ((_errorSelectorOrNil == SelectorCannotInterpret) || ((_newTargetMethodOrNil == null) || (isYoung(_newTargetMethodOrNil)))) {
		patchToMegamorphicICFornumArgsreceiver((_cPIC->selector), (_cPIC->cmNumArgs), _receiver);
		return ceSendFromInLineCacheMiss(_cPIC);
	}
	cogExtendPICCaseNMethodtagisMNUCase(_cPIC, _newTargetMethodOrNil, inlineCacheTagForInstance(_receiver), _errorSelectorOrNil == SelectorDoesNotUnderstand);
	executeCogPICfromLinkedSendWithReceiverandCacheTag(_cPIC, _receiver, inlineCacheTagAt(backEnd, _callerReturnAddress));
	{
		assert(0);
	}
	return 0;
}
/* Cogit>>#ceFree: */
void
ceFree(void *_pointer)
{
	free(_pointer);
}
/* Cogit>>#ceMalloc: */
void*
ceMalloc(size_t _size)
{
	return malloc(_size);
}
/*	An in-line cache check in a method has failed. The failing entry check has 
	jumped to the ceMethodAbort abort call at the start of the method which 
	has called this routine. 
	If possible allocate a closed PIC for the current and existing classes. 
	The stack looks like: 
	receiver 
	args 
	sender return address 
	sp=>	ceMethodAbort call return address 
	So we can find the method that did the failing entry check at 
	ceMethodAbort call return address - missOffset 
	and we can find the send site from the outer return address. */
/* Cogit>>#ceSICMiss: */
sqInt
ceSICMiss(sqInt _receiver)
{
	sqInt _cacheTag;
	usqInt _callerReturnAddress;
	sqInt _errorSelectorOrNil;
	sqInt _extent;
	CogMethod *_inlineCache;
	sqInt _linkingSucceeded;
	sqInt _methodOrSelectorIndex;
	CogMethod * _missedTargetCogMethod;
	usqInt _missedTargetReturnAddress;
	sqInt _newTargetMethodOrNil;
	sqInt _selector;

	_extent = 0;
	_linkingSucceeded = 0;
	_missedTargetReturnAddress = ((usqInt) (popStack()) );
	_missedTargetCogMethod = ((CogMethod *) (_missedTargetReturnAddress - missOffset) );
	if (isOopForwarded(_receiver)) {
		return ceSendFromInLineCacheMiss(_missedTargetCogMethod);
	}
	_callerReturnAddress = ((usqInt) (stackTop()) );
	assert((_callerReturnAddress >= methodZoneBase) && (_callerReturnAddress <= (freeStart())));
	assert(((_missedTargetCogMethod->selector)) != (nilObject()));
	assert((((sqInt) _missedTargetCogMethod ) + cmEntryOffset) == (callTargetFromReturnAddress(backEnd, _callerReturnAddress)));
	if ((inlineCacheTagAt(backEnd, _callerReturnAddress)) == 0) {
		patchToMegamorphicICFornumArgsreceiver((_missedTargetCogMethod->selector), (_missedTargetCogMethod->cmNumArgs), _receiver);
		return ceSendFromInLineCacheMiss(_missedTargetCogMethod);
	}
	/* begin lookup:for:methodAndErrorSelectorInto: */
	_selector = (_missedTargetCogMethod->selector);
	_methodOrSelectorIndex = lookupMethodWithoutMNUProcessingForSelectorreceiver(_selector, _receiver);
	if (_methodOrSelectorIndex == SelectorCannotInterpret) {
		{
			_newTargetMethodOrNil = null;
			_errorSelectorOrNil = SelectorCannotInterpret;
		}
		goto l2;
	}
	if (_methodOrSelectorIndex == SelectorDoesNotUnderstand) {
		_methodOrSelectorIndex = lookupMethodWithoutMNUProcessingForSelectorreceiver(splObj(SelectorDoesNotUnderstand), _receiver);
		if (((usqInt) _methodOrSelectorIndex ) <= (maxLookupNoMNUErrorCode())) {
			{
				_newTargetMethodOrNil = null;
				_errorSelectorOrNil = SelectorDoesNotUnderstand;
			}
			goto l2;
		}
		assert(isOopCompiledMethod(_methodOrSelectorIndex));
		cogMethodIfPossibleselector(_methodOrSelectorIndex, splObj(SelectorDoesNotUnderstand));
		{
			_newTargetMethodOrNil = _methodOrSelectorIndex;
			_errorSelectorOrNil = SelectorDoesNotUnderstand;
		}
		goto l2;
	}
	assert(couldBeObject(((usqInt) _methodOrSelectorIndex )));
	if (!(isOopCompiledMethod(_methodOrSelectorIndex))) {
		{
			_newTargetMethodOrNil = _methodOrSelectorIndex;
			_errorSelectorOrNil = SelectorCannotInterpret;
		}
		goto l2;
	}
	cogMethodIfPossibleselector(_methodOrSelectorIndex, _selector);
	{
		_newTargetMethodOrNil = _methodOrSelectorIndex;
		_errorSelectorOrNil = null;
	}
	l2:
	;
	/* end lookup:for:methodAndErrorSelectorInto: */
	_cacheTag = inlineCacheTagForInstance(_receiver);
	if ((_errorSelectorOrNil == SelectorCannotInterpret) || ((_newTargetMethodOrNil == null) || (isYoung(_newTargetMethodOrNil)))) {
		patchToMegamorphicICFornumArgsreceiver((_missedTargetCogMethod->selector), (_missedTargetCogMethod->cmNumArgs), _receiver);
		return ceSendFromInLineCacheMiss(_missedTargetCogMethod);
	}
	{
		_inlineCache = openPICWithSelector((_missedTargetCogMethod->selector));
		_linkingSucceeded = _inlineCache != null;
		if (_inlineCache) {
			/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
			/* begin enableCodeZoneWrite */
			if (jitCodeZoneWriteEnabled) {
				error("Code zone writing is not reentrant");
			}
			
#      if READ_ONLY_CODE_ZONE
			{
				
#        if __APPLE__
				{
					pthread_jit_write_protect_np(0);
				}
#        else /* __APPLE__ */
				{
					sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
				}
#        endif /* __APPLE__ */
			}
#      endif /* READ_ONLY_CODE_ZONE */
			jitCodeZoneWriteEnabled = 1;
			/* end enableCodeZoneWrite */
			{
				_extent = rewriteInlineCacheAttagtarget(backEnd, _callerReturnAddress, inlineCacheValueForSelectorinat((_missedTargetCogMethod->selector), mframeHomeMethodExport(), _callerReturnAddress), ((sqInt) _inlineCache ) + cmEntryOffset);
			}
			/* begin disableCodeZoneWrite */
			
#      if READ_ONLY_CODE_ZONE
			{
				
#        if __APPLE__
				{
					pthread_jit_write_protect_np(1);
				}
#        else /* __APPLE__ */
				{
					sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
				}
#        endif /* __APPLE__ */
			}
#      endif /* READ_ONLY_CODE_ZONE */
			jitCodeZoneWriteEnabled = 0;
			/* end disableCodeZoneWrite */
			{
				flushICacheFromto(((usqInt) _callerReturnAddress ) - _extent, ((usqInt) _callerReturnAddress ));
			}
			/* end enableCodeZoneWriteDuring:flushingCacheWith: */
		}
	}
	if (!_inlineCache) {
		/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
		/* begin enableCodeZoneWrite */
		if (jitCodeZoneWriteEnabled) {
			error("Code zone writing is not reentrant");
		}
		
#    if READ_ONLY_CODE_ZONE
		{
			
#      if __APPLE__
			{
				pthread_jit_write_protect_np(0);
			}
#      else /* __APPLE__ */
			{
				sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
			}
#      endif /* __APPLE__ */
		}
#    endif /* READ_ONLY_CODE_ZONE */
		jitCodeZoneWriteEnabled = 1;
		/* end enableCodeZoneWrite */
		{
			_inlineCache = cogPICSelectornumArgsCase0MethodCase1MethodtagisMNUCase((_missedTargetCogMethod->selector), (_missedTargetCogMethod->cmNumArgs), _missedTargetCogMethod, _newTargetMethodOrNil, _cacheTag, _errorSelectorOrNil == SelectorDoesNotUnderstand);
			_linkingSucceeded = !((((sqInt) _inlineCache ) >= MaxNegativeErrorCode) && (((sqInt) _inlineCache ) <= -1));
			if (_linkingSucceeded) {
				_extent = rewriteCallAttarget(backEnd, _callerReturnAddress, ((sqInt) _inlineCache ) + cmEntryOffset);
			}
		}
		/* begin disableCodeZoneWrite */
		
#    if READ_ONLY_CODE_ZONE
		{
			
#      if __APPLE__
			{
				pthread_jit_write_protect_np(1);
			}
#      else /* __APPLE__ */
			{
				sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
			}
#      endif /* __APPLE__ */
		}
#    endif /* READ_ONLY_CODE_ZONE */
		jitCodeZoneWriteEnabled = 0;
		/* end disableCodeZoneWrite */
		{
			if (_linkingSucceeded) {
				flushICacheFromto(((usqInt) _inlineCache ), ((usqInt) _inlineCache ) + closedPICSize);
				flushICacheFromto(((usqInt) _callerReturnAddress ) - _extent, ((usqInt) _callerReturnAddress ));
			}
		}
		/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	}
	if (_linkingSucceeded) {
		executeCogPICfromLinkedSendWithReceiverandCacheTag(_inlineCache, _receiver, inlineCacheTagAt(backEnd, _callerReturnAddress));
	}
	if (((sqInt) _inlineCache ) == InsufficientCodeSpace) {
		callForCogCompiledCodeCompaction();
	}
	return ceSendFromInLineCacheMiss(_missedTargetCogMethod);
}
/* Cogit>>#checkAssertsEnabledInCogit */
void
checkAssertsEnabledInCogit(void)
{
	int _assertsAreEnabledInCogit;

	_assertsAreEnabledInCogit = 0;
	assert(_assertsAreEnabledInCogit);
}
/*	Check if the CFramePointer is in use. 
	Different C compilers can choose to not use the frame pointers to delimit 
	stack frames, and use instead the frame pointer as a general purpose 
	register. This function implements a rough heuristic to determine if the 
	FP is used as a frame delimiter or not. 
	 
	This function is meant to work as follows: 
	- the caller should call ceCaptureCStackPointers capturing the FP and SP 
	of the caller. 
	- then the caller calls this function that will in turn also call 
	ceCaptureCStackPointers to capture the FP and SP. 
	 
	If the FP moved between the two calls, and the FP captured the second time 
	is between the previous one and the new SP, this means the compiler 
	probably generated code to update the FP. 
	 */
/* Cogit>>#checkCFramePointerInUse */
static sqInt
checkCFramePointerInUse(void)
{
	void * _currentCSP;
	sqInt _result;

	/* begin simulationOnly: */
	/* end simulationOnly: */
	_currentCSP = getCStackPointer();
	ceCaptureCStackPointers();
	assert((getCStackPointer()) < _currentCSP);
	_result = ((getCFramePointer()) >= (getCStackPointer())) && ((getCFramePointer()) <= _currentCSP);
	/* begin simulationOnly: */
	/* end simulationOnly: */
	return _result;
}
/*	Check for a valid object reference, if any, at a map entry. Answer a code 
	unique to each error for debugging. */
/* Cogit>>#checkIfValidOopRefAndTarget:pc:cogMethod: */
static sqInt NoDbgRegParms
checkIfValidOopRefAndTargetpccogMethod(sqInt _annotation, char *_mcpc, sqInt _cogMethod)
{
	usqInt _cacheTag2;
	sqInt _entryPoint;
	sqInt _entryPoint2;
	sqInt _literal;
	sqInt _offset2;
	sqInt _tagCouldBeObj;
	CogMethod * _targetCogCode;

	if (_annotation == IsObjectReference) {
		_literal = unsignedLongAt(((usqInt) _mcpc ));
		if (!(asserta(checkValidOopReference(_literal)))) {
			return 1;
		}
		if ((couldBeObject(_literal)) && (isReallyYoungObject(_literal))) {
			if (!(asserta(((((CogMethod *) _cogMethod ))->cmRefersToYoung)))) {
				return 2;
			}
		}
	}
	if (_annotation >= IsSendCall) {
		if (!(asserta((((((CogMethod *) _cogMethod ))->cmType)) == CMMethod))) {
			return 3;
		}
		/* begin entryCacheTagAndCouldBeObjectAt:annotation:into: */
		_cacheTag2 = inlineCacheTagAt(backEnd, ((sqInt) _mcpc ));
		_entryPoint2 = callTargetFromReturnAddress(backEnd, ((sqInt) _mcpc ));
		_tagCouldBeObj = 0;
		{
			_entryPoint = _entryPoint2;
			if (_tagCouldBeObj) {
				if (couldBeObject(_cacheTag2)) {
					if (!(asserta(checkValidOopReference(_cacheTag2)))) {
						return 4;
					}
				}
 else {
					if (!(asserta(validInlineCacheTag(_cacheTag2)))) {
						return 5;
					}
				}
				if ((couldBeObject(_cacheTag2)) && (isReallyYoungObject(_cacheTag2))) {
					if (!(asserta(((((CogMethod *) _cogMethod ))->cmRefersToYoung)))) {
						return 6;
					}
				}
			} else {
				if (cacheTagIsSelectorForAnnotationandEntryPoint(_annotation, _entryPoint)) {
					if (((int) _cacheTag2 ) < 0) {
						if ((-((int) _cacheTag2 )) > NumSpecialSelectors) {
							return 7;
						}
					}
 else {
						if (_cacheTag2 >= (literalCountOf((enumeratingCogMethod->methodObject)))) {
							return 8;
						}
					}
				}
 else {
					if (!(asserta(validInlineCacheTag(_cacheTag2)))) {
						return 9;
					}
				}
			}
		}
		/* end entryCacheTagAndCouldBeObjectAt:annotation:into: */
		if (_entryPoint > methodZoneBase) {
			/* begin targetMethodAndSendTableFor:annotation:into: */
			/* begin offsetAndSendTableFor:annotation:into: */
			if (_annotation == IsSendCall) {
				_offset2 = cmEntryOffset;
			} else {
				if (_annotation == IsDirectedSuperSend) {
					_offset2 = cmNoCheckEntryOffset;
				} else {
					if (_annotation == IsDirectedSuperBindingSend) {
						_offset2 = cmNoCheckEntryOffset;
					} else {
						assert(_annotation == IsSuperSend);
						_offset2 = cmNoCheckEntryOffset;
					}
				}
			}
			{
				_targetCogCode = ((CogMethod *) (_entryPoint - _offset2) );
				{
					if (!(asserta((((_targetCogCode->cmType)) == CMMethod) || ((((_targetCogCode->cmType)) == CMPolymorphicIC) || (((_targetCogCode->cmType)) == CMMegamorphicIC))))) {
						return 10;
					}
				}
			}
			/* end offsetAndSendTableFor:annotation:into: */
			/* end targetMethodAndSendTableFor:annotation:into: */
		}
	}
	return 0;
}
/*	Check for a valid object reference, if any, at a map entry. Answer a code 
	unique to each error for debugging. */
/* Cogit>>#checkIfValidOopRef:pc:cogMethod: */
static sqInt NoDbgRegParms
checkIfValidOopRefpccogMethod(sqInt _annotation, char *_mcpc, sqInt _cogMethod)
{
	sqInt _entryPoint;
	sqInt _literal;
	sqInt _offset;
	sqInt _offset2;
	usqInt _selectorOrCacheTag;

	if (_annotation == IsObjectReference) {
		_literal = unsignedLongAt(((usqInt) _mcpc ));
		if (!(checkValidOopReference(_literal))) {
			{
				print("object ref leak in CM ");
				printHex(((sqInt) _cogMethod ));
				print(" @ ");
				printHex(((sqInt) _mcpc ));
				cr();
			}
			return 1;
		}
	}
	if (_annotation >= IsSendCall) {
		_entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt) _mcpc ));
		if (_entryPoint <= methodZoneBase) {
			_offset = _entryPoint;
		} else {
			/* begin offsetAndSendTableFor:annotation:into: */
			if (_annotation == IsSendCall) {
				_offset2 = cmEntryOffset;
			} else {
				if (_annotation == IsDirectedSuperSend) {
					_offset2 = cmNoCheckEntryOffset;
				} else {
					if (_annotation == IsDirectedSuperBindingSend) {
						_offset2 = cmNoCheckEntryOffset;
					} else {
						assert(_annotation == IsSuperSend);
						_offset2 = cmNoCheckEntryOffset;
					}
				}
			}
			{
				_offset = _offset2;
			}
			/* end offsetAndSendTableFor:annotation:into: */
		}
		_selectorOrCacheTag = inlineCacheTagAt(backEnd, ((sqInt) _mcpc ));
		if ((_entryPoint > methodZoneBase) && ((_offset != cmNoCheckEntryOffset) && ((((((CogMethod *) (_entryPoint - _offset) ))->cmType)) != CMMegamorphicIC))) {
			if (!(validInlineCacheTag(_selectorOrCacheTag))) {
				{
					print("cache tag leak in CM ");
					printHex(((sqInt) _cogMethod ));
					print(" @ ");
					printHex(((sqInt) _mcpc ));
					cr();
				}
				return 1;
			}
		} else {
		}
	}
	return 0;
}
/*	Answer if all references to objects in machine-code are valid. */
/* Cogit>>#checkIntegrityOfObjectReferencesInCode: */
sqInt
checkIntegrityOfObjectReferencesInCode(sqInt gcModes)
{
	CogMethod *_cogMethod;
	sqInt _count;
	int _ok;

	_cogMethod = ((CogMethod *) methodZoneBase );
	_ok = 1;
	while (_cogMethod < (limitZony())) {
		if (((_cogMethod->cmType)) != CMFree) {
			if ((_cogMethod->cmRefersToYoung)) {
				if (((_count = occurrencesInYoungReferrers(_cogMethod))) != 1) {
					{
						print("young referrer CM ");
						printHex(((sqInt) _cogMethod ));
					}
					if (_count == 0) {
						{
							print(" is not in youngReferrers");
							cr();
						}
					} else {
						{
							print(" is in youngReferrers ");
							printNum(_count);
							print(" times!");
							cr();
						}
					}
					_ok = 0;
				}
			}
			if (!(checkValidOopReference((_cogMethod->selector)))) {
				{
					print("object leak in CM ");
					printHex(((sqInt) _cogMethod ));
					print(" selector");
					cr();
				}
				_ok = 0;
			}
			if (((_cogMethod->cmType)) == CMMethod) {
				assert(((_cogMethod->objectHeader)) == (nullHeaderForMachineCodeMethod()));
				if (!(checkValidObjectReference((_cogMethod->methodObject)))) {
					{
						print("object leak in CM ");
						printHex(((sqInt) _cogMethod ));
						print(" methodObject");
						cr();
					}
					_ok = 0;
				}
				if (!(isOopCompiledMethod((_cogMethod->methodObject)))) {
					{
						print("non-method in CM ");
						printHex(((sqInt) _cogMethod ));
						print(" methodObject");
						cr();
					}
					_ok = 0;
				}
				if ((mapForperformUntilarg(_cogMethod, checkIfValidOopRefpccogMethod, ((sqInt) _cogMethod ))) != 0) {
					_ok = 0;
				}
				if (((isYoungObject(getMemoryMap(), (_cogMethod->methodObject))) || (isYoung((_cogMethod->selector)))) && (!((_cogMethod->cmRefersToYoung)))) {
					{
						print("CM ");
						printHex(((sqInt) _cogMethod ));
						print(" refers to young but not marked as such");
						cr();
					}
					_ok = 0;
				}
			} else {
				if (((_cogMethod->cmType)) == CMPolymorphicIC) {
					if (!(checkValidObjectReferencesInClosedPIC(_cogMethod))) {
						_ok = 0;
					}
				}
 else {
					if (((_cogMethod->cmType)) == CMMegamorphicIC) {
						if ((mapForperformUntilarg(_cogMethod, checkIfValidOopRefpccogMethod, ((sqInt) _cogMethod ))) != 0) {
							_ok = 0;
						}
					}
				}
			}
		}
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
	}
	return _ok;
}
/* Cogit>>#checkMaybeObjRefInClosedPIC: */
static sqInt NoDbgRegParms
checkMaybeObjRefInClosedPIC(sqInt _maybeObject)
{
	if (_maybeObject == 0) {
		return 1;
	}
	if (!(couldBeObject(_maybeObject))) {
		return 1;
	}
	return checkValidObjectReference(_maybeObject);
}
/* Cogit>>#checkValidObjectReferencesInClosedPIC: */
static sqInt NoDbgRegParms
checkValidObjectReferencesInClosedPIC(CogMethod *_cPIC)
{
	sqInt _i;
	int _ok;
	sqInt _pc;

	_ok = 1;
	_pc = ((sqInt) _cPIC ) + firstCPICCaseOffset;
	if (!(checkMaybeObjRefInClosedPIC(literalBeforeFollowingAddress(backEnd, _pc - (jumpLongByteSize(backEnd)))))) {
		{
			print("object leak in CPIC ");
			printHex(((sqInt) _cPIC ));
			print(" @ ");
			printHex(_pc - (jumpLongByteSize(backEnd)));
			cr();
		}
		_ok = 0;
	}
	_pc = addressOfEndOfCaseinCPIC((_cPIC->cPICNumCases), _cPIC);
	for (_i = 2; _i <= ((_cPIC->cPICNumCases)); _i += 1) {
		if (!(checkMaybeObjRefInClosedPIC(literalBeforeFollowingAddress(backEnd, (_pc - (jumpLongConditionalByteSize(backEnd))) - (cmpC32RTempByteSize(backEnd)))))) {
			{
				print("object leak in CPIC ");
				printHex(((sqInt) _cPIC ));
				print(" @ ");
				printHex(_pc - (jumpLongConditionalByteSize(backEnd)));
				cr();
			}
			_ok = 0;
		}
		_pc += cPICCaseSize;
	}
	return _ok;
}
/*	i.e. this should never be called, so keep it out of the main path. */
/* Cogit>>#cleanUpFailingCogCodeConstituents: */
static sqInt NoDbgRegParms NeverInline
cleanUpFailingCogCodeConstituents(CogMethod *_cogMethodArg)
{
	CogMethod *_cogMethod;

	_cogMethod = _cogMethodArg;
	while (_cogMethod < (limitZony())) {
		if (((_cogMethod->cmType)) == CMPolymorphicIC) {
			(_cogMethod->methodObject = 0);
		}
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
	}
	popRemappableOop();
	return null;
}
/*	Answer if the ClosedPIC refers to any unmarked objects or freed/freeable 
	target methods, 
	applying markAndTraceOrFreeCogMethod:firstVisit: to those targets to 
	determine if freed/freeable. */
/* Cogit>>#closedPICRefersToUnmarkedObject: */
static sqInt NoDbgRegParms
closedPICRefersToUnmarkedObject(CogMethod *_cPIC)
{
	sqInt _i;
	sqInt _object;
	sqInt _pc;

	if (!((isImmediate((_cPIC->selector))) || (isMarkedOrPermanent((_cPIC->selector))))) {
		return 1;
	}
	_pc = addressOfEndOfCaseinCPIC(1, _cPIC);
	if (couldBeObject((_object = literalBeforeFollowingAddress(backEnd, _pc - (jumpLongByteSize(backEnd)))))) {
		if (!(isMarkedOrPermanent(_object))) {
			return 1;
		}
	}
	if (markAndTraceOrFreePICTargetin(jumpLongTargetBeforeFollowingAddress(backEnd, _pc), _cPIC)) {
		return 1;
	}
	for (_i = 2; _i <= ((_cPIC->cPICNumCases)); _i += 1) {
		_pc = addressOfEndOfCaseinCPIC(_i, _cPIC);
		if (couldBeObject((_object = literalBeforeFollowingAddress(backEnd, (_pc - (jumpLongConditionalByteSize(backEnd))) - (cmpC32RTempByteSize(backEnd)))))) {
			if (!(isMarkedOrPermanent(_object))) {
				return 1;
			}
		}
		if (markAndTraceOrFreePICTargetin(jumpLongTargetBeforeFollowingAddress(backEnd, _pc), _cPIC)) {
			return 1;
		}
	}
	return 0;
}
/* Cogit>>#codeEntryFor: */
char *
codeEntryFor(char *_address)
{
	sqInt _i;

	for (_i = 0; _i <= (trampolineTableIndex - 3); _i += 2) {
		if ((_address >= (trampolineAddresses[_i + 1])) && (_address <= ((trampolineAddresses[_i + 3]) - 1))) {
			return trampolineAddresses[_i + 1];
		}
	}
	return null;
}
/* Cogit>>#codeEntryNameFor: */
char *
codeEntryNameFor(char *_address)
{
	sqInt _i;

	for (_i = 0; _i <= (trampolineTableIndex - 3); _i += 2) {
		if ((_address >= (trampolineAddresses[_i + 1])) && (_address <= ((trampolineAddresses[_i + 3]) - 1))) {
			return trampolineAddresses[_i];
		}
	}
	return null;
}
/* Cogit>>#cogCodeBase */
sqInt
cogCodeBase(void)
{
	return codeBase;
}
/*	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 withDetails is true 
	- answer machine-code to bytecode pc mapping information for methods 
	- answer class, target pair information for closed PIC 
	N.B. Since the class tag for the first case of a closed PIC is stored at 
	the send site, it must be collected 
	by scanning methods (see 
	collectCogConstituentFor:Annotation:Mcpc:Bcpc:Method:). Since closed PICs 
	are never shared they always come after the method that references them, 
	so we don't need an extra pass 
	to collect the first case class tags, which are (temporarily) assigned to 
	each closed PIC's methodObject field. 
	But we do need to reset the methodObject fields to zero. This is done in 
	createPICData:, unless memory 
	runs out, in which case it is done by cleanUpFailingCogCodeConstituents:. */
/* Cogit>>#cogCodeConstituents: */
sqInt
cogCodeConstituents(sqInt _withDetails)
{
	CogMethod *_cogMethod;
	sqInt _constituents;
	sqInt _count;
	sqInt _i;
	sqInt _label;
	sqInt _profileData;
	sqInt _value;

	_count = (trampolineTableIndex / 2) + 3;
	_cogMethod = ((CogMethod *) methodZoneBase );
	while (_cogMethod < (limitZony())) {
		if (((_cogMethod->cmType)) != CMFree) {
			_count += 1;
		}
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
	}
	_constituents = instantiateClassindexableSize(classArray(), _count * 2);
	if (!_constituents) {
		return _constituents;
	}
	pushRemappableOop(_constituents);
	if (((_label = stringForCString("CogCode")) == null) || ((_value = positive64BitIntegerFor(codeBase)) == null)) {
		popRemappableOop();
		return null;
	}
	{
		storePointerUncheckedofObjectwithValue(0, _constituents, _label);
		storePointerUncheckedofObjectwithValue(1, _constituents, _value);
	}
	for (_i = 0; _i < trampolineTableIndex; _i += 2) {
		if (((_label = stringForCString(trampolineAddresses[_i])) == null) || ((_value = positive64BitIntegerFor(((usqInt) (trampolineAddresses[_i + 1]) ))) == null)) {
			popRemappableOop();
			return null;
		}
		{
			storePointerUncheckedofObjectwithValue(2 + _i, _constituents, _label);
			storePointerUncheckedofObjectwithValue(3 + _i, _constituents, _value);
		}
	}
	_count = trampolineTableIndex + 2;
	_cogMethod = ((CogMethod *) methodZoneBase );
	while (_cogMethod < (limitZony())) {
		if (((_cogMethod->cmType)) != CMFree) {
			if (((_cogMethod->cmType)) == CMMethod) {
				_profileData = (_cogMethod->methodObject);
			} else {
				_profileData = ((_withDetails && (((_cogMethod->cmType)) == CMPolymorphicIC))
					 ? createCPICData(_cogMethod)
					 : (_cogMethod->selector));
			}
			if (!_profileData) {
				return cleanUpFailingCogCodeConstituents(_cogMethod);
			}
			storePointerUncheckedofObjectwithValue(_count, _constituents, _profileData);
			if (_withDetails) {
				_value = collectCogMethodConstituent(_cogMethod);
			}
 else {
				_value = positive64BitIntegerFor(((usqInt) _cogMethod ));
			}
			if (!_value) {
				return cleanUpFailingCogCodeConstituents(_cogMethod);
			}
			storePointerUncheckedofObjectwithValue(_count + 1, _constituents, _value);
			_count += 2;
		}
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
	}
	if (((_label = stringForCString("CCFree")) == null) || ((_value = positive64BitIntegerFor(mzFreeStart)) == null)) {
		popRemappableOop();
		return null;
	}
	{
		storePointerUncheckedofObjectwithValue(_count, _constituents, _label);
		storePointerUncheckedofObjectwithValue(_count + 1, _constituents, _value);
	}
	if (((_label = stringForCString("CCEnd")) == null) || ((_value = positive64BitIntegerFor(limitAddress)) == null)) {
		popRemappableOop();
		return null;
	}
	{
		storePointerUncheckedofObjectwithValue(_count + 2, _constituents, _label);
		storePointerUncheckedofObjectwithValue(_count + 3, _constituents, _value);
	}
	_constituents = popRemappableOop();
	beRootIfOld(_constituents);
	return _constituents;
}
/*	Extend the cPIC with the supplied case. If caseNMethod is cogged dispatch 
	direct to 
	its unchecked entry-point. If caseNMethod is not cogged, jump to the fast 
	interpreter dispatch, and if isMNUCase then dispatch to fast MNU 
	invocation and mark the cPIC as 
	having the MNU case for cache flushing. */
/* Cogit>>#cogExtendPIC:CaseNMethod:tag:isMNUCase: */
static sqInt NoDbgRegParms
cogExtendPICCaseNMethodtagisMNUCase(CogMethod *_cPIC, sqInt _caseNMethod, sqInt _caseNTag, sqInt _isMNUCase)
{
	sqInt _address;
	sqInt _operand;
	sqInt _target;

	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		assert((_caseNMethod != null) && (!(isYoung(_caseNMethod))));
		if (!_isMNUCase && (methodHasCogMethod(_caseNMethod))) {
			_operand = 0;
			_target = ((sqInt) (cogMethodOf(_caseNMethod)) ) + cmNoCheckEntryOffset;
		} else {
			_operand = _caseNMethod;
			if (_isMNUCase) {
				(_cPIC->cpicHasMNUCaseOrCMIsFullBlock) = 1;
				_target = picAbortAddress(_cPIC);
			} else {
				_target = ((sqInt) _cPIC ) + (picInterpretAbortOffset());
			}
		}
		_address = addressOfEndOfCaseinCPIC(((_cPIC->cPICNumCases)) + 1, _cPIC);
		rewritePICCaseAttagobjReftarget(_address, _caseNTag, _operand, _target);
		/* begin rewriteCPIC:caseJumpTo: */
		rewriteCPICJumpAttarget(backEnd, ((((sqInt) _cPIC ) + firstCPICCaseOffset) - (jumpLongByteSize(backEnd))) - (loadLiteralByteSize(backEnd)), _address - cPICCaseSize);
		/* end rewriteCPIC:caseJumpTo: */
		(_cPIC->cPICNumCases = ((_cPIC->cPICNumCases)) + 1);
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		flushICacheFromto(((usqInt) _cPIC ), ((usqInt) _cPIC ) + closedPICSize);
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	return 0;
}
/*	Attempt to produce a machine code method for the bytecode method 
	object aMethodObj. N.B. If there is no code memory available do *NOT* 
	attempt to reclaim the method zone. Certain clients (e.g. ceSICMiss:) 
	depend on the zone remaining constant across method generation. */
/* Cogit>>#cogFullBlockMethod:numCopied: */
CogMethod *
cogFullBlockMethodnumCopied(sqInt _aMethodObj, sqInt _numCopied)
{
	CogMethod *_cogMethod;
	usqLong _startTime;
	sqInt _ultimateLiteral;

	_startTime = ioUTCMicrosecondsNow();
	ensureNoForwardedLiteralsIn(_aMethodObj);
	_ultimateLiteral = ultimateLiteralOf(_aMethodObj);
	assert(!(isForwarded(_ultimateLiteral)));
	assert(!(methodHasCogMethod(_aMethodObj)));
	assert(isOopCompiledMethod(_ultimateLiteral));
	methodObj = _aMethodObj;
	methodHeader = methodHeaderOf(_aMethodObj);
	receiverTags = receiverTagBitsForMethod(methodObj);
	_cogMethod = compileCogFullBlockMethod(_numCopied);
	if ((((sqInt) _cogMethod ) >= MaxNegativeErrorCode) && (((sqInt) _cogMethod ) <= -1)) {
		if (((sqInt) _cogMethod ) == InsufficientCodeSpace) {
			callForCogCompiledCodeCompaction();
		}
		return null;
	}
	statCompileFullBlockCount += 1;
	statCompileFullBlockUsecs += (ioUTCMicrosecondsNow()) - _startTime;
	return _cogMethod;
}
/* Cogit>>#cogitPostGCAction: */
void
cogitPostGCAction(sqInt _gcMode)
{
	if (_gcMode == GCModeBecome) {
		followForwardedLiteralsInOpenPICList();
	}
	assert(allMethodsHaveCorrectHeader());
	assert(((_gcMode & (GCModeFull + GCModeNewSpace)) == 0) || (kosherYoungReferrers()));
}
/*	Check that the header fields onf a non-free method are consistent with 
	the type. Answer 0 if it is ok, otherwise answer a code for the error. */
/* Cogit>>#cogMethodDoesntLookKosher: */
sqInt
cogMethodDoesntLookKosher(CogMethod *_cogMethod)
{
	if (((((_cogMethod->blockSize)) & (BytesPerWord - 1)) != 0) || ((((_cogMethod->blockSize)) < (sizeof(CogMethod))) || (((_cogMethod->blockSize)) >= 32768))) {
		return 1;
	}
	if (((_cogMethod->cmType)) == CMFree) {
		return 2;
	}
	if (((_cogMethod->cmType)) == CMMethod) {
		if (!(((((_cogMethod->methodHeader)) & 7) == 1))) {
			return 11;
		}
		if (!(couldBeObject((_cogMethod->methodObject)))) {
			return 12;
		}
		if ((((_cogMethod->stackCheckOffset)) > 0) && (((_cogMethod->stackCheckOffset)) < cmNoCheckEntryOffset)) {
			return 13;
		}
		return 0;
	}
	if (((_cogMethod->cmType)) == CMMegamorphicIC) {
		if (((_cogMethod->blockSize)) != openPICSize) {
			return 21;
		}
		if (((_cogMethod->methodHeader)) != 0) {
			return 22;
		}
		if (((_cogMethod->objectHeader)) >= 0) {
			if (!((((_cogMethod->methodObject)) == 0) || (compactionInProgress || (((_cogMethod->methodObject)) == ((usqInt) (methodFor((_cogMethod->methodObject))) ))))) {
				return 23;
			}
		}
		if (((_cogMethod->stackCheckOffset)) != 0) {
			return 24;
		}
		return 0;
	}
	if (((_cogMethod->cmType)) == CMPolymorphicIC) {
		if (((_cogMethod->blockSize)) != closedPICSize) {
			return 0x1F;
		}
		if (!((((_cogMethod->cPICNumCases)) >= 1) && (((_cogMethod->cPICNumCases)) <= MaxCPICCases))) {
			return 32;
		}
		if (((_cogMethod->methodHeader)) != 0) {
			return 33;
		}
		if (((_cogMethod->methodObject)) != 0) {
			return 34;
		}
		return 0;
	}
	return 9;
}
/* Cogit>>#cogMethodIfPossible:selector: */
void
cogMethodIfPossibleselector(sqInt _methodOrSelectorIndex, sqInt _selector)
{
	if ((!(methodHasCogMethod(_methodOrSelectorIndex))) && (methodShouldBeCogged(_methodOrSelectorIndex))) {
		cogselector(_methodOrSelectorIndex, _selector);
	}
}
/*	Attempt to create a one-case PIC for an MNU. 
	The tag for the case is at the send site and so doesn't need to be 
	generated.  */
/* Cogit>>#cogMNUPICSelector:receiver:methodOperand:numArgs: */
CogMethod *
cogMNUPICSelectorreceivermethodOperandnumArgs(sqInt _selector, sqInt _rcvr, sqInt _methodOperand, sqInt _numArgs)
{
	CogMethod * _pic;
	usqInt _startAddress;

	if ((isYoung(_selector)) || ((inlineCacheTagForInstance(_rcvr)) == 0)) {
		return 0;
	}
	assert(endCPICCase0 != null);
	_startAddress = allocate(closedPICSize);
	if (_startAddress == 0) {
		callForCogCompiledCodeCompaction();
		return 0;
	}
	_pic = ((CogMethod *) _startAddress );
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		initializePICatDeltanumArgs(_pic, _startAddress - cPICPrototype, _numArgs);
		configureMNUCPICmethodOperand(_pic, _methodOperand);
		/* begin fillInCPICHeader:numArgs:numCases:hasMNUCase:selector: */
		assert(!(isYoung(_selector)));
		(_pic->cmType = CMPolymorphicIC);
		(_pic->objectHeader = 0);
		(_pic->blockSize = closedPICSize);
		(_pic->methodObject = 0);
		(_pic->methodHeader = 0);
		(_pic->selector = _selector);
		(_pic->cmNumArgs = _numArgs);
		(_pic->cmRefersToYoung = 0);
		(_pic->cmUsageCount = initialClosedPICUsageCount());
		(_pic->cpicHasMNUCaseOrCMIsFullBlock) = 1;
		(_pic->cPICNumCases = 1);
		(_pic->picUsage = 0);
		assert(((_pic->cmType)) == CMPolymorphicIC);
		assert(((_pic->selector)) == _selector);
		assert(((_pic->cmNumArgs)) == _numArgs);
		assert(((_pic->cPICNumCases)) == 1);
		assert((callTargetFromReturnAddress(backEnd, ((sqInt) _pic ) + missOffset)) == (picAbortTrampolineFor(_numArgs)));
		assert(closedPICSize == (roundUpLength(closedPICSize)));
		/* end fillInCPICHeader:numArgs:numCases:hasMNUCase:selector: */
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		flushICacheFromto(((usqInt) _pic ), ((usqInt) _pic ) + closedPICSize);
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	return _pic;
}
/*	Create an Open PIC. Temporarily create a direct call of 
	ceSendFromOpenPIC:. Should become a probe of the first-level method lookup 
	cache followed by a 
	call of ceSendFromOpenPIC: if the probe fails. */
/* Cogit>>#cogOpenPICSelector:numArgs: */
static CogMethod * NoDbgRegParms
cogOpenPICSelectornumArgs(sqInt _selector, sqInt _numArgs)
{
	sqInt _codeSize;
	sqInt _end;
	sqInt _mapSize;
	CogMethod * _pic;
	CogMethod *_pic2;
	usqInt _startAddress;

	_startAddress = allocate(openPICSize);
	if (_startAddress == 0) {
		return ((CogMethod *) InsufficientCodeSpace );
	}
	{
		(methodLabel->address = _startAddress);
		(methodLabel->dependent = null);
	}
	/* begin allocateOpcodes:bytecodes: */
	ensureAndClearAbstractOpcodes(100);
	zeroOpcodeIndexForNewOpcodes();
	labelCounter = 0;
	/* end allocateOpcodes:bytecodes: */
	compileOpenPICnumArgs(_selector, _numArgs);
	computeMaximumSizes();
	concretizeAt(methodLabel, _startAddress);
	_codeSize = generateInstructionsAt(_startAddress + (sizeof(CogMethod)));
	_mapSize = generateMapAtstart((_startAddress + openPICSize) - 1, _startAddress + cmNoCheckEntryOffset);
	assert((((entry->address)) - _startAddress) == cmEntryOffset);
	assert(((roundUpLength((sizeof(CogMethod)) + _codeSize)) + (roundUpLength(_mapSize))) <= openPICSize);
	_end = outputInstructionsAt(_startAddress + (sizeof(CogMethod)));
	/* begin fillInOPICHeader:numArgs:selector: */
	_pic2 = ((CogMethod *) _startAddress );
	(_pic2->cmType = CMMegamorphicIC);
	(_pic2->objectHeader = 0);
	(_pic2->blockSize = openPICSize);
	addToMegamorphicICList(_pic2);
	(_pic2->methodHeader = 0);
	(_pic2->selector = _selector);
	(_pic2->cmNumArgs = _numArgs);
	if ((_pic2->cmRefersToYoung = isYoung(_selector))) {
		addToYoungReferrers(_pic2);
	}
	(_pic2->cmUsageCount = initialOpenPICUsageCount());
	(_pic2->cpicHasMNUCaseOrCMIsFullBlock) = 0;
	(_pic2->cPICNumCases = 0);
	(_pic2->picUsage = 0);
	assert(((_pic2->cmType)) == CMMegamorphicIC);
	assert(((_pic2->selector)) == _selector);
	assert(((_pic2->cmNumArgs)) == _numArgs);
	assert((callTargetFromReturnAddress(backEnd, ((sqInt) _pic2 ) + missOffset)) == (picAbortTrampolineFor(_numArgs)));
	assert(openPICSize == (roundUpLength(openPICSize)));
	_pic = _pic2;
	/* end fillInOPICHeader:numArgs:selector: */
	return _pic;
}
/*	Attempt to create a two-case PIC for case0CogMethod and 
	case1Method,case1Tag. The tag for case0CogMethod is at the send site and 
	so doesn't need to be generated. 
	case1Method may be any of 
	- a Cog method; link to its unchecked entry-point 
	- a CompiledMethod; link to ceInterpretMethodFromPIC: 
	- a CompiledMethod; link to ceMNUFromPICMNUMethod:receiver: */
/* Cogit>>#cogPICSelector:numArgs:Case0Method:Case1Method:tag:isMNUCase: */
static CogMethod * NoDbgRegParms
cogPICSelectornumArgsCase0MethodCase1MethodtagisMNUCase(sqInt _selector, sqInt _numArgs, CogMethod *_case0CogMethod, sqInt _case1MethodOrNil, sqInt _case1Tag, sqInt _isMNUCase)
{
	CogMethod *_pic;
	usqInt _startAddress;

	if (isYoung(_selector)) {
		return ((CogMethod *) YoungSelectorInPIC );
	}
	_startAddress = allocate(closedPICSize);
	_pic = ((CogMethod *) _startAddress );
	if (_startAddress == 0) {
		return ((CogMethod *) InsufficientCodeSpace );
	}
	initializePICatDeltanumArgs(_pic, _startAddress - cPICPrototype, _numArgs);
	configureCPICCase0Case1MethodtagisMNUCase(_pic, _case0CogMethod, _case1MethodOrNil, _case1Tag, _isMNUCase);
	/* begin fillInCPICHeader:numArgs:numCases:hasMNUCase:selector: */
	assert(!(isYoung(_selector)));
	(_pic->cmType = CMPolymorphicIC);
	(_pic->objectHeader = 0);
	(_pic->blockSize = closedPICSize);
	(_pic->methodObject = 0);
	(_pic->methodHeader = 0);
	(_pic->selector = _selector);
	(_pic->cmNumArgs = _numArgs);
	(_pic->cmRefersToYoung = 0);
	(_pic->cmUsageCount = initialClosedPICUsageCount());
	(_pic->cpicHasMNUCaseOrCMIsFullBlock) = _isMNUCase;
	(_pic->cPICNumCases = 2);
	(_pic->picUsage = 0);
	assert(((_pic->cmType)) == CMPolymorphicIC);
	assert(((_pic->selector)) == _selector);
	assert(((_pic->cmNumArgs)) == _numArgs);
	assert(((_pic->cPICNumCases)) == 2);
	assert((callTargetFromReturnAddress(backEnd, ((sqInt) _pic ) + missOffset)) == (picAbortTrampolineFor(_numArgs)));
	assert(closedPICSize == (roundUpLength(closedPICSize)));
	/* end fillInCPICHeader:numArgs:numCases:hasMNUCase:selector: */
	return _pic;
}
/*	Attempt to produce a machine code method for the bytecode method 
	object aMethodObj. N.B. If there is no code memory available do *NOT* 
	attempt to reclaim the method zone. Certain clients (e.g. ceSICMiss:) 
	depend on the zone remaining constant across method generation. */
/* Cogit>>#cog:selector: */
CogMethod *
cogselector(sqInt _aMethodObj, sqInt _aSelectorOop)
{
	CogMethod *_cogMethod;
	sqInt _selector;
	usqLong _startTime;

	_startTime = ioUTCMicrosecondsNow();
	assert(!(methodHasCogMethod(_aMethodObj)));
	assert(!(isOopCompiledMethod(ultimateLiteralOf(_aMethodObj))));
	_selector = ((_aSelectorOop == (nilObject()))
		 ? maybeSelectorOfMethod(_aMethodObj)
		 : _aSelectorOop);
	ensureNoForwardedLiteralsIn(_aMethodObj);
	methodObj = _aMethodObj;
	methodHeader = methodHeaderOf(_aMethodObj);
	receiverTags = receiverTagBitsForMethod(methodObj);
	_cogMethod = compileCogMethod(_aSelectorOop);
	if ((((sqInt) _cogMethod ) >= MaxNegativeErrorCode) && (((sqInt) _cogMethod ) <= -1)) {
		if (((sqInt) _cogMethod ) == InsufficientCodeSpace) {
			callForCogCompiledCodeCompaction();
		}
		return null;
	}
	statCompileMethodCount += 1;
	statCompileMethodUsecs += (ioUTCMicrosecondsNow()) - _startTime;
	return _cogMethod;
}
/* Cogit>>#collectCogConstituentFor:Annotation:Mcpc:Bcpc:Method: */
static sqInt NoDbgRegParms
collectCogConstituentForAnnotationMcpcBcpcMethod(BytecodeDescriptor *_descriptor, sqInt _isBackwardBranchAndAnnotation, char *_mcpc, sqInt _bcpc, void *cogMethodArg)
{
	sqInt _address;
	sqInt _annotation;
	sqInt _entryPoint;
	sqInt _offset2;
	CogMethod * _targetCogCode;

	if (!_descriptor) {
		return 0;
	}
	if (!((_descriptor->isMapped))) {
		return 0;
	}
	_address = positive64BitIntegerFor(_mcpc);
	if (!_address) {
		return PrimErrNoMemory;
	}
	storePointerUncheckedofObjectwithValue(cogConstituentIndex, topRemappableOop(), _address);
	storePointerUncheckedofObjectwithValue(cogConstituentIndex + 1, topRemappableOop(), ((((usqInt) _bcpc ) << 3) | 1));
	cogConstituentIndex += 2;
	if (((_isBackwardBranchAndAnnotation & 1) == 0) && ((((usqInt) _isBackwardBranchAndAnnotation ) >> 1) >= IsSendCall)) {
		_entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt) _mcpc ));
		if (_entryPoint > methodZoneBase) {
			/* begin targetMethodAndSendTableFor:annotation:into: */
			_annotation = ((usqInt) _isBackwardBranchAndAnnotation ) >> 1;
			/* begin offsetAndSendTableFor:annotation:into: */
			if (_annotation == IsSendCall) {
				_offset2 = cmEntryOffset;
			} else {
				if (_annotation == IsDirectedSuperSend) {
					_offset2 = cmNoCheckEntryOffset;
				} else {
					if (_annotation == IsDirectedSuperBindingSend) {
						_offset2 = cmNoCheckEntryOffset;
					} else {
						assert(_annotation == IsSuperSend);
						_offset2 = cmNoCheckEntryOffset;
					}
				}
			}
			{
				_targetCogCode = ((CogMethod *) (_entryPoint - _offset2) );
				{
					if (((_targetCogCode->cmType)) == CMPolymorphicIC) {
						(_targetCogCode->methodObject = classForInlineCacheTag(inlineCacheTagAt(backEnd, _mcpc)));
					}
				}
			}
			/* end offsetAndSendTableFor:annotation:into: */
			/* end targetMethodAndSendTableFor:annotation:into: */
		}
	}
	return 0;
}
/*	Answer a description of the mapping between machine code pointers and 
	bytecode pointers for the Cog Method. 
	First value is the address of the cog method. 
	Following values are pairs of machine code pc and bytecode pc */
/* Cogit>>#collectCogMethodConstituent: */
static sqInt NoDbgRegParms
collectCogMethodConstituent(CogMethod *_cogMethod)
{
	sqInt _address;
	sqInt _aMethodObj;
	sqInt _annotation;
	sqInt _bcpc;
	sqInt _byte;
	sqInt _cm;
	sqInt _data;
	BytecodeDescriptor *_descriptor;
	sqInt _distance;
	sqInt _endbcpc;
	sqInt _errCode;
	CogMethod *_homeMethod;
	sqInt _isBackwardBranch;
	usqInt _isInBlock;
	sqInt _latestContinuation;
	usqInt _map;
	sqInt _mapByte;
	usqInt _mcpc;
	sqInt _nExts;
	sqInt _nextBcpc;
	sqInt _nSlots;
	sqInt _result;
	sqInt _startbcpc;
	sqInt _targetPC;

	if (!(((_cogMethod->cmType)) == CMMethod)) {
		return positive64BitIntegerFor(((usqInt) _cogMethod ));
	}
	if (((_cogMethod->stackCheckOffset)) == 0) {
		return positive64BitIntegerFor(((usqInt) _cogMethod ));
	}
	_cm = (_cogMethod->methodObject);
	_nSlots = ((((byteSizeOf(_cm)) - (startPCOfMethod(_cm))) * 2) + (minSlotsForShortening())) + 1;
	_data = instantiateClassindexableSize(splObj(ClassArray), _nSlots);
	if (!_data) {
		return null;
	}
	pushRemappableOop(_data);
	_address = positive64BitIntegerFor(((usqInt) _cogMethod ));
	if (!_address) {
		popRemappableOop();
		return null;
	}
	storePointerUncheckedofObjectwithValue(0, topRemappableOop(), _address);
	cogConstituentIndex = 1;
	/* begin mapFor:bcpc:performUntil:arg: */
	_startbcpc = startPCOfMethod((_cogMethod->methodObject));
	assert(((_cogMethod->stackCheckOffset)) > 0);
	_mcpc = ((usqInt) _cogMethod ) + ((_cogMethod->stackCheckOffset));
	_result = collectCogConstituentForAnnotationMcpcBcpcMethod(null, 0 + ((sqInt) (((usqInt) HasBytecodePC ) << 1) ), ((char *) _mcpc ), _startbcpc, ((void *) _cogMethod ));
	if (_result != 0) {
		_errCode = _result;
		goto l3;
	}
	_bcpc = _startbcpc;
	_isInBlock = (_cogMethod->cpicHasMNUCaseOrCMIsFullBlock);
	_homeMethod = ((CogMethod *) _cogMethod );
	assert(_startbcpc == (startPCOfMethodHeader((_homeMethod->methodHeader))));
	_map = (((usqInt) _homeMethod ) + ((_homeMethod->blockSize))) - 1;
	_annotation = ((usqInt) (byteAt(_map)) ) >> AnnotationShift;
	assert((_annotation == IsAbsPCReference) || ((_annotation == IsObjectReference) || ((_annotation == IsRelativeCall) || (_annotation == IsDisplacementX2N))));
	_latestContinuation = _startbcpc;
	_aMethodObj = (_homeMethod->methodObject);
	_endbcpc = (numBytesOf(_aMethodObj)) - 1;
	_bcpc += deltaToSkipPrimAndErrorStoreInheader(_aMethodObj, (_homeMethod->methodHeader));
	_nExts = 0;
	{
		enumeratingCogMethod = _homeMethod;
	}
	while ((((usqInt) (byteAt(_map)) ) >> AnnotationShift) != HasBytecodePC) {
		_map -= 1;
	}
	_map -= 1;
	while (((_mapByte = byteAt(_map))) != MapEnd) {
		if (_mapByte >= FirstAnnotation) {
			_annotation = ((usqInt) _mapByte ) >> AnnotationShift;
			_mcpc += (_mapByte & DisplacementMask) * 4;
			if (_annotation >= HasBytecodePC) {
				if ((_annotation == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
					_annotation += _mapByte & DisplacementMask;
					_map -= 1;
				}
				while (1) {
					_byte = fetchByteofObject(_bcpc, _aMethodObj);
					_descriptor = generatorAt(_byte);
					if (_isInBlock) {
						if (_bcpc >= _endbcpc) {
							_errCode = 0;
							goto l3;
						}
					} else {
						if (((_descriptor->isReturn)) && (_bcpc >= _latestContinuation)) {
							_errCode = 0;
							goto l3;
						}
						if (isBranch(_descriptor)) {
							/* begin latestContinuationPCFor:at:exts:in: */
							_distance = ((_descriptor->spanFunction))(_descriptor, _bcpc, _nExts, _aMethodObj);
							_targetPC = (_bcpc + ((_descriptor->numBytes))) + (((_distance < 0) ? 0 : _distance));
							/* end latestContinuationPCFor:at:exts:in: */
							_latestContinuation = ((_latestContinuation < _targetPC) ? _targetPC : _latestContinuation);
						}
					}
					_nextBcpc = _bcpc + ((_descriptor->numBytes));
					if (((_descriptor->isMapped)) || (_isInBlock && ((_descriptor->isMappedInBlock)))) 
						break;
					_bcpc = _nextBcpc;
					_nExts = (((_descriptor->isExtension))
						 ? _nExts + 1
						 : 0);
				}
				_isBackwardBranch = (isBranch(_descriptor)) && ((assert(((_descriptor->spanFunction)) != null), (((_descriptor->spanFunction))(_descriptor, _bcpc, _nExts, _aMethodObj)) < 0));
				_result = collectCogConstituentForAnnotationMcpcBcpcMethod(_descriptor, ((_isBackwardBranch)
					 ? ((sqInt) (((usqInt) _annotation ) << 1) ) + 1
					 : ((sqInt) (((usqInt) _annotation ) << 1) )), ((char *) _mcpc ), ((_isBackwardBranch)
					 ? _bcpc - (2 * _nExts)
					 : _bcpc), ((void *) _cogMethod ));
				if (_result != 0) {
					_errCode = _result;
					goto l3;
				}
				_bcpc = _nextBcpc;
				_nExts = (((_descriptor->isExtension))
					 ? _nExts + 1
					 : 0);
			}
		} else {
			assert(((((usqInt) _mapByte ) >> AnnotationShift) == IsDisplacementX2N) || ((((usqInt) _mapByte ) >> AnnotationShift) == IsAnnotationExtension));
			if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
				_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
			}
		}
		_map -= 1;
	}
	_errCode = 0;
	l3:
	;
	/* end mapFor:bcpc:performUntil:arg: */
	if (_errCode != 0) {
		popRemappableOop();
		return null;
	}
	if (cogConstituentIndex < _nSlots) {
		shortentoIndexableSize(topRemappableOop(), cogConstituentIndex);
	}
	return popRemappableOop();
}
/* Cogit>>#compactCogCompiledCode */
void
compactCogCompiledCode(void)
{
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		assert(noCogMethodsMaximallyMarked());
		markActiveMethodsAndReferents();
		freeOlderMethodsForCompaction();
		compactPICsWithFreedTargets();
		planCompaction();
		updateStackZoneReferencesToCompiledCodePreCompaction();
		relocateMethodsPreCompaction();
		compactCompiledCode();
		assert(allMethodsHaveCorrectHeader());
		assert(kosherYoungReferrers());
		stopsFromto(backEnd, freeStart(), (youngReferrers()) - 1);
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		flushICacheFromto(((usqInt) methodZoneBase ), ((usqInt) (youngReferrers()) ));
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
}
/* Cogit>>#compactPICsWithFreedTargets */
static void
compactPICsWithFreedTargets(void)
{
	CogMethod *_cogMethod;
	int _count;

	_cogMethod = ((CogMethod *) methodZoneBase );
	_count = 0;
	while (_cogMethod < (limitZony())) {
		if ((((_cogMethod->cmType)) == CMPolymorphicIC) && (cPICCompactAndIsNowEmpty(_cogMethod))) {
			(_cogMethod->cmType = CMFree);
		}
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		_count += 1;
	}
	assert(_count == (numMethods()));
}
/*	The start of a CogMethod has a call to a run-time abort routine that 
	either handles an in-line cache failure or a stack overflow. The routine 
	selects the 
	path depending on ReceiverResultReg; if zero it takes the stack overflow 
	path; if nonzero the in-line cache miss path. Neither of these paths 
	returns. The abort routine must be called; In the callee the method is 
	located by 
	adding the relevant offset to the return address of the call. 
	 
	N.B. This code must match that in compilePICAbort: so that the offset of 
	the return address of the call is the same in methods and closed PICs. */
/* Cogit>>#compileAbort */
static AbstractInstruction *
compileAbort(void)
{
	AbstractInstruction *_anInstruction;
	sqInt _callTarget;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(MoveCqR, 0, ReceiverResultReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(0));
	}
	stackOverflowCall = _anInstruction;
	/* end checkQuickConstant:forInstruction: */
	{
		sendMiss = genoperand(PushR, LinkReg);
		/* begin Call: */
		_callTarget = methodAbortTrampolineFor(methodOrBlockNumArgs);
		return genoperand(Call, _callTarget);
		/* end Call: */
	}
}
/*	Generate a call to aRoutine with up to 4 arguments. If resultRegOrNone is 
	not NoReg assign the C result to resultRegOrNone. If saveRegs, save all 
	registers. Hack: a negative arg value indicates an abstract register, a 
	non-negative value 
	indicates a constant. */
/* Cogit>>#compileCallFor:numArgs:arg:arg:arg:arg:resultReg:regsToSave: */
static void NoDbgRegParms
compileCallFornumArgsargargargargresultRegregsToSave(void *_aRoutine, sqInt _numArgs, sqInt _regOrConst0, sqInt _regOrConst1, sqInt _regOrConst2, sqInt _regOrConst3, sqInt _resultRegOrNone, sqInt _regMask)
{
	const int cStackAlignment = STACK_ALIGN_BYTES;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	sqInt _delta;
	int _numRegsPushed;
	sqInt _operand2;
	sqInt _reg;
	sqInt _reg2;
	int _registerCount;
	int _registerCount2;
	usqInt _regMaskCopy;
	sqInt _regsToSave;
	sqInt _wordsPushedModAlignment;

	_regsToSave = ((_resultRegOrNone == NoReg)
		 ? _regMask
		 : (_regMask | (1ULL << _resultRegOrNone)) - (1ULL << _resultRegOrNone));
	if (cStackAlignment > BytesPerWord) {
		/* begin genAlignCStackSavingRegisters:numArgs:wordAlignment: */
		_regMaskCopy = ((usqInt) _regsToSave );
		_numRegsPushed = 0;
		while (_regMaskCopy != 0) {
			_numRegsPushed += _regMaskCopy & 1;
			_regMaskCopy = ((usqInt) _regMaskCopy ) >> 1;
		}
		if ((_numRegsPushed == 0) && ((numIntRegArgs(((AbstractInstruction *) backEnd ))) >= _numArgs)) {
			goto l4;
		}
		_wordsPushedModAlignment = (_numRegsPushed + _numArgs) % (cStackAlignment / BytesPerWord);
		if (_wordsPushedModAlignment != 0) {
			_delta = (cStackAlignment / BytesPerWord) - _wordsPushedModAlignment;
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperand(SubCqR, _delta * BytesPerWord, SPReg);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(_delta * BytesPerWord));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		l4:
		;
		/* end genAlignCStackSavingRegisters:numArgs:wordAlignment: */
	}
	{
		/* begin genSaveRegs: */
		assert(((R12 - R1) + 1) == 12);
		assert(!(_regsToSave & (registerMaskForand(SPReg, FPReg))));
		_registerCount2 = 0;
		for (_reg2 = R12; _reg2 >= R1; _reg2 += -1) {
			if (_regsToSave & (1ULL << _reg2)) {
				_registerCount2 += 1;
			}
		}
		if (!((_registerCount2 % 2) == 0)) {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction2 = genoperand(PushCq, 48879);
			if (usesOutOfLineLiteral(_anInstruction2)) {
				(_anInstruction2->dependent = locateLiteral(48879));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		for (_reg2 = R12; _reg2 >= R1; _reg2 += -1) {
			if (_regsToSave & (1ULL << _reg2)) {
				genoperand(PushR, _reg2);
			}
		}
		/* end genSaveRegs: */
		/* begin genMarshallNArgs:arg:arg:arg:arg: */
		if (_numArgs == 0) {
			goto l6;
		}
		if (_regOrConst0 < NoReg) {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction3 = genoperandoperand(MoveCqR, -2 - _regOrConst0, CArg0Reg);
			if (usesOutOfLineLiteral(_anInstruction3)) {
				(_anInstruction3->dependent = locateLiteral(-2 - _regOrConst0));
			}
			/* end checkQuickConstant:forInstruction: */
		} else {
			genoperandoperand(MoveRR, _regOrConst0, CArg0Reg);
		}
		if (_numArgs == 1) {
			goto l6;
		}
		if (_regOrConst1 < NoReg) {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction4 = genoperandoperand(MoveCqR, -2 - _regOrConst1, CArg1Reg);
			if (usesOutOfLineLiteral(_anInstruction4)) {
				(_anInstruction4->dependent = locateLiteral(-2 - _regOrConst1));
			}
			/* end checkQuickConstant:forInstruction: */
		} else {
			genoperandoperand(MoveRR, _regOrConst1, CArg1Reg);
		}
		if (_numArgs == 2) {
			goto l6;
		}
		if (_regOrConst2 < NoReg) {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction5 = genoperandoperand(MoveCqR, -2 - _regOrConst2, CArg2Reg);
			if (usesOutOfLineLiteral(_anInstruction5)) {
				(_anInstruction5->dependent = locateLiteral(-2 - _regOrConst2));
			}
			/* end checkQuickConstant:forInstruction: */
		} else {
			genoperandoperand(MoveRR, _regOrConst2, CArg2Reg);
		}
		if (_numArgs == 3) {
			goto l6;
		}
		if (_regOrConst3 < NoReg) {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction6 = genoperandoperand(MoveCqR, -2 - _regOrConst3, CArg3Reg);
			if (usesOutOfLineLiteral(_anInstruction6)) {
				(_anInstruction6->dependent = locateLiteral(-2 - _regOrConst3));
			}
			/* end checkQuickConstant:forInstruction: */
		} else {
			genoperandoperand(MoveRR, _regOrConst3, CArg3Reg);
		}
		l6:
		;
		/* end genMarshallNArgs:arg:arg:arg:arg: */
	}
	{
		/* begin gen:literal: */
		_operand2 = ((usqInt) _aRoutine );
		checkLiteralforInstruction(_operand2, genoperand(CallFull, _operand2));
		/* end gen:literal: */
	}
	if (_resultRegOrNone != NoReg) {
		genWriteCResultIntoReg(backEnd, _resultRegOrNone);
	}
	/* begin genRemoveNArgsFromStack: */
	assert(_numArgs <= 4);
	/* end genRemoveNArgsFromStack: */
	/* begin genRestoreRegs: */
	assert(((R12 - R1) + 1) == 12);
	assert(!(_regsToSave & (registerMaskForand(SPReg, FPReg))));
	_registerCount = 0;
	for (_reg = R1; _reg <= R12; _reg += 1) {
		if (_regsToSave & (1ULL << _reg)) {
			_registerCount += 1;
		}
	}
	for (_reg = R1; _reg <= R12; _reg += 1) {
		if (_regsToSave & (1ULL << _reg)) {
			genoperand(PopR, _reg);
		}
	}
	if (!((_registerCount % 2) == 0)) {
		genoperand(PopR, R0);
	}
	/* end genRestoreRegs: */
}
/*	Compile the cache tag computation and the first comparison. Answer the 
	address of that comparison. */
/* Cogit>>#compileCPICEntry */
static AbstractInstruction *
compileCPICEntry(void)
{
	entry = genGetInlineCacheClassTagFrominto(ReceiverResultReg, TempReg);
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, ClassReg, TempReg);
	/* end CmpR:R: */
	return genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
}
/*	Compile the abstract instructions for the entire full block method. */
/* Cogit>>#compileEntireFullBlockMethod: */
static sqInt NoDbgRegParms
compileEntireFullBlockMethod(sqInt _numCopied)
{
	sqInt _result;

	/* begin preenMethodLabel */
	/* begin setLabelOffset: */
	((((AbstractInstruction *) methodLabel ))->operands)[1] = 0;
	/* end setLabelOffset: */
	/* end preenMethodLabel */
	compileFullBlockEntry();
	compileFullBlockMethodFrameBuild(_numCopied);
	if (((_result = compileMethodBody())) < 0) {
		return _result;
	}
	return 0;
}
/*	The entry code to a method checks that the class of the current receiver 
	matches that in the inline cache. Other non-obvious elements are that its 
	alignment must be 
	different from the alignment of the noCheckEntry so that the method map 
	machinery can distinguish normal and super sends (super sends bind to the 
	noCheckEntry).  */
/* Cogit>>#compileEntry */
static void
compileEntry(void)
{
	AbstractInstruction *_abstractInstruction;
	AbstractInstruction * _inst;

	entry = genGetInlineCacheClassTagFrominto(ReceiverResultReg, TempReg);
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, ClassReg, TempReg);
	/* end CmpR:R: */
	genConditionalBranchoperand(JumpNonZero, ((sqInt) sendMiss ));
	noCheckEntry = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
	if (compileSendTrace()) {
		/* begin saveAndRestoreLinkRegAround: */
		_inst = genoperand(PushR, LinkReg);
		{
			/* begin CallRT: */
			/* begin annotateCall: */
			_abstractInstruction = genoperand(Call, ceTraceLinkedSendTrampoline);
			(_abstractInstruction->annotation = IsRelativeCall);
			/* end annotateCall: */
			/* end CallRT: */
		}
		genoperand(PopR, LinkReg);
		/* end saveAndRestoreLinkRegAround: */
	}
}
/*	Compile the abstract instructions for the entire method, including blocks.Abort for stack overflow on full block activation (no inline cache miss 
	possible). The flag is SendNumArgsReg. */
/* Cogit>>#compileFullBlockEntry */
static sqInt
compileFullBlockEntry(void)
{
	sqInt _alignment;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	sqInt _callTarget;
	AbstractInstruction * _jumpNoContextSwitch;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(MoveCqR, 0, ReceiverResultReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(0));
	}
	stackOverflowCall = _anInstruction;
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin PushR: */
		genoperand(PushR, LinkReg);
		/* end PushR: */
	}
	/* begin Call: */
	_callTarget = methodAbortTrampolineFor(methodOrBlockNumArgs);
	genoperand(Call, _callTarget);
	/* end Call: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(MoveCqR, 0, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(0));
	}
	fullBlockNoContextSwitchEntry = _anInstruction2;
	/* end checkQuickConstant:forInstruction: */
	_jumpNoContextSwitch = genoperand(Jump, ((sqInt) 0 ));
	/* begin AlignmentNops: */
	_alignment = ((BytesPerWord < 8) ? 8 : BytesPerWord);
	genoperand(AlignmentNops, _alignment);
	/* end AlignmentNops: */
	fullBlockEntry = genoperandoperand(MoveRR, ReceiverResultReg, SendNumArgsReg);
	jmpTarget(_jumpNoContextSwitch, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return 0;
}
/*	Compile the top-level method body. */
/* Cogit>>#compileMethodBody */
static sqInt
compileMethodBody(void)
{
	if (endPC < initialPC) {
		return 0;
	}
	return compileAbstractInstructionsFromthrough(initialPC + (deltaToSkipPrimAndErrorStoreInheader(methodObj, methodHeader)), endPC);
}
/*	The start of a PIC has a call to a run-time abort routine that either 
	handles a dispatch to an 
	interpreted method or a dispatch of an MNU case. The routine selects the 
	path by testing 
	ClassReg, which holds the inline cache tag; if equal to the 
	picAbortDiscriminatorValue (zero) 
	it takes the MNU path; if nonzero the dispatch to interpreter path. 
	Neither of these paths 
	returns. The abort routine must be called; In the callee the PIC is 
	located by adding the 
	relevant offset to the return address of the call. 
	 
	N.B. This code must match that in compileAbort so that the offset of the 
	return address of 
	the call is the same in methods and closed PICs. */
/* Cogit>>#compilePICAbort: */
static sqInt NoDbgRegParms
compilePICAbort(sqInt _numArgs)
{
	AbstractInstruction *_anInstruction;
	sqInt _callTarget;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(MoveCqR, 0, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		picInterpretAbort = genoperand(PushR, LinkReg);
		/* begin Call: */
		_callTarget = picAbortTrampolineFor(_numArgs);
		genoperand(Call, _callTarget);
		/* end Call: */
	}
	return 0;
}
/*	Generate a trampoline with up to four arguments. Generate either a call or 
	a jump to aRoutine 
	as requested by callJumpBar. If generating a call and resultRegOrNone is 
	not NoReg pass the C 
	result back in resultRegOrNone. 
	Hack: a negative value indicates an abstract register, a non-negative 
	value indicates a constant. */
/* Cogit>>#compileTrampolineFor:numArgs:arg:arg:arg:arg:regsToSave:pushLinkReg:resultReg: */
static void NoDbgRegParms
compileTrampolineFornumArgsargargargargregsToSavepushLinkRegresultReg(void *_aRoutine, sqInt _numArgs, sqInt _regOrConst0, sqInt _regOrConst1, sqInt _regOrConst2, sqInt _regOrConst3, sqInt _regMask, sqInt _pushLinkReg, sqInt _resultRegOrNone)
{
	genSmalltalkToCStackSwitch(_pushLinkReg);
	compileCallFornumArgsargargargargresultRegregsToSave(_aRoutine, _numArgs, _regOrConst0, _regOrConst1, _regOrConst2, _regOrConst3, _resultRegOrNone, _regMask);
	genLoadStackPointers(backEnd);
	if (_pushLinkReg && 1) {
		{
			genoperand(PopR, LinkReg);
			genoperand(RetN, 0);
		}
	} else {
		genoperand(RetN, 0);
	}
}
/*	Generate the entry code for a method to determine cmEntryOffset and 
	cmNoCheckEntryOffset. We 
	need cmNoCheckEntryOffset up front to be able to generate the map starting 
	from cmNoCheckEntryOffsetstack allocate the various collections so that they 
	are effectively garbage collected on return. */
/* Cogit>>#computeEntryOffsets */
static void
computeEntryOffsets(void)
{
	AbstractInstruction *_sendMissCall;

	/* begin allocateOpcodes:bytecodes: */
	ensureAndClearAbstractOpcodes(24);
	zeroOpcodeIndexForNewOpcodes();
	labelCounter = 0;
	/* end allocateOpcodes:bytecodes: */
	methodOrBlockNumArgs = 0;
	_sendMissCall = compileAbort();
	compileEntry();
	computeMaximumSizes();
	/* begin enableCodeZoneWriteDuring: */
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		generateInstructionsAt(methodZoneBase + (sizeof(CogMethod)));
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	/* end enableCodeZoneWriteDuring: */
	cmEntryOffset = ((entry->address)) - methodZoneBase;
	cmNoCheckEntryOffset = ((noCheckEntry->address)) - methodZoneBase;
	missOffset = (((_sendMissCall->address)) + ((_sendMissCall->machineCodeSize))) - methodZoneBase;
}
/*	Generate the entry code for a method to determine cmEntryOffset and 
	cmNoCheckEntryOffset. We 
	need cmNoCheckEntryOffset up front to be able to generate the map starting 
	from cmNoCheckEntryOffsetstack allocate the various collections so that they 
	are effectively garbage collected on return. */
/* Cogit>>#computeFullBlockEntryOffsets */
static void
computeFullBlockEntryOffsets(void)
{
	/* begin allocateOpcodes:bytecodes: */
	ensureAndClearAbstractOpcodes(24);
	zeroOpcodeIndexForNewOpcodes();
	labelCounter = 0;
	/* end allocateOpcodes:bytecodes: */
	methodOrBlockNumArgs = 0;
	compileFullBlockEntry();
	computeMaximumSizes();
	/* begin enableCodeZoneWriteDuring: */
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		generateInstructionsAt(methodZoneBase + (sizeof(CogMethod)));
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	/* end enableCodeZoneWriteDuring: */
	cbEntryOffset = ((fullBlockEntry->address)) - methodZoneBase;
	cbNoSwitchEntryOffset = ((fullBlockNoContextSwitchEntry->address)) - methodZoneBase;
}
/*	This pass assigns maximum sizes to all abstract instructions and 
	eliminates jump fixups. 
	It hence assigns the maximum address an instruction will occur at which 
	allows the next 
	pass to conservatively size jumps. */
/* Cogit>>#computeMaximumSizes */
static void
computeMaximumSizes(void)
{
	AbstractInstruction *_abstractInstruction;
	sqInt _i;
	int _relativeAddress;

	dumpLiterals(0);
	_relativeAddress = 0;
	for (_i = 0; _i < opcodeIndex; _i += 1) {
		_abstractInstruction = abstractInstructionAt(_i);
		{
			(_abstractInstruction->address = _relativeAddress);
			(_abstractInstruction->maxSize = computeMaximumSize(_abstractInstruction));
		}
		_relativeAddress += (_abstractInstruction->maxSize);
	}
}
/*	Configure a copy of the prototype CPIC for a two-case PIC for  
	case0CogMethod and 
	case1Method 
	case1Tag. 
	The tag for case0CogMethod is at the send site and so doesn't need to be 
	generated. case1Method may be any of 
	- a Cog method; jump to its unchecked entry-point 
	- a CompiledMethod; jump to the ceInterpretFromPIC trampoline 
	- nil; call ceMNUFromPIC 
	addDelta is the address change from the prototype to the new CPIC 
	location, needed 
	because the loading of the CPIC label at the end may use a literal instead 
	of a pc relative load.self disassembleFrom: cPIC asInteger + (self sizeof: CogMethod) to: cPIC 
	asInteger + closedPICSize */
/* Cogit>>#configureCPIC:Case0:Case1Method:tag:isMNUCase: */
static sqInt NoDbgRegParms
configureCPICCase0Case1MethodtagisMNUCase(CogMethod *_aPIC, CogMethod *_case0CogMethod, sqInt _case1Method, sqInt _case1Tag, sqInt _isMNUCase)
{
	sqInt _caseEndAddress;
	sqInt _operand;
	sqInt _targetEntry;

	assert(_case1Method != null);
	if (!_isMNUCase && (methodHasCogMethod(_case1Method))) {
		_operand = 0;
		_targetEntry = ((sqInt) (cogMethodOf(_case1Method)) ) + cmNoCheckEntryOffset;
	} else {
		_operand = (((_case1Method == null) || (isYoungObject(getMemoryMap(), _case1Method)))
			 ? 0
			 : _case1Method);
		_targetEntry = ((_case1Method == null)
			 ? picAbortAddress(_aPIC)
			 : ((sqInt) _aPIC ) + (picInterpretAbortOffset()));
	}
	rewriteJumpLongAttarget(backEnd, ((sqInt) _aPIC ) + firstCPICCaseOffset, ((sqInt) _case0CogMethod ) + cmNoCheckEntryOffset);
	_caseEndAddress = addressOfEndOfCaseinCPIC(2, _aPIC);
	rewritePICCaseAttagobjReftarget(_caseEndAddress, _case1Tag, _operand, ((sqInt) (((_isMNUCase)
		 ? picAbortAddress(_aPIC)
		 : _targetEntry)) ));
	return 0;
}
/*	Configure a copy of the prototype CPIC for a one-case MNU CPIC that calls 
	ceMNUFromPIC for 
	case0Tag The tag for case0 is at the send site and so doesn't need to be 
	generated. addDelta is the address change from the prototype to the new 
	CPIC location, needed 
	because the loading of the CPIC label at the end may be a literal instead 
	of a pc-relative load.We do not scavenge PICs, hence we cannot cache the MNU method if it is in 
	new space. */
/* Cogit>>#configureMNUCPIC:methodOperand: */
static sqInt NoDbgRegParms
configureMNUCPICmethodOperand(CogMethod *_aPIC, sqInt _methodOop)
{
	sqInt _operand;
	sqInt _target;

	_operand = (((_methodOop == null) || (isYoungObject(getMemoryMap(), _methodOop)))
		 ? 0
		 : _methodOop);
	rewriteJumpLongAttarget(backEnd, ((sqInt) _aPIC ) + firstCPICCaseOffset, picAbortAddress(_aPIC));
	storeLiteralbeforeFollowingAddress(backEnd, _operand, (((sqInt) _aPIC ) + firstCPICCaseOffset) - (jumpLongByteSize(backEnd)));
	/* begin rewriteCPIC:caseJumpTo: */
	_target = addressOfEndOfCaseinCPIC(2, _aPIC);
	rewriteCPICJumpAttarget(backEnd, ((((sqInt) _aPIC ) + firstCPICCaseOffset) - (jumpLongByteSize(backEnd))) - (loadLiteralByteSize(backEnd)), _target);
	/* end rewriteCPIC:caseJumpTo: */
	return 0;
}
/*	Scan the CPIC for target methods that have been freed and eliminate them. 
	Since the first entry cannot be eliminated, answer that the PIC should be 
	freed if the first entry is to a free target. Answer if the PIC is now 
	empty or should be freed. */
/* Cogit>>#cPICCompactAndIsNowEmpty: */
static sqInt NoDbgRegParms
cPICCompactAndIsNowEmpty(CogMethod *_cPIC)
{
	sqInt _entryPoint;
	sqInt _followingAddress;
	sqInt _i;
	sqInt _methods[MaxCPICCases];
	sqInt _pc;
	int _tags[MaxCPICCases];
	CogMethod *_targetMethod;
	sqInt _targets[MaxCPICCases];
	int _used;
	int _valid;

	_used = 0;
	for (_i = 1; _i <= ((_cPIC->cPICNumCases)); _i += 1) {
		_pc = addressOfEndOfCaseinCPIC(_i, _cPIC);
		if (_i == 1) {
			_entryPoint = jumpLongTargetBeforeFollowingAddress(backEnd, _pc);
		} else {
			/* begin jumpLongConditionalTargetBeforeFollowingAddress: */
			_entryPoint = jumpLongTargetBeforeFollowingAddress(((AbstractInstruction *) backEnd ), _pc);
			/* end jumpLongConditionalTargetBeforeFollowingAddress: */
		}
		_valid = 1;
		if (!((((usqInt) _cPIC ) <= ((usqInt) _entryPoint )) && ((((usqInt) _cPIC ) + ((_cPIC->blockSize))) >= ((usqInt) _entryPoint )))) {
			_targetMethod = ((CogMethod *) (_entryPoint - cmNoCheckEntryOffset) );
			assert((((_targetMethod->cmType)) == CMMethod) || (((_targetMethod->cmType)) == CMFree));
			if (((_targetMethod->cmType)) == CMFree) {
				if (_i == 1) {
					return 1;
				}
				_valid = 0;
			}
		}
		if (_valid) {
			_tags[_used] = ((_i > 1)
				 ? (/* begin literal32BeforeFollowingAddress: */ (_followingAddress = _pc - (jumpLongConditionalByteSize(backEnd))), literalBeforeFollowingAddress(((AbstractInstruction *) backEnd ), _followingAddress) /* end literal32BeforeFollowingAddress: */)
				 : 0);
			_targets[_used] = _entryPoint;
			_methods[_used] = literalBeforeFollowingAddress(backEnd, _pc - (((_i == 1)
				 ? jumpLongByteSize(backEnd)
				 : (jumpLongConditionalByteSize(backEnd)) + (cmpC32RTempByteSize(backEnd)))));
			_used += 1;
		}
	}
	if (_used == ((_cPIC->cPICNumCases))) {
		return 0;
	}
	if (_used == 0) {
		return 1;
	}
	(_cPIC->cPICNumCases = _used);
	if (_used == 1) {
		_pc = addressOfEndOfCaseinCPIC(2, _cPIC);
		/* begin rewriteCPIC:caseJumpTo: */
		rewriteCPICJumpAttarget(backEnd, ((((sqInt) _cPIC ) + firstCPICCaseOffset) - (jumpLongByteSize(backEnd))) - (loadLiteralByteSize(backEnd)), _pc);
		/* end rewriteCPIC:caseJumpTo: */
		return 0;
	}
	for (_i = 1; _i < _used; _i += 1) {
		_pc = addressOfEndOfCaseinCPIC(_i + 1, _cPIC);
		rewritePICCaseAttagobjReftarget(_pc, _tags[_i], _methods[_i], _targets[_i]);
	}
	/* begin rewriteCPIC:caseJumpTo: */
	rewriteCPICJumpAttarget(backEnd, ((((sqInt) _cPIC ) + firstCPICCaseOffset) - (jumpLongByteSize(backEnd))) - (loadLiteralByteSize(backEnd)), _pc - cPICCaseSize);
	/* end rewriteCPIC:caseJumpTo: */
	return 0;
}
/*	The first case in a CPIC doesn't have a class reference so we need only 
	step over actually usd subsequent cases. */
/* Cogit>>#cPICHasForwardedClass: */
static sqInt NoDbgRegParms
cPICHasForwardedClass(CogMethod *_cPIC)
{
	sqInt _classIndex;
	sqInt _i;
	sqInt _pc;

	_pc = (addressOfEndOfCaseinCPIC((_cPIC->cPICNumCases), _cPIC)) - (jumpLongConditionalByteSize(backEnd));
	for (_i = 2; _i <= ((_cPIC->cPICNumCases)); _i += 1) {
		/* begin literal32BeforeFollowingAddress: */
		_classIndex = literalBeforeFollowingAddress(((AbstractInstruction *) backEnd ), _pc);
		/* end literal32BeforeFollowingAddress: */
		if (isForwardedClassIndex(_classIndex)) {
			return 1;
		}
		_pc += cPICCaseSize;
	}
	return 0;
}
/*	scan the CPIC for target methods that have been freed. */
/* Cogit>>#cPICHasFreedTargets: */
static sqInt NoDbgRegParms
cPICHasFreedTargets(CogMethod *_cPIC)
{
	sqInt _entryPoint;
	sqInt _i;
	sqInt _pc;
	CogMethod *_targetMethod;

	for (_i = 1; _i <= ((_cPIC->cPICNumCases)); _i += 1) {
		_pc = addressOfEndOfCaseinCPIC(_i, _cPIC);
		if (_i == 1) {
			_entryPoint = jumpLongTargetBeforeFollowingAddress(backEnd, _pc);
		} else {
			/* begin jumpLongConditionalTargetBeforeFollowingAddress: */
			_entryPoint = jumpLongTargetBeforeFollowingAddress(((AbstractInstruction *) backEnd ), _pc);
			/* end jumpLongConditionalTargetBeforeFollowingAddress: */
		}
		if (!((((usqInt) _cPIC ) <= ((usqInt) _entryPoint )) && ((((usqInt) _cPIC ) + ((_cPIC->blockSize))) >= ((usqInt) _entryPoint )))) {
			_targetMethod = ((CogMethod *) (_entryPoint - cmNoCheckEntryOffset) );
			assert((((_targetMethod->cmType)) == CMMethod) || (((_targetMethod->cmType)) == CMFree));
			if (((_targetMethod->cmType)) == CMFree) {
				return 1;
			}
		}
	}
	return 0;
}
/*	Whimsey; we want 16rCA5E10 + cPICPrototypeCaseOffset to be somewhere in 
	the middle of the zone. */
/* Cogit>>#cPICPrototypeCaseOffset */
static sqInt
cPICPrototypeCaseOffset(void)
{
	return ((methodZoneBase + (youngReferrers())) / 2) - 13262352;
}
/*	Are any of the jumps from this CPIC to targetMethod? */
/* Cogit>>#cPIC:HasTarget: */
static sqInt NoDbgRegParms
cPICHasTarget(CogMethod *_cPIC, CogMethod *_targetMethod)
{
	sqInt _i;
	sqInt _pc;
	sqInt _target;

	_target = ((usqInt) _targetMethod ) + cmNoCheckEntryOffset;
	_pc = ((sqInt) _cPIC ) + firstCPICCaseOffset;
	if (_target == (jumpLongTargetBeforeFollowingAddress(backEnd, _pc))) {
		return 1;
	}
	for (_i = 2; _i <= MaxCPICCases; _i += 1) {
		_pc += cPICCaseSize;
		if (_target == (jumpLongTargetBeforeFollowingAddress(backEnd, _pc))) {
			return 1;
		}
	}
	return 0;
}
/*	Answer an Array of the PIC's selector, followed by class and 
	targetMethod/doesNotUnderstand: for each entry in the PIC. */
/* Cogit>>#createCPICData: */
static sqInt NoDbgRegParms
createCPICData(CogMethod *_cPIC)
{
	sqInt _class;
	sqInt _entryPoint;
	sqInt _i;
	sqInt _pc;
	sqInt _picData;
	sqInt _target;
	CogMethod *_targetMethod;

	assert((((_cPIC->methodObject)) == 0) || (addressCouldBeOop((_cPIC->methodObject))));
	_picData = instantiateClassindexableSize(classArray(), (((_cPIC->cPICNumCases)) * 2) + 1);
	if (!_picData) {
		return _picData;
	}
	storePointerUncheckedofObjectwithValue(0, _picData, (_cPIC->selector));
	for (_i = 1; _i <= ((_cPIC->cPICNumCases)); _i += 1) {
		_pc = addressOfEndOfCaseinCPIC(_i, _cPIC);
		if (_i == 1) {
			_class = (_cPIC->methodObject);
			if (_class == 0) {
				_class = nilObject();
			}
			_entryPoint = jumpLongTargetBeforeFollowingAddress(backEnd, _pc);
		} else {
			_class = classForInlineCacheTag(literal32BeforeFollowingAddress(backEnd, _pc - (jumpLongConditionalByteSize(backEnd))));
			/* begin jumpLongConditionalTargetBeforeFollowingAddress: */
			_entryPoint = jumpLongTargetBeforeFollowingAddress(((AbstractInstruction *) backEnd ), _pc);
			/* end jumpLongConditionalTargetBeforeFollowingAddress: */
		}
		if ((((usqInt) _cPIC ) <= ((usqInt) _entryPoint )) && ((((usqInt) _cPIC ) + ((_cPIC->blockSize))) >= ((usqInt) _entryPoint ))) {
			_target = splObj(SelectorDoesNotUnderstand);
		} else {
			_targetMethod = ((CogMethod *) (_entryPoint - cmNoCheckEntryOffset) );
			assert(((_targetMethod->cmType)) == CMMethod);
			_target = (_targetMethod->methodObject);
		}
		{
			storePointerUncheckedofObjectwithValue((_i * 2) - 1, _picData, _class);
			storePointerUncheckedofObjectwithValue(_i * 2, _picData, _target);
		}
	}
	beRootIfOld(_picData);
	(_cPIC->methodObject = 0);
	return _picData;
}
/*	Division is a little weird on some processors. Defer to the backEnd 
	to allow it to generate any special code it may need to. */
/* Cogit>>#DivR:R:Quo:Rem: */
static AbstractInstruction * NoDbgRegParms
gDivRRQuoRem(sqInt _rDivisor, sqInt _rDividend, sqInt _rQuotient, sqInt _rRemainder)
{
	genDivRRQuoRem(backEnd, _rDivisor, _rDividend, _rQuotient, _rRemainder);
	return abstractInstructionAt(opcodeIndex - 1);
}
/* Cogit>>#DupS:R:Vr: */

#if FEATURE_JIT_SIMD
static AbstractInstruction * NoDbgRegParms
gDupSRVr(sqInt _aSize, sqInt _aGeneralRegister, sqInt _aVectorRegister)
{
	return genoperandoperandoperand(DupRVr, _aSize, _aGeneralRegister, _aVectorRegister);
}
#endif /* FEATURE_JIT_SIMD */
/*	Return the default number of bytes to allocate for native code at startup. 
	The actual value can be set via vmParameterAt: and/or a preference in the 
	ini file. */
/* Cogit>>#defaultCogCodeSize */
sqInt
defaultCogCodeSize(void)
{
	return 1024 * 1280;
}
/*	Answer the number of bytecodes to skip to get to the first bytecode 
	past the primitive call and any store of the error code. */
/* Cogit>>#deltaToSkipPrimAndErrorStoreIn:header: */
static sqInt NoDbgRegParms
deltaToSkipPrimAndErrorStoreInheader(sqInt _aMethodObj, sqInt _aMethodHeader)
{
	return ((((primitiveIndexOfMethodheader(_aMethodObj, _aMethodHeader)) > 0) && ((longStoreBytecodeForHeader(_aMethodHeader)) == (fetchByteofObject((startPCOfMethod(_aMethodObj)) + (sizeOfCallPrimitiveBytecode(_aMethodHeader)), _aMethodObj))))
		 ? (sizeOfCallPrimitiveBytecode(_aMethodHeader)) + (sizeOfLongStoreTempBytecode(_aMethodHeader))
		 : 0);
}
/* Cogit>>#endPCOf: */
static sqInt NoDbgRegParms
endPCOf(sqInt _aMethod)
{
	sqInt _byte;
	BytecodeDescriptor *_descriptor;
	sqInt _distance;
	sqInt _end;
	sqInt _latestContinuation;
	sqInt _nExts;
	sqInt _pc;
	sqInt _prim;
	sqInt _targetPC;

	_pc = (_latestContinuation = startPCOfMethod(_aMethod));
	if (((_prim = primitiveIndexOf(_aMethod))) > 0) {
		if (isQuickPrimitiveIndex(_prim)) {
			return _pc - 1;
		}
	}
	_nExts = 0;
	_end = numBytesOf(_aMethod);
	while (_pc <= _end) {
		_byte = fetchByteofObject(_pc, _aMethod);
		_descriptor = generatorAt(_byte);
		if (((_descriptor->isReturn)) && (_pc >= _latestContinuation)) {
			_end = _pc;
		}
		if (isBranch(_descriptor)) {
			_distance = ((_descriptor->spanFunction))(_descriptor, _pc, _nExts, _aMethod);
			_targetPC = (_pc + ((_descriptor->numBytes))) + _distance;
			_latestContinuation = ((_latestContinuation < _targetPC) ? _targetPC : _latestContinuation);
		}
		_nExts = (((_descriptor->isExtension))
			 ? _nExts + 1
			 : 0);
		_pc += (_descriptor->numBytes);
	}
	return _end;
}
/* Cogit>>#ensureAndClearAbstractOpcodes: */
static void NoDbgRegParms
ensureAndClearAbstractOpcodes(sqInt _numberOfAbstractOpcodes)
{
	usqIntptr_t _allocBytes;
	usqIntptr_t _clearFixupsBytes;
	usqIntptr_t _clearOpcodesBytes;
	usqIntptr_t _fixupBytes;
	usqIntptr_t _opcodeBytes;

	numAbstractOpcodes = _numberOfAbstractOpcodes;
	_opcodeBytes = (sizeof(CogAbstractInstruction)) * MaxNumberOfAbstractOpcodes;
	_fixupBytes = (sizeof(CogBytecodeFixup)) * MaxNumberOfAbstractOpcodes;
	_allocBytes = _opcodeBytes + _fixupBytes;
	_clearOpcodesBytes = (sizeof(CogAbstractInstruction)) * _numberOfAbstractOpcodes;
	_clearFixupsBytes = (sizeof(CogBytecodeFixup)) * _numberOfAbstractOpcodes;
	{
		if (!abstractOpcodes) {
			abstractOpcodes = malloc(_allocBytes);
			fixups = ((void *) (((usqInt) abstractOpcodes ) + _opcodeBytes) );
		}
		bzero(abstractOpcodes, _clearOpcodesBytes);
		bzero(fixups, _clearFixupsBytes);
	}
}
/*	This is a static version of ceEnterCogCodePopReceiverReg 
	for break-pointing when debugging in C.This exists only for break-pointing. */
/* Cogit>>#enterCogCodePopReceiver */
void
enterCogCodePopReceiver(void)
{
	realCEEnterCogCodePopReceiverReg();
	{
		error("what??");
	}
}
/*	Use asserts to check if the ClosedPICPrototype is as expected from 
	compileClosedPICPrototype, and can be updated as required via 
	rewriteCPICCaseAt:tag:objRef:target:. If all asserts pass, answer 
	0, otherwise answer a bit mask identifying all the errors.self disassembleFrom: methodZoneBase + (self sizeof: CogMethod) to: 
	methodZoneBase + closedPICSize */
/* Cogit>>#expectedClosedPICPrototype: */
static sqInt NoDbgRegParms
expectedClosedPICPrototype(CogMethod *_cPIC)
{
	sqInt _classTag;
	sqInt _classTagPC;
	sqInt _entryPoint;
	int _errors;
	sqInt _i;
	sqInt _methodObjPC;
	sqInt _object;
	sqInt _pc;

	_errors = 0;
	_pc = ((usqInt) _cPIC ) + firstCPICCaseOffset;
	_object = literalBeforeFollowingAddress(backEnd, _pc - (jumpLongByteSize(backEnd)));
	if (!(asserta(_object == (firstPrototypeMethodOop())))) {
		_errors = 1;
	}
	_entryPoint = jumpLongTargetBeforeFollowingAddress(backEnd, _pc);
	if (!(asserta(_entryPoint == ((cPICPrototypeCaseOffset()) + 13262352)))) {
		_errors += 2;
	}
	for (_i = 1; _i < MaxCPICCases; _i += 1) {
		_pc += cPICCaseSize;
		_methodObjPC = (_pc - (jumpLongConditionalByteSize(backEnd))) - (cmpC32RTempByteSize(backEnd));
		_object = literalBeforeFollowingAddress(backEnd, _methodObjPC);
		if (!(asserta(_object == ((subsequentPrototypeMethodOop()) + _i)))) {
			_errors = _errors | 4;
		}
		_classTagPC = _pc - (jumpLongConditionalByteSize(backEnd));
		/* begin literal32BeforeFollowingAddress: */
		_classTag = literalBeforeFollowingAddress(((AbstractInstruction *) backEnd ), _classTagPC);
		/* end literal32BeforeFollowingAddress: */
		if (!(asserta(_classTag == (3133021973U + _i)))) {
			_errors = _errors | 8;
		}
		/* begin jumpLongConditionalTargetBeforeFollowingAddress: */
		_entryPoint = jumpLongTargetBeforeFollowingAddress(((AbstractInstruction *) backEnd ), _pc);
		/* end jumpLongConditionalTargetBeforeFollowingAddress: */
		if (!(asserta(_entryPoint == (((cPICPrototypeCaseOffset()) + 13262352) + (_i * 16))))) {
			_errors = _errors | 16;
		}
		rewritePICCaseAttagobjReftarget(_pc, _classTag ^ 1515870810, _object ^ 2779096485U, _entryPoint ^ 371280);
		_object = literalBeforeFollowingAddress(backEnd, _methodObjPC);
		if (!(asserta(_object == (((subsequentPrototypeMethodOop()) + _i) ^ 2779096485U)))) {
			_errors = _errors | 32;
		}
		/* begin literal32BeforeFollowingAddress: */
		_classTag = literalBeforeFollowingAddress(((AbstractInstruction *) backEnd ), _classTagPC);
		/* end literal32BeforeFollowingAddress: */
		if (!(asserta(_classTag == ((3133021973U + _i) ^ 1515870810)))) {
			_errors = _errors | 64;
		}
		/* begin jumpLongConditionalTargetBeforeFollowingAddress: */
		_entryPoint = jumpLongTargetBeforeFollowingAddress(((AbstractInstruction *) backEnd ), _pc);
		/* end jumpLongConditionalTargetBeforeFollowingAddress: */
		if (!(asserta(_entryPoint == ((((cPICPrototypeCaseOffset()) + 13262352) + (_i * 16)) ^ 371280)))) {
			_errors = _errors | 128;
		}
		rewritePICCaseAttagobjReftarget(_pc, _classTag ^ 1515870810, _object ^ 2779096485U, _entryPoint ^ 371280);
	}
	_entryPoint = jumpLongTargetBeforeFollowingAddress(backEnd, (_pc + cPICEndSize) - (endSizeOffset()));
	if (!(asserta(_entryPoint == (cPICMissTrampolineFor(0))))) {
		_errors += 256;
	}
	return _errors;
}
/*	224		11100000	aaaaaaaa	Extend A (Ext A = Ext A prev * 256 + Ext A) */
/* Cogit>>#extABytecode */
static sqInt
extABytecode(void)
{
	extA = (((usqInt) extA ) << 8) + byte1;
	return 0;
}
/*	225		11100001	sbbbbbbb	Extend B (Ext B = Ext B prev * 256 + Ext B) */
/* Cogit>>#extBBytecode */
static sqInt
extBBytecode(void)
{
	extB = (((numExtB == 0) && (byte1 > 0x7F))
		 ? byte1 - 256
		 : (((usqInt) extB ) << 8) + byte1);
	numExtB += 1;
	return 0;
}
/* Cogit>>#FaddS:Rv:Rv:Rv: */
static AbstractInstruction * NoDbgRegParms
gFaddSRvRvRv(sqInt _aSize, sqInt _vectorRegister1, sqInt _vectorRegister2, sqInt _vectorRegisterSum)
{
	return genoperandoperandoperandoperand(FaddSRvRvRv, _aSize, _vectorRegister1, _vectorRegister2, _vectorRegisterSum);
}
/* Cogit>>#FsubS:Rv:Rv:Rv: */
static AbstractInstruction * NoDbgRegParms
gFsubSRvRvRv(sqInt _aSize, sqInt _minuendVectorRegister, sqInt _subtrahendVectorRegister, sqInt _vectorRegisterSum)
{
	return genoperandoperandoperandoperand(FsubSRvRvRv, _aSize, _minuendVectorRegister, _subtrahendVectorRegister, _vectorRegisterSum);
}
/* Cogit>>#fillInMethodHeader:size:selector: */
static CogMethod * NoDbgRegParms
fillInMethodHeadersizeselector(CogMethod *method, sqInt _size, sqInt _selector)
{
	CogMethod *_originalMethod;
	sqInt _rawHeader;

	(method->cmType = CMMethod);
	(method->objectHeader = nullHeaderForMachineCodeMethod());
	(method->blockSize = _size);
	(method->methodObject = methodObj);
	_rawHeader = rawHeaderOf(methodObj);
	if (isCogMethodReference(_rawHeader)) {
		_originalMethod = ((CogMethod *) _rawHeader );
		assert(((_originalMethod->blockSize)) == _size);
		assert(methodHeader == ((_originalMethod->methodHeader)));
	} else {
		rawHeaderOfput(methodObj, ((sqInt) method ));
	}
	(method->methodHeader = methodHeader);
	(method->selector = _selector);
	(method->cmNumArgs = argumentCountOfMethodHeader(methodHeader));
	if ((method->cmRefersToYoung = hasYoungReferent)) {
		addToYoungReferrers(method);
	}
	(method->cmUsageCount = initialMethodUsageCount());
	(method->cpicHasMNUCaseOrCMIsFullBlock) = 0;
	(method->cmUsesPenultimateLit = maxLitIndex >= ((literalCountOfMethodHeader(methodHeader)) - 2));
	(method->picUsage = 0);
	if (needsFrame) {
		if (!((((stackCheckLabel->address)) - ((sqInt) method )) <= MaxStackCheckOffset)) {
			error("too much code for stack check offset");
		}
	}
	(method->stackCheckOffset = ((needsFrame)
		 ? ((stackCheckLabel->address)) - ((sqInt) method )
		 : 0));
	assert((callTargetFromReturnAddress(backEnd, ((sqInt) method ) + missOffset)) == (methodAbortTrampolineFor((method->cmNumArgs))));
	assert(_size == (roundUpLength(_size)));
	return method;
}
/* Cogit>>#findBackwardBranch:IsBackwardBranch:Mcpc:Bcpc:MatchingBcpc: */
static sqInt NoDbgRegParms
findBackwardBranchIsBackwardBranchMcpcBcpcMatchingBcpc(BytecodeDescriptor *descriptor, sqInt _isBackwardBranchAndAnnotation, char *_mcpc, sqInt _bcpc, void *_targetBcpc)
{
	return (((_isBackwardBranchAndAnnotation & 1) && (((sqInt) _targetBcpc ) == _bcpc))
		 ? ((sqInt) _mcpc )
		 : 0);
}
/*	Machine code addresses map to the following bytecode for all bytecodes 
	except backward branches, where they map to the backward branch itself. 
	This is so that loops continue, rather than terminate prematurely. */
/* Cogit>>#find:IsBackwardBranch:Mcpc:Bcpc:MatchingMcpc: */
static sqInt NoDbgRegParms
findIsBackwardBranchMcpcBcpcMatchingMcpc(BytecodeDescriptor *_descriptor, sqInt _isBackwardBranchAndAnnotation, char *_mcpc, sqInt _bcpc, void *_targetMcpc)
{
	return ((_targetMcpc == _mcpc)
		 ? (((_descriptor == null) || (_isBackwardBranchAndAnnotation & 1))
			 ? _bcpc
			 : _bcpc + ((_descriptor->numBytes)))
		 : 0);
}
/*	Answer a fake value for the first method oop in the PIC prototype. 
	Since we use MoveUniqueCw:R: it must not be confused with a 
	method-relative address. */
/* Cogit>>#firstPrototypeMethodOop */
static sqInt
firstPrototypeMethodOop(void)
{
	return (((((usqInt) 99282957 ) >= ((methodLabel->address))) && (((usqInt) 99282957 ) < (youngReferrers())))
		 ? 212332557
		 : 99282957);
}
/* Cogit>>#fixupAt: */
static BytecodeFixup * NoDbgRegParms
fixupAt(sqInt _fixupPC)
{
	return fixupAtIndex(_fixupPC - initialPC);
}
/* Cogit>>#followForwardedLiteralsIn: */
void
followForwardedLiteralsIn(CogMethod *_cogMethod)
{
	sqInt _annotation;
	usqInt _map;
	sqInt _mapByte;
	sqInt _mcpc;
	sqInt _result;

	assert((((_cogMethod->cmType)) != CMMethod) || (!(isForwarded((_cogMethod->methodObject)))));
	/* begin enableCodeZoneWriteDuring: */
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		if (shouldRemapOop((_cogMethod->selector))) {
			(_cogMethod->selector = remapObj((_cogMethod->selector)));
			if (isYoung((_cogMethod->selector))) {
				ensureInYoungReferrers(_cogMethod);
			}
		}
		/* begin mapFor:performUntil:arg: */
		/* begin firstMappedPCFor: */
		_mcpc = (((_cogMethod->cpicHasMNUCaseOrCMIsFullBlock))
			 ? ((usqInt) _cogMethod ) + cbNoSwitchEntryOffset
			 : ((usqInt) _cogMethod ) + cmNoCheckEntryOffset);
		/* end firstMappedPCFor: */
		_map = (((usqInt) _cogMethod ) + ((_cogMethod->blockSize))) - 1;
		{
			enumeratingCogMethod = _cogMethod;
		}
		while (((_mapByte = byteAt(_map))) != MapEnd) {
			if (_mapByte >= FirstAnnotation) {
				_mcpc += (_mapByte & DisplacementMask) * 4;
				if ((((_annotation = ((usqInt) _mapByte ) >> AnnotationShift)) == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
					_annotation += _mapByte & DisplacementMask;
					_map -= 1;
				}
				_result = remapIfObjectRefpchasYoung(_annotation, ((char *) _mcpc ), 0);
				if (_result != 0) {
					goto l4;
				}
			} else {
				if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
					_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
				}
			}
			_map -= 1;
		}
		l4:
		;
		/* end mapFor:performUntil:arg: */
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	/* end enableCodeZoneWriteDuring: */
}
/* Cogit>>#followForwardedMethods */
void
followForwardedMethods(void)
{
	CogMethod *_cogMethod;
	sqInt _followed;
	int _freedPIC;

	_freedPIC = 0;
	_cogMethod = ((CogMethod *) methodZoneBase );
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		while (_cogMethod < (limitZony())) {
			if (isOopForwarded((_cogMethod->selector))) {
				_followed = followForwarded((_cogMethod->selector));
				(_cogMethod->selector = _followed);
				if (isYoung(_followed)) {
					ensureInYoungReferrers(_cogMethod);
				}
			}
			if (((_cogMethod->cmType)) == CMMethod) {
				if (isForwarded((_cogMethod->methodObject))) {
					(_cogMethod->methodObject = followForwarded((_cogMethod->methodObject)));
					if (isYoungObject(getMemoryMap(), (_cogMethod->methodObject))) {
						ensureInYoungReferrers(_cogMethod);
					}
				}
			}
			if (((_cogMethod->cmType)) == CMPolymorphicIC) {
				if (followMethodReferencesInClosedPIC(_cogMethod)) {
					_freedPIC = 1;
					freeMethod(_cogMethod);
				}
			}
			_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		}
		if (_freedPIC) {
			unlinkSendsToFree();
		}
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		if (codeModified) {
			flushICacheFromto(((usqInt) methodZoneBase ), ((usqInt) (limitZony()) ));
		}
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
}
/*	Follow a potential object reference from a closed PIC. 
	This may be a method reference or null. 
	Answer if the followed literal is young. 
	'mcpc' refers to the jump/branch instruction at the end of 
	each cpic case */
/* Cogit>>#followMaybeObjRefInClosedPICAt: */
static sqInt NoDbgRegParms
followMaybeObjRefInClosedPICAt(sqInt _mcpc)
{
	sqInt _object;
	sqInt _subject;

	_object = literalBeforeFollowingAddress(backEnd, _mcpc);
	if (!(couldBeObject(_object))) {
		return 0;
	}
	if (!(isForwarded(_object))) {
		return isYoungObject(getMemoryMap(), _object);
	}
	_subject = followForwarded(_object);
	storeLiteralbeforeFollowingAddress(backEnd, _subject, _mcpc);
	codeModified = 1;
	return isYoungObject(getMemoryMap(), _subject);
}
/*	Remap all object references in the closed PIC. Answer if any references 
	are young. 
	Set codeModified if any modifications are made. */
/* Cogit>>#followMethodReferencesInClosedPIC: */
static sqInt NoDbgRegParms
followMethodReferencesInClosedPIC(CogMethod *_cPIC)
{
	sqInt _i;
	sqInt _pc;
	sqInt _refersToYoung;

	_pc = addressOfEndOfCaseinCPIC(1, _cPIC);
	_refersToYoung = followMaybeObjRefInClosedPICAt(_pc - (jumpLongByteSize(backEnd)));
	_pc = addressOfEndOfCaseinCPIC((_cPIC->cPICNumCases), _cPIC);
	for (_i = 2; _i <= ((_cPIC->cPICNumCases)); _i += 1) {
		if (followMaybeObjRefInClosedPICAt((_pc - (jumpLongConditionalByteSize(backEnd))) - (cmpC32RTempByteSize(backEnd)))) {
			_refersToYoung = 1;
		}
		_pc += cPICCaseSize;
	}
	return _refersToYoung;
}
/*	Free machine-code methods whose compiled methods are unmarked 
	and open PICs whose selectors are not marked, and closed PICs that 
	refer to unmarked objects. */
/* Cogit>>#freeUnmarkedMachineCode */
void
freeUnmarkedMachineCode(void)
{
	CogMethod *_cogMethod;
	int _freedMethod;

	_freedMethod = 0;
	_cogMethod = ((CogMethod *) methodZoneBase );
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		while (_cogMethod < (limitZony())) {
			if ((((_cogMethod->cmType)) == CMMethod) && (!(isMarkedOrPermanent((_cogMethod->methodObject))))) {
				_freedMethod = 1;
				freeMethod(_cogMethod);
			}
			if ((((_cogMethod->cmType)) == CMMegamorphicIC) && ((!(isImmediate((_cogMethod->selector)))) && (!(isMarkedOrPermanent((_cogMethod->selector)))))) {
				_freedMethod = 1;
				freeMethod(_cogMethod);
			}
			if ((((_cogMethod->cmType)) == CMPolymorphicIC) && (closedPICRefersToUnmarkedObject(_cogMethod))) {
				_freedMethod = 1;
				freeMethod(_cogMethod);
			}
			_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		}
		if (_freedMethod) {
			unlinkSendsToFree();
		}
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		if (codeModified) {
			flushICacheFromto(((usqInt) methodZoneBase ), ((usqInt) (limitZony()) ));
		}
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
}
/*	Call ceSendMustBeBooleanTo: via the relevant trampoline. */
/* Cogit>>#genCallMustBeBooleanFor: */
static AbstractInstruction * NoDbgRegParms
genCallMustBeBooleanFor(sqInt _boolean)
{
	AbstractInstruction *_abstractInstruction;
	sqInt _callTarget;

	/* begin CallRT: */
	_callTarget = ((_boolean == (falseObject()))
		 ? ceSendMustBeBooleanAddFalseTrampoline
		 : ceSendMustBeBooleanAddTrueTrampoline);
	/* begin annotateCall: */
	_abstractInstruction = genoperand(Call, _callTarget);
	(_abstractInstruction->annotation = IsRelativeCall);
	return _abstractInstruction;
	/* end annotateCall: */
	/* end CallRT: */
}
/* Cogit>>#genCheckForInterruptsTrampoline */
static sqInt
genCheckForInterruptsTrampoline(void)
{
	sqInt _address;

	zeroOpcodeIndex();
	{
		/* begin MoveR:Aw: */
		_address = instructionPointerAddress();
		/* begin gen:operand:literal: */
		checkLiteralforInstruction(_address, genoperandoperand(MoveRAw, LinkReg, _address));
		/* end gen:operand:literal: */
		/* end MoveR:Aw: */
	}
	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(ceCheckForInterrupts, "ceCheckForInterruptsTrampoline", 0, null, null, null, null, 0, 0, NoReg, 1);
}
/* Cogit>>#genConditionalBranch:operand: */
static AbstractInstruction * NoDbgRegParms
genConditionalBranchoperand(sqInt _opcode, sqInt _operandOne)
{
	AbstractInstruction *_branch;

	/* begin noteFollowingConditionalBranch: */
	_branch = genoperand(_opcode, _operandOne);
	return _branch;
	/* end noteFollowingConditionalBranch: */
}
/*	An enilopmart (the reverse of a trampoline) is a piece of code that makes 
	the system-call-like transition from the C runtime into generated machine 
	code. The desired arguments and entry-point are pushed on a stackPage's 
	stack. The enilopmart pops off the values to be loaded into registers and 
	then executes a return instruction to pop off the entry-point and jump to 
	it.  
	BEFORE				AFTER			(stacks grow down) 
	whatever			stackPointer ->	whatever 
	target address =>	reg1 = reg1val, etc 
	reg1val				pc = target address 
	reg2val 
	stackPointer ->	reg3val */
/* Cogit>>#genEnilopmartFor:and:and:forCall:called: */
static void (*genEnilopmartForandandforCallcalled(sqInt _regArg1, sqInt _regArg2OrNone, sqInt _regArg3OrNone, sqInt _forCall, char *_trampolineName))(void)

{
	AbstractInstruction *_anInstruction;
	sqInt _endAddress;
	sqInt _enilopmart;
	sqInt _quickConstant;
	sqInt _size;

	zeroOpcodeIndex();
	{
		/* begin MoveCq:R: */
		_quickConstant = varBaseAddress();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, _quickConstant, VarBaseReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveCq:R: */
	}
	genLoadStackPointers(backEnd);
	if (_regArg3OrNone != NoReg) {
		genoperand(PopR, _regArg3OrNone);
	}
	if (_regArg2OrNone != NoReg) {
		genoperand(PopR, _regArg2OrNone);
	}
	genoperand(PopR, _regArg1);
	genEnilopmartReturn(_forCall);
	computeMaximumSizes();
	_size = generateInstructionsAt(methodZoneBase);
	_endAddress = outputInstructionsAt(methodZoneBase);
	assert((methodZoneBase + _size) == _endAddress);
	_enilopmart = methodZoneBase;
	methodZoneBase = alignUptoRoutineBoundary(_endAddress);
	stopsFromto(backEnd, _endAddress, methodZoneBase - 1);
	recordGeneratedRunTimeaddress(_trampolineName, _enilopmart);
	return ((void (*)(void)) _enilopmart );
}
/*	An enilopmart (the reverse of a trampoline) is a piece of code that makes 
	the system-call-like transition from the C runtime into generated machine 
	code. At the point the enilopmart enters machine code via a return 
	instruction, any argument registers have been loaded with their values and 
	the stack, if 
	for call, looks like 
	ret pc 
	stackPointer ->	target address 
	 
	and if not for call, looks like 
	whatever 
	stackPointer ->	target address 
	 
	If forCall and running on a CISC, ret pc must be left on the stack. If 
	forCall and 
	running on a RISC, ret pc must be popped into LinkReg. In either case, 
	target address must be removed from the stack and jumped/returned to. */
/* Cogit>>#genEnilopmartReturn: */
static void NoDbgRegParms
genEnilopmartReturn(sqInt _forCall)
{
	{
		if (_forCall) {
			genoperand(PopR, RISCTempReg);
			genoperand(PopR, LinkReg);
			genoperand(JumpR, RISCTempReg);
		} else {
			{
				genoperand(PopR, RISCTempReg);
				genoperand(JumpR, RISCTempReg);
			}
		}
	}
}
/*	Generate the routine that writes the current values of the C frame and 
	stack pointers into 
	variables. These are used to establish the C stack in trampolines back 
	into the C run-time. 
	 
	This is a presumptuous quick hack for x86. It is presumptuous for two 
	reasons. Firstly 
	the system's frame and stack pointers may differ from those we use in 
	generated code, 
	e.g. on register-rich RISCs. Secondly the ABI may not support a simple 
	frameless call 
	as written here (for example 128-bit stack alignment on Mac OS X). */
/* Cogit>>#generateCaptureCStackPointers: */
static void NoDbgRegParms
generateCaptureCStackPointers(sqInt _captureFramePointer)
{
	sqInt _startAddress;

	/* begin allocateOpcodes:bytecodes: */
	ensureAndClearAbstractOpcodes(32);
	zeroOpcodeIndexForNewOpcodes();
	labelCounter = 0;
	/* end allocateOpcodes:bytecodes: */
	_startAddress = methodZoneBase;
	genCaptureCStackPointers(backEnd, _captureFramePointer);
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		outputInstructionsForGeneratedRuntimeAt(_startAddress);
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		flushICacheFromto(((usqInt) _startAddress ), ((usqInt) methodZoneBase ));
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	recordGeneratedRunTimeaddress("ceCaptureCStackPointers", _startAddress);
	ceCaptureCStackPointers = ((void (*)(void)) _startAddress );
}
/*	Generate the prototype ClosedPIC to determine how much space as full PIC 
	takes. When we first allocate a closed PIC it only has one or two cases 
	and we want to grow it. 
	So we have to determine how big a full one is before hand. */
/* Cogit>>#generateClosedPICPrototype */
static void
generateClosedPICPrototype(void)
{
	AbstractInstruction * cPICEndOfCodeLabel;
	AbstractInstruction * endCPICCase1;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	CogMethod *_cPIC;
	sqInt _endAddress;
	sqInt _h;
	AbstractInstruction *_jumpNext;
	sqInt _jumpTarget;
	sqInt _jumpTarget2;
	sqInt _jumpTarget3;
	int _numArgs;
	sqInt _opcode;
	sqInt _operandOne;
	sqInt _wordConstant;
	sqInt _wordConstant2;

	/* begin allocateOpcodes:bytecodes: */
	ensureAndClearAbstractOpcodes(MaxCPICCases * 9);
	zeroOpcodeIndexForNewOpcodes();
	labelCounter = 0;
	/* end allocateOpcodes:bytecodes: */
	{
		(methodLabel->address = methodZoneBase);
		(methodLabel->dependent = null);
	}
	/* begin compilePolymorphicICPrototype */
	compilePICAbort((_numArgs = 0));
	_jumpNext = compileCPICEntry();
	/* begin MoveUniqueCw:R: */
	_wordConstant2 = firstPrototypeMethodOop();
	/* begin uniqueLiteral:forInstruction: */
	_anInstruction2 = genoperandoperand(MoveCwR, _wordConstant2, SendNumArgsReg);
	assert(usesOutOfLineLiteral(_anInstruction2));
	(_anInstruction2->dependent = allocateLiteral(_wordConstant2));
	/* end uniqueLiteral:forInstruction: */
	/* end MoveUniqueCw:R: */
	/* begin JumpLong: */
	_jumpTarget2 = (((methodZoneBase + (youngReferrers())) / 2) - 13262352) + 13262352;
	genoperand(JumpLong, _jumpTarget2);
	/* end JumpLong: */
	endCPICCase0 = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
	for (_h = 1; _h < MaxCPICCases; _h += 1) {
		if (_h == (MaxCPICCases - 1)) {
			jmpTarget(_jumpNext, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
		}
		/* begin MoveUniqueCw:R: */
		_wordConstant = (subsequentPrototypeMethodOop()) + _h;
		/* begin uniqueLiteral:forInstruction: */
		_anInstruction = genoperandoperand(MoveCwR, _wordConstant, SendNumArgsReg);
		assert(usesOutOfLineLiteral(_anInstruction));
		(_anInstruction->dependent = allocateLiteral(_wordConstant));
		/* end uniqueLiteral:forInstruction: */
		/* end MoveUniqueCw:R: */
		/* begin gen:literal:operand: */
		_opcode = CmpC32R;
		checkLiteralforInstruction(3133021973U + _h, genoperandoperand(_opcode, 3133021973U + _h, TempReg));
		/* end gen:literal:operand: */
		/* begin JumpLongZero: */
		_jumpTarget = ((((methodZoneBase + (youngReferrers())) / 2) - 13262352) + 13262352) + (_h * 16);
		genConditionalBranchoperand(JumpLongZero, ((sqInt) _jumpTarget ));
		/* end JumpLongZero: */
		if (_h == 1) {
			endCPICCase1 = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
		}
	}
	/* begin gen:literal:operand: */
	_operandOne = (methodLabel->address);
	checkLiteralforInstruction(_operandOne, genoperandoperand(MoveCwR, _operandOne, ClassReg));
	/* end gen:literal:operand: */
	/* begin JumpLong: */
	_jumpTarget3 = cPICMissTrampolineFor(_numArgs);
	genoperand(JumpLong, _jumpTarget3);
	/* end JumpLong: */
	cPICEndOfCodeLabel = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
	dumpLiterals(0);
	/* end compilePolymorphicICPrototype */
	computeMaximumSizes();
	_cPIC = ((CogMethod *) methodZoneBase );
	closedPICSize = (sizeof(CogMethod)) + (generateInstructionsAt(methodZoneBase + (sizeof(CogMethod))));
	/* begin enableCodeZoneWriteDuring: */
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		_endAddress = outputInstructionsAt(methodZoneBase + (sizeof(CogMethod)));
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	/* end enableCodeZoneWriteDuring: */
	assert((methodZoneBase + closedPICSize) == _endAddress);
	firstCPICCaseOffset = ((endCPICCase0->address)) - methodZoneBase;
	cPICEndOfCodeOffset = ((cPICEndOfCodeLabel->address)) - methodZoneBase;
	cPICCaseSize = ((endCPICCase1->address)) - ((endCPICCase0->address));
	cPICEndSize = closedPICSize - (((MaxCPICCases - 1) * cPICCaseSize) + firstCPICCaseOffset);
	closedPICSize = roundUpLength(closedPICSize);
	assert(((picInterpretAbort->address)) == (((methodLabel->address)) + (picInterpretAbortOffset())));
	/* begin enableCodeZoneWriteDuring: */
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		assert((expectedClosedPICPrototype(_cPIC)) == 0);
		storeLiteralbeforeFollowingAddress(backEnd, 0, ((endCPICCase0->address)) - (jumpLongByteSize(backEnd)));
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	/* end enableCodeZoneWriteDuring: */
	methodZoneBase = alignUptoRoutineBoundary(_endAddress);
	cPICPrototype = _cPIC;
}
/*	We handle jump sizing simply. First we make a pass that asks each 
	instruction to compute its maximum size. Then we make a pass that 
	sizes jumps based on the maxmimum sizes. Then we make a pass 
	that fixes up jumps. When fixing up a jump the jump is not allowed to 
	choose a smaller offset but must stick to the size set in the second pass. */
/* Cogit>>#generateCogFullBlock */
static CogMethod *
generateCogFullBlock(void)
{
	CogMethod *method;
	sqInt _codeSize;
	usqIntptr_t _headerSize;
	sqInt _mapSize;
	sqInt _result;
	usqInt _startAddress;
	sqInt _totalSize;

	_headerSize = sizeof(CogMethod);
	(methodLabel->address = freeStart());
	computeMaximumSizes();
	concretizeAt(methodLabel, freeStart());
	/* begin enableCodeZoneWriteDuring: */
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		_codeSize = generateInstructionsAt(((methodLabel->address)) + _headerSize);
		_mapSize = generateMapAtstart(null, ((methodLabel->address)) + cbNoSwitchEntryOffset);
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	/* end enableCodeZoneWriteDuring: */
	_totalSize = roundUpLength((_headerSize + _codeSize) + _mapSize);
	if (_totalSize > MaxMethodSize) {
		return ((CogMethod *) MethodTooBig );
	}
	_startAddress = allocate(_totalSize);
	if (_startAddress == 0) {
		return ((CogMethod *) InsufficientCodeSpace );
	}
	assert((_startAddress + cbEntryOffset) == ((fullBlockEntry->address)));
	assert((_startAddress + cbNoSwitchEntryOffset) == ((fullBlockNoContextSwitchEntry->address)));
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		_result = outputInstructionsAt(_startAddress + _headerSize);
		assert(((_startAddress + _headerSize) + _codeSize) == _result);
		padIfPossibleWithStopsFromto(backEnd, _result, ((_startAddress + _totalSize) - _mapSize) - 1);
		generateMapAtstart((_startAddress + _totalSize) - 1, _startAddress + cbNoSwitchEntryOffset);
		flag("TOCHECK");
		method = fillInMethodHeadersizeselector(((CogMethod *) _startAddress ), _totalSize, nilObject());
		(method->cpicHasMNUCaseOrCMIsFullBlock = 1);
		if (postCompileHook) {
			postCompileHook(method);
			postCompileHook = null;
		}
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		flushICacheFromto(((usqInt) method ), ((usqInt) method ) + _totalSize);
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	return method;
}
/*	We handle jump sizing simply. First we make a pass that asks each 
	instruction to compute its maximum size. Then we make a pass that 
	sizes jumps based on the maxmimum sizes. Then we make a pass 
	that fixes up jumps. When fixing up a jump the jump is not allowed to 
	choose a smaller offset but must stick to the size set in the second pass. */
/* Cogit>>#generateCogMethod: */
static CogMethod * NoDbgRegParms
generateCogMethod(sqInt _selector)
{
	CogMethod *method;
	sqInt _codeSize;
	usqIntptr_t _headerSize;
	sqInt _mapSize;
	sqInt _result;
	usqInt _startAddress;
	sqInt _totalSize;

	_headerSize = sizeof(CogMethod);
	(methodLabel->address = freeStart());
	computeMaximumSizes();
	concretizeAt(methodLabel, freeStart());
	/* begin enableCodeZoneWriteDuring: */
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		_codeSize = generateInstructionsAt(((methodLabel->address)) + _headerSize);
		_mapSize = generateMapAtstart(null, ((methodLabel->address)) + cmNoCheckEntryOffset);
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	/* end enableCodeZoneWriteDuring: */
	_totalSize = roundUpLength((_headerSize + _codeSize) + _mapSize);
	if (_totalSize > MaxMethodSize) {
		return ((CogMethod *) MethodTooBig );
	}
	_startAddress = allocate(_totalSize);
	if (_startAddress == 0) {
		return ((CogMethod *) InsufficientCodeSpace );
	}
	assert((_startAddress + cmEntryOffset) == ((entry->address)));
	assert((_startAddress + cmNoCheckEntryOffset) == ((noCheckEntry->address)));
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		_result = outputInstructionsAt(_startAddress + _headerSize);
		assert(((_startAddress + _headerSize) + _codeSize) == _result);
		padIfPossibleWithStopsFromto(backEnd, _result, ((_startAddress + _totalSize) - _mapSize) - 1);
		generateMapAtstart((_startAddress + _totalSize) - 1, _startAddress + cmNoCheckEntryOffset);
		method = fillInMethodHeadersizeselector(((CogMethod *) _startAddress ), _totalSize, _selector);
		if (postCompileHook) {
			postCompileHook(method);
			postCompileHook = null;
		}
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		flushICacheFromto(((usqInt) method ), ((usqInt) method ) + _totalSize);
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	return method;
}
/*	Generate the method map at addressrNull (or compute it if addressOrNull is 
	null). Answer the length of the map in byes. Each entry in the map is in 
	two parts. In the 
	least signficant bits are a displacement of how far from the start or 
	previous entry, 
	unless it is an IsAnnotationExtension byte, in which case those bits are 
	the extension. 
	In the most signficant bits are the type of annotation at the point 
	reached. A null 
	byte ends the map. */
/* Cogit>>#generateMapAt:start: */
static sqInt NoDbgRegParms
generateMapAtstart(usqInt _addressOrNull, usqInt _startAddress)
{
	unsigned char _annotation;
	sqInt _delta;
	sqInt _i;
	AbstractInstruction *_instruction;
	int _length;
	usqInt _location;
	sqInt _mapEntry;
	sqInt _maxDelta;
	usqInt _mcpc;

	_length = 0;
	_location = _startAddress;
	for (_i = 0; _i < opcodeIndex; _i += 1) {
		_instruction = abstractInstructionAt(_i);
		{
			_annotation = (_instruction->annotation);
			if (!(_annotation == null)) {
				/* begin assertValidAnnotation:for: */
				assert((_annotation != (getIsObjectReference())) || (((_instruction->opcode)) == Literal));
				/* end assertValidAnnotation:for: */
				_mcpc = ((((_instruction->opcode)) == Literal)
					 ? (_instruction->address)
					 : ((_instruction->address)) + ((_instruction->machineCodeSize)));
				while (((_delta = (_mcpc - _location) / 4)) > DisplacementMask) {
					_maxDelta = ((((_delta < MaxX2NDisplacement) ? _delta : MaxX2NDisplacement)) | DisplacementMask) - DisplacementMask;
					assert((((usqInt) _maxDelta ) >> AnnotationShift) <= DisplacementMask);
					if (_addressOrNull) {
						/* begin addToMap:instruction:byte:at:for: */
						byteAtput(_addressOrNull - _length, (((usqInt) _maxDelta ) >> AnnotationShift) + DisplacementX2N);
						/* end addToMap:instruction:byte:at:for: */
					}
					_location += _maxDelta * 4;
					_length += 1;
				}
				if (_addressOrNull) {
					_mapEntry = _delta + ((sqInt) (((usqInt) (((_annotation < IsSendCall) ? _annotation : IsSendCall)) ) << AnnotationShift) );
					/* begin addToMap:instruction:byte:at:for: */
					byteAtput(_addressOrNull - _length, _mapEntry);
					/* end addToMap:instruction:byte:at:for: */
				}
				_location += _delta * 4;
				_length += 1;
				if (_annotation > IsSendCall) {
					if (_addressOrNull) {
						_mapEntry = ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) ) + (_annotation - IsSendCall);
						/* begin addToMap:instruction:byte:at:for: */
						byteAtput(_addressOrNull - _length, _mapEntry);
						/* end addToMap:instruction:byte:at:for: */
					}
					_length += 1;
				}
			}
		}
	}
	if (_addressOrNull) {
		/* begin addToMap:instruction:byte:at:for: */
		byteAtput(_addressOrNull - _length, MapEnd);
		/* end addToMap:instruction:byte:at:for: */
	}
	return _length + 1;
}
/*	Generate the prototype ClosedPIC to determine how much space as full PIC 
	takes. When we first allocate a closed PIC it only has one or two cases 
	and we want to grow it. 
	So we have to determine how big a full one is before hand.stack allocate the various collections so that they 
	are effectively garbage collected on return. */
/* Cogit>>#generateOpenPICPrototype */
static void
generateOpenPICPrototype(void)
{
	sqInt _codeSize;
	sqInt _mapSize;

	/* begin allocateOpcodes:bytecodes: */
	ensureAndClearAbstractOpcodes(100);
	zeroOpcodeIndexForNewOpcodes();
	labelCounter = 0;
	/* end allocateOpcodes:bytecodes: */
	{
		(methodLabel->address = methodZoneBase);
		(methodLabel->dependent = null);
	}
	compileOpenPICnumArgs(specialSelector(0), 2);
	computeMaximumSizes();
	concretizeAt(methodLabel, methodZoneBase);
	/* begin enableCodeZoneWriteDuring: */
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		_codeSize = generateInstructionsAt(methodZoneBase + (sizeof(CogMethod)));
		_mapSize = generateMapAtstart(null, methodZoneBase + cmNoCheckEntryOffset);
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	/* end enableCodeZoneWriteDuring: */
	openPICSize = (roundUpLength((sizeof(CogMethod)) + _codeSize)) + (roundUpLength(_mapSize));
}
/* Cogit>>#generateReturnToInterpreterPCTrampoline */
static void
generateReturnToInterpreterPCTrampoline(void)
{
	ceReturnToInterpreterTrampoline = genReturnTrampolineForcalledarg(ceReturnToInterpreter, "ceReturnToInterpreterTrampoline", ReceiverResultReg);
}
/*	Generate the run-time entries at the base of the native code zone and 
	update the base. */
/* Cogit>>#generateRunTimeTrampolines */
static void
generateRunTimeTrampolines(void)
{
	sqInt ceFreeTrampoline;
	sqInt ceMallocTrampoline;

	ceSendMustBeBooleanAddFalseTrampoline = genMustBeBooleanTrampolineForcalled(falseObject(), "ceSendMustBeBooleanAddFalseTrampoline");
	ceSendMustBeBooleanAddTrueTrampoline = genMustBeBooleanTrampolineForcalled(trueObject(), "ceSendMustBeBooleanAddTrueTrampoline");
	ceNonLocalReturnTrampoline = genNonLocalReturnTrampoline();
	ceCheckForInterruptTrampoline = genCheckForInterruptsTrampoline();
	ceFetchContextInstVarTrampoline = genTrampolineForcalledargargresult(ceContextinstVar, "ceFetchContextInstVarTrampoline", ReceiverResultReg, SendNumArgsReg, SendNumArgsReg);
	ceStoreContextInstVarTrampoline = genTrampolineForcalledargargargresult(ceContextinstVarvalue, "ceStoreContextInstVarTrampoline", ReceiverResultReg, SendNumArgsReg, ClassReg, ReceiverResultReg);
	ceCannotResumeTrampoline = genTrampolineForcalled(ceCannotResume, "ceCannotResumeTrampoline");
	ceBaseFrameReturnTrampoline = genReturnTrampolineForcalledarg(ceBaseFrameReturn, "ceBaseFrameReturnTrampoline", ReceiverResultReg);
	generateReturnToInterpreterPCTrampoline();
	ceMallocTrampoline = genTrampolineForcalledargresult(ceMalloc, "ceMallocTrampoline", ReceiverResultReg, TempReg);
	ceFreeTrampoline = genTrampolineForcalledarg(ceFree, "ceFreeTrampoline", ReceiverResultReg);
}
/*	Generate a routine ceCaptureCStackPointers that will capture the C stack 
	pointer, and, if it is in use, the C frame pointer. These are used in 
	trampolines to call 
	run-time routines in the interpreter from machine-code. */
/* Cogit>>#generateStackPointerCapture */
static void
generateStackPointerCapture(void)
{
	sqInt _oldMethodZoneBase;
	sqInt _oldTrampolineTableIndex;

	cFramePointerInUse = 0;
	assertCStackWellAligned();
	_oldMethodZoneBase = methodZoneBase;
	_oldTrampolineTableIndex = trampolineTableIndex;
	generateCaptureCStackPointers(1);
	ceCaptureCStackPointers();
	if (!((cFramePointerInUse = checkCFramePointerInUse()))) {
		methodZoneBase = _oldMethodZoneBase;
		trampolineTableIndex = _oldTrampolineTableIndex;
		generateCaptureCStackPointers(0);
	}
	assertCStackWellAligned();
}
/*	Generate the run-time entries and exits at the base of the native code 
	zone and update the base. 
	Read the class-side method trampolines for documentation on the various 
	trampolines  */
/* Cogit>>#generateTrampolines */
static void
generateTrampolines(void)
{
	sqInt _methodZoneStart;

	_methodZoneStart = methodZoneBase;
	(methodLabel->address = _methodZoneStart);
	/* begin allocateOpcodes:bytecodes: */
	ensureAndClearAbstractOpcodes(80);
	zeroOpcodeIndexForNewOpcodes();
	labelCounter = 0;
	/* end allocateOpcodes:bytecodes: */
	hasYoungReferent = 0;
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		maybeGenerateSelectorIndexDereferenceRoutine();
		generateSendTrampolines();
		generateMissAbortTrampolines();
		generateObjectRepresentationTrampolines();
		generateRunTimeTrampolines();
		generateEnilopmarts();
		generateTracingTrampolines();
		recordGeneratedRunTimeaddress("methodZoneBase", methodZoneBase);
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		flushICacheFromto(((usqInt) _methodZoneStart ), ((usqInt) methodZoneBase ));
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
}
/* Cogit>>#generatorForPC: */
static BytecodeDescriptor * NoDbgRegParms
generatorForPC(sqInt _pc)
{
	return generatorAt(fetchByteofObject(_pc, methodObj));
}
/*	Generate a routine that answers the stack pointer immedately 
	after a leaf call, used for checking stack pointer alignment. */
/* Cogit>>#genGetLeafCallStackPointer */
static void
genGetLeafCallStackPointer(void)
{
	sqInt _startAddress;

	/* begin allocateOpcodes:bytecodes: */
	ensureAndClearAbstractOpcodes(4);
	zeroOpcodeIndexForNewOpcodes();
	labelCounter = 0;
	/* end allocateOpcodes:bytecodes: */
	_startAddress = methodZoneBase;
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, FPReg, R0);
		/* end MoveR:R: */
		genoperand(RetN, 0);
	}
	outputInstructionsForGeneratedRuntimeAt(_startAddress);
	recordGeneratedRunTimeaddress("ceGetFP", _startAddress);
	ceGetFP = ((usqIntptr_t (*)(void)) _startAddress );
	_startAddress = methodZoneBase;
	zeroOpcodeIndex();
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, SPReg, R0);
	/* end MoveR:R: */
	genoperand(RetN, 0);
	outputInstructionsForGeneratedRuntimeAt(_startAddress);
	recordGeneratedRunTimeaddress("ceGetSP", _startAddress);
	ceGetSP = ((usqIntptr_t (*)(void)) _startAddress );
}
/*	Generate the abort for a PIC. This abort performs either a call of 
	ceInterpretMethodFromPIC:receiver: to handle invoking an uncogged target 
	or a call of ceMNUFromPICMNUMethod:receiver: to handle an MNU dispatch 
	in a closed PIC. It distinguishes the two by testing ClassReg. If the 
	register is zero then this is an MNU. 
	 
	This poses a problem in 32-bit Spur, where zero is the cache tag for 
	immediate characters (tag pattern 2r10) because SmallIntegers have tag 
	patterns 2r11 
	and 2r01, so anding with 1 reduces these to 0 & 1. We solve the ambiguity 
	by patching send sites with a 0 cache tag to open PICs instead of closed 
	PICs.  */
/* Cogit>>#genInnerPICAbortTrampoline: */
static sqInt NoDbgRegParms
genInnerPICAbortTrampoline(char *_name)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_jumpMNUCase;

	/* begin CmpCq:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(CmpCqR, 0, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	_jumpMNUCase = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	compileTrampolineFornumArgsargargargargregsToSavepushLinkRegresultReg(ceInterpretMethodFromPICreceiver, 2, SendNumArgsReg, ReceiverResultReg, null, null, 0, 0, NoReg);
	jmpTarget(_jumpMNUCase, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(ceMNUFromPICMNUMethodreceiver, _name, 2, SendNumArgsReg, ReceiverResultReg, null, null, 0, 0, NoReg, 1);
}
/* Cogit>>#genLoadCStackPointersForPrimCall */
static sqInt
genLoadCStackPointersForPrimCall(void)
{
	sqInt _address;
	sqInt _address2;
	sqInt _address3;
	AbstractInstruction *_anInstruction;
	sqInt _reg;
	sqInt _reg2;

	if (debugPrimCallStackOffset == 0) {
		/* begin MoveAw:R: */
		_address = cStackPointerAddress();
		_reg = cStackPointer(backEnd);
		/* begin gen:literal:operand: */
		checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, _reg));
		/* end gen:literal:operand: */
		/* end MoveAw:R: */
	} else {
		/* begin MoveAw:R: */
		_address2 = cStackPointerAddress();
		/* begin gen:literal:operand: */
		checkLiteralforInstruction(_address2, genoperandoperand(MoveAwR, _address2, TempReg));
		/* end gen:literal:operand: */
		/* end MoveAw:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(SubCqR, debugPrimCallStackOffset, TempReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(debugPrimCallStackOffset));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin MoveR:R: */
		_reg2 = cStackPointer(backEnd);
		genoperandoperand(MoveRR, TempReg, _reg2);
		/* end MoveR:R: */
	}
	if (cFramePointerInUse) {
		/* begin MoveAw:R: */
		_address3 = cFramePointerAddress();
		/* begin gen:literal:operand: */
		checkLiteralforInstruction(_address3, genoperandoperand(MoveAwR, _address3, FPReg));
		/* end gen:literal:operand: */
		/* end MoveAw:R: */
	}
	return 0;
}
/*	The in-line cache for a send is implemented as a constant load into 
	ClassReg. We always use a 32-bit load, even in 64-bits. 
	 
	In the initial (unlinked) state the in-line cache is notionally loaded 
	with the selector. 
	But since in 64-bits an arbitrary selector oop won't fit in a 32-bit 
	constant load, we 
	instead load the cache with the selector's index, either into the literal 
	frame of the 
	current method, or into the special selector array. Negative values are 
	1-relative indices into the special selector array. 
	 
	When a send is linked, the load of the selector, or selector index, is 
	overwritten with a 
	load of the receiver's class, or class tag. Hence, the 64-bit VM is 
	currently constrained 
	to use class indices as cache tags. If out-of-line literals are used, 
	distinct caches /must 
	not/ share acche locations, for if they do, send cacheing will be confused 
	by the sharing. 
	Hence we use the MoveUniqueC32:R: instruction that will not share literal 
	locations.  */
/* Cogit>>#genLoadInlineCacheWithSelector: */
static void NoDbgRegParms
genLoadInlineCacheWithSelector(sqInt _selectorIndex)
{
	AbstractInstruction *_anInstruction;
	sqInt _cacheValue;

	assert(((_selectorIndex < 0)
		 ? (-_selectorIndex >= 1) && (-_selectorIndex <= (numSpecialSelectors()))
		 : (_selectorIndex >= 0) && (_selectorIndex <= ((literalCountOf(methodObj)) - 1))));
	{
		_cacheValue = _selectorIndex;
	}
	/* begin uniqueLiteral:forInstruction: */
	_anInstruction = genoperandoperand(MovePatcheableC32R, _cacheValue, ClassReg);
	assert(usesOutOfLineLiteral(_anInstruction));
	(_anInstruction->dependent = allocateLiteral(_cacheValue));
	/* end uniqueLiteral:forInstruction: */
}
/* Cogit>>#genNonLocalReturnTrampoline */
static sqInt
genNonLocalReturnTrampoline(void)
{
	sqInt _address;

	zeroOpcodeIndex();
	{
		/* begin MoveR:Aw: */
		_address = instructionPointerAddress();
		/* begin gen:operand:literal: */
		checkLiteralforInstruction(_address, genoperandoperand(MoveRAw, LinkReg, _address));
		/* end gen:operand:literal: */
		/* end MoveR:Aw: */
	}
	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(ceNonLocalReturn, "ceNonLocalReturnTrampoline", 1, ReceiverResultReg, null, null, null, 0, 0, NoReg, 1);
}
/*	Generate a trampoline for a routine used as a return address, that has one 
	argument. Hack: a negative value indicates an abstract register, a 
	non-negative value indicates a constant. */
/* Cogit>>#genReturnTrampolineFor:called:arg: */
static sqInt NoDbgRegParms
genReturnTrampolineForcalledarg(void *_aRoutine, char *_aString, sqInt _regOrConst0)
{
	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(_aRoutine, _aString, 1, _regOrConst0, null, null, null, 0, 0, NoReg, 0);
}
/*	If the client requires, then on an ARM-like RISC processor, the return 
	address needs to 
	be pushed to the stack so that the interpreter sees the same stack layout 
	as on CISC. */
/* Cogit>>#genSmalltalkToCStackSwitch: */
static sqInt NoDbgRegParms
genSmalltalkToCStackSwitch(sqInt _pushLinkReg)
{
	if (_pushLinkReg) {
		genoperand(PushR, LinkReg);
	}
	genSaveStackPointers(backEnd);
	if (cFramePointerInUse) {
		genLoadCStackPointers(backEnd);
	}
 else {
		genLoadCStackPointer(backEnd);
	}
	return 0;
}
/*	Generate a trampoline with no arguments */
/* Cogit>>#genTrampolineFor:called: */
static sqInt NoDbgRegParms
genTrampolineForcalled(void *_aRoutine, char *_aString)
{
	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(_aRoutine, _aString, 0, null, null, null, null, 0, 1, NoReg, 0);
}
/*	Generate a trampoline with one argument. 
	Hack: a negative value indicates an abstract register, a non-negative 
	value indicates a constant. */
/* Cogit>>#genTrampolineFor:called:arg: */
static sqInt NoDbgRegParms
genTrampolineForcalledarg(void *_aRoutine, char *_aString, sqInt _regOrConst0)
{
	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(_aRoutine, _aString, 1, _regOrConst0, null, null, null, 0, 1, NoReg, 0);
}
/*	Generate a trampoline with two arguments that answers a result. 
	Hack: a negative value indicates an abstract register, a non-negative 
	value indicates a constant. */
/* Cogit>>#genTrampolineFor:called:arg:arg:arg:result: */
static sqInt NoDbgRegParms
genTrampolineForcalledargargargresult(void *_aRoutine, char *_aString, sqInt _regOrConst0, sqInt _regOrConst1, sqInt _regOrConst2, sqInt _resultReg)
{
	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(_aRoutine, _aString, 3, _regOrConst0, _regOrConst1, _regOrConst2, null, 0, 1, _resultReg, 0);
}
/*	Generate a trampoline with two arguments. 
	Hack: a negative value indicates an abstract register, a non-negative 
	value indicates a constant. */
/* Cogit>>#genTrampolineFor:called:arg:arg:regsToSave: */
static sqInt NoDbgRegParms
genTrampolineForcalledargargregsToSave(void *_aRoutine, char *_aString, sqInt _regOrConst0, sqInt _regOrConst1, sqInt _regMask)
{
	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(_aRoutine, _aString, 2, _regOrConst0, _regOrConst1, null, null, _regMask, 1, NoReg, 0);
}
/*	Generate a trampoline with two arguments that answers a result. 
	Hack: a negative value indicates an abstract register, a non-negative 
	value indicates a constant. */
/* Cogit>>#genTrampolineFor:called:arg:arg:result: */
static sqInt NoDbgRegParms
genTrampolineForcalledargargresult(void *_aRoutine, char *_aString, sqInt _regOrConst0, sqInt _regOrConst1, sqInt _resultReg)
{
	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(_aRoutine, _aString, 2, _regOrConst0, _regOrConst1, null, null, 0, 1, _resultReg, 0);
}
/*	Generate a trampoline with one argument. 
	Hack: a negative value indicates an abstract register, a non-negative 
	value indicates a constant. */
/* Cogit>>#genTrampolineFor:called:arg:regsToSave: */
static sqInt NoDbgRegParms
genTrampolineForcalledargregsToSave(void *_aRoutine, char *_aString, sqInt _regOrConst0, sqInt _regMask)
{
	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(_aRoutine, _aString, 1, _regOrConst0, null, null, null, _regMask, 1, NoReg, 0);
}
/*	Generate a trampoline with one argument that answers a result. 
	Hack: a negative value indicates an abstract register, a non-negative 
	value indicates a constant. */
/* Cogit>>#genTrampolineFor:called:arg:result: */
static sqInt NoDbgRegParms
genTrampolineForcalledargresult(void *_aRoutine, char *_aString, sqInt _regOrConst0, sqInt _resultReg)
{
	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(_aRoutine, _aString, 1, _regOrConst0, null, null, null, 0, 1, _resultReg, 0);
}
/*	Generate a trampoline with up to four arguments. Generate either a call or 
	a jump to aRoutineOrNil 
	as requested by callJumpBar. If generating a call and resultRegOrNone is 
	not NoReg pass the C result 
	back in resultRegOrNone. 
	Hack: a negative value indicates an abstract register, a non-negative 
	value indicates a constant. */
/* Cogit>>#genTrampolineFor:called:numArgs:arg:arg:arg:arg:regsToSave:pushLinkReg:resultReg:appendOpcodes: */
static sqInt NoDbgRegParms
genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(void *_aRoutine, char *_trampolineName, sqInt _numArgs, sqInt _regOrConst0, sqInt _regOrConst1, sqInt _regOrConst2, sqInt _regOrConst3, sqInt _regMask, sqInt _pushLinkReg, sqInt _resultRegOrNone, sqInt _appendBoolean)
{
	sqInt _startAddress;

	_startAddress = methodZoneBase;
	if (!_appendBoolean) {
		zeroOpcodeIndex();
	}
	compileTrampolineFornumArgsargargargargregsToSavepushLinkRegresultReg(_aRoutine, _numArgs, _regOrConst0, _regOrConst1, _regOrConst2, _regOrConst3, _regMask, _pushLinkReg, _resultRegOrNone);
	outputInstructionsForGeneratedRuntimeAt(_startAddress);
	recordGeneratedRunTimeaddress(_trampolineName, _startAddress);
	recordRunTimeObjectReferences();
	return _startAddress;
}
/*	Generate a trampoline with no arguments */
/* Cogit>>#genTrampolineFor:called:regsToSave: */
static sqInt NoDbgRegParms
genTrampolineForcalledregsToSave(void *_aRoutine, char *_aString, sqInt _regMask)
{
	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(_aRoutine, _aString, 0, null, null, null, null, _regMask, 1, NoReg, 0);
}
/*	<Integer> */
/* Cogit>>#gen: */
static AbstractInstruction * NoDbgRegParms
gen(sqInt _opcode)
{
	AbstractInstruction *_abstractInstruction;

	assert(opcodeIndex < numAbstractOpcodes);
	_abstractInstruction = abstractInstructionAt(opcodeIndex);
	opcodeIndex += 1;
	(_abstractInstruction->opcode = _opcode);
	return _abstractInstruction;
}
/*	<Integer|CogAbstractInstruction> */
/* Cogit>>#gen:operand: */
static AbstractInstruction * NoDbgRegParms
genoperand(sqInt _opcode, sqInt _operand)
{
	AbstractInstruction *_abstractInstruction;

	assert(opcodeIndex < numAbstractOpcodes);
	_abstractInstruction = abstractInstructionAt(opcodeIndex);
	opcodeIndex += 1;
	(_abstractInstruction->opcode = _opcode);
	(_abstractInstruction->operands)[0] = _operand;
	return _abstractInstruction;
}
/*	<Integer|CogAbstractInstruction> */
/* Cogit>>#gen:operand:operand: */
static AbstractInstruction * NoDbgRegParms
genoperandoperand(sqInt _opcode, sqInt _operandOne, sqInt _operandTwo)
{
	AbstractInstruction *_abstractInstruction;

	assert(opcodeIndex < numAbstractOpcodes);
	_abstractInstruction = abstractInstructionAt(opcodeIndex);
	opcodeIndex += 1;
	(_abstractInstruction->opcode = _opcode);
	(_abstractInstruction->operands)[0] = _operandOne;
	(_abstractInstruction->operands)[1] = _operandTwo;
	return _abstractInstruction;
}
/*	<Integer|CogAbstractInstruction> */
/* Cogit>>#gen:operand:operand:operand: */
static AbstractInstruction * NoDbgRegParms
genoperandoperandoperand(sqInt _opcode, sqInt _operandOne, sqInt _operandTwo, sqInt _operandThree)
{
	AbstractInstruction *_abstractInstruction;

	assert(opcodeIndex < numAbstractOpcodes);
	_abstractInstruction = abstractInstructionAt(opcodeIndex);
	opcodeIndex += 1;
	(_abstractInstruction->opcode = _opcode);
	(_abstractInstruction->operands)[0] = _operandOne;
	(_abstractInstruction->operands)[1] = _operandTwo;
	(_abstractInstruction->operands)[2] = _operandThree;
	return _abstractInstruction;
}
/*	<Integer|CogAbstractInstruction> */
/* Cogit>>#gen:operand:operand:operand:operand: */
static AbstractInstruction * NoDbgRegParms
genoperandoperandoperandoperand(sqInt _opcode, sqInt _operandOne, sqInt _operandTwo, sqInt _operandThree, sqInt _operandFour)
{
	AbstractInstruction *_abstractInstruction;

	assert(opcodeIndex < numAbstractOpcodes);
	_abstractInstruction = abstractInstructionAt(opcodeIndex);
	opcodeIndex += 1;
	(_abstractInstruction->opcode = _opcode);
	(_abstractInstruction->operands)[0] = _operandOne;
	(_abstractInstruction->operands)[1] = _operandTwo;
	(_abstractInstruction->operands)[2] = _operandThree;
	(_abstractInstruction->operands)[3] = _operandFour;
	return _abstractInstruction;
}
/* Cogit>>#getBlockCompilationCount */
sqInt
getBlockCompilationCount(void)
{
	return ((((usqInt) statCompileFullBlockCount ) << 3) | 1);
}
/* Cogit>>#getBlockCompilationMSecs */
sqInt
getBlockCompilationMSecs(void)
{
	return ((((usqInt) ((statCompileFullBlockUsecs + 500) / 1000) ) << 3) | 1);
}
/* Cogit>>#getLiteral: */
static sqInt NoDbgRegParms
getLiteral(sqInt _litIndex)
{
	if (maxLitIndex < _litIndex) {
		maxLitIndex = _litIndex;
	}
	return literalofMethod(_litIndex, methodObj);
}
/* Cogit>>#getMethodCompilationCount */
sqInt
getMethodCompilationCount(void)
{
	return ((((usqInt) statCompileMethodCount ) << 3) | 1);
}
/* Cogit>>#getMethodCompilationMSecs */
sqInt
getMethodCompilationMSecs(void)
{
	return ((((usqInt) ((statCompileMethodUsecs + 500) / 1000) ) << 3) | 1);
}
/*	Access for the literal manager. */
/* Cogit>>#getOpcodeIndex */
static sqInt
getOpcodeIndex(void)
{
	return opcodeIndex;
}
/* Cogit>>#incrementUsageOfTargetIfLinkedSend:mcpc:ignored: */
static sqInt NoDbgRegParms
incrementUsageOfTargetIfLinkedSendmcpcignored(sqInt _annotation, char *_mcpc, sqInt superfluity)
{
	sqInt _entryPoint;
	sqInt _offset2;
	CogMethod * _targetCogCode;

	if (_annotation >= IsSendCall) {
		_entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt) _mcpc ));
		if (_entryPoint > methodZoneBase) {
			/* begin targetMethodAndSendTableFor:annotation:into: */
			/* begin offsetAndSendTableFor:annotation:into: */
			if (_annotation == IsSendCall) {
				_offset2 = cmEntryOffset;
			} else {
				if (_annotation == IsDirectedSuperSend) {
					_offset2 = cmNoCheckEntryOffset;
				} else {
					if (_annotation == IsDirectedSuperBindingSend) {
						_offset2 = cmNoCheckEntryOffset;
					} else {
						assert(_annotation == IsSuperSend);
						_offset2 = cmNoCheckEntryOffset;
					}
				}
			}
			{
				_targetCogCode = ((CogMethod *) (_entryPoint - _offset2) );
				{
					if (((_targetCogCode->cmUsageCount)) < (CMMaxUsageCount / 2)) {
						(_targetCogCode->cmUsageCount = ((_targetCogCode->cmUsageCount)) + 1);
					}
				}
			}
			/* end offsetAndSendTableFor:annotation:into: */
			/* end targetMethodAndSendTableFor:annotation:into: */
		}
	}
	return 0;
}
/*	Answer the value to put in an inline-cache that is being loaded with the 
	selector. Usually this is simply the selector, but in 64-bits the cache is 
	only 32-bits wide 
	and so the cache is loaded with the index of the selector. */
/* Cogit>>#indexForSelector:in:at: */
static sqInt NoDbgRegParms
indexForSelectorinat(sqInt _selector, CogMethod *_cogMethod, sqInt _mcpc)
{
	sqInt _aSpecialSelector;
	sqInt _i;
	sqInt _iLimit;
	sqInt _methodLiteral;
	sqInt _methodOop;

	assert(!(isOopForwarded(_selector)));
	assert((((usqInt) _mcpc ) > ((usqInt) _cogMethod )) && (_mcpc < (((usqInt) _cogMethod ) + ((_cogMethod->blockSize)))));
	for (_i = 0; _i < NumSpecialSelectors; _i += 1) {
		_aSpecialSelector = specialSelector(_i);
		if (isOopForwarded(_aSpecialSelector)) {
			_aSpecialSelector = followForwarded(_aSpecialSelector);
		}
		if (_selector == _aSpecialSelector) {
			return -1 - _i;
		}
	}
	_methodOop = (_cogMethod->methodObject);
	for (_i = LiteralStart, _iLimit = literalCountOfMethodHeader((_cogMethod->methodHeader)); _i <= _iLimit; _i += 1) {
		_methodLiteral = longAt(((_i * BytesPerOop) + BaseHeaderSize) + _methodOop);
		if (isOopForwarded(_methodLiteral)) {
			_methodLiteral = followForwarded(_methodLiteral);
			longAtput(((_i * BytesPerOop) + BaseHeaderSize) + _methodOop, _methodLiteral);
		}
		if (_methodLiteral == _selector) {
			assert(_selector == (literalofMethod(_i - 1, _methodOop)));
			return _i - 1;
		}
	}
	error("could not find selector in method when unlinking send site");
	return 0;
}
/*	Answer a usage count that reflects likely long-term usage. */
/* Cogit>>#initialClosedPICUsageCount */
static sqInt
initialClosedPICUsageCount(void)
{
	return CMMaxUsageCount / 2;
}
/* Cogit>>#initializeBackend */
static void
initializeBackend(void)
{
	AbstractInstruction *_existingInst;
	sqInt _i;
	sqInt _iLimit;
	AbstractInstruction *_newInst;
	AbstractInstruction *_newLiterals;

	(methodLabel->machineCodeSize = 0);
	(methodLabel->opcode = Label);
	(methodLabel->operands)[0] = 0;
	(methodLabel->operands)[1] = 0;
	{
		assert(((registerMaskFor(VarBaseReg)) & CallerSavedRegisterMask) == 0);
	}
	{
		/* begin allocateLiterals: */
		if (4 > literalsSize) {
			_newLiterals = calloc(4, sizeof(CogAbstractInstruction));
			if (literals) {
				for (_i = 0; _i < nextLiteralIndex; _i += 1) {
					_existingInst = literalInstructionAt(_i);
					_newInst = &(_newLiterals[_i]);
					cloneLiteralFrom(_newInst, _existingInst);
					assert(((_existingInst->dependent)) == null);
					(_existingInst->dependent = _newInst);
				}
				for (_i = 0, _iLimit = opcodeIndex - 1; _i <= _iLimit; _i += 1) {
					_existingInst = abstractInstructionAt(_i);
					if ((((_existingInst->dependent)) != null) && (((((_existingInst->dependent))->opcode)) == Literal)) {
						(_existingInst->dependent = (((_existingInst->dependent))->dependent));
					}
				}
			}
			free(literals);
			literals = _newLiterals;
			literalsSize = 4;
		}
		/* end allocateLiterals: */
		/* begin resetLiterals */
		firstOpcodeIndex = 1U << 16;
		nextLiteralIndex = (lastDumpedLiteralIndex = 0);
		/* end resetLiterals */
	}
}
/* Cogit>>#initializeCodeZoneFrom:upTo: */
void
initializeCodeZoneFromupTo(sqInt _startAddress, sqInt _endAddress)
{
	initializeBackend();
	/* begin enableCodeZoneWriteDuring: */
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		stopsFromto(backEnd, _startAddress, _endAddress - 1);
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	/* end enableCodeZoneWriteDuring: */
	/* begin simulationOnly: */
	/* end simulationOnly: */
	codeBase = (methodZoneBase = _startAddress);
	minValidCallAddress = (((((codeBase < (interpretAddress())) ? codeBase : interpretAddress())) < (primitiveFailAddress())) ? ((codeBase < (interpretAddress())) ? codeBase : interpretAddress()) : primitiveFailAddress());
	manageFromto(methodZoneBase, _endAddress);
	/* begin enableCodeZoneWriteDuring: */
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		/* begin maybeGenerateCheckFeatures */
		/* end maybeGenerateCheckFeatures */
		/* begin maybeGenerateICacheFlush */
		/* end maybeGenerateICacheFlush */
		genGetLeafCallStackPointer();
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	/* end enableCodeZoneWriteDuring: */
	generateStackPointerCapture();
	generateTrampolines();
	computeEntryOffsets();
	computeFullBlockEntryOffsets();
	generateClosedPICPrototype();
	manageFromto(methodZoneBase, _endAddress);
	generateOpenPICPrototype();
}
/* Cogit>>#initializePIC:atDelta:numArgs: */
static void NoDbgRegParms
initializePICatDeltanumArgs(CogMethod *_aPIC, sqInt _addrDelta, sqInt _numArgs)
{
	memcpy(_aPIC, ((CogMethod *) cPICPrototype ), closedPICSize);
	rewriteCallAttarget(backEnd, ((sqInt) _aPIC ) + missOffset, picAbortTrampolineFor(_numArgs));
	relocateMethodReferenceBeforeAddressby(backEnd, (((sqInt) _aPIC ) + cPICEndOfCodeOffset) - (jumpLongByteSize(backEnd)), _addrDelta);
	rewriteJumpLongAttarget(backEnd, ((sqInt) _aPIC ) + cPICEndOfCodeOffset, cPICMissTrampolineFor(_numArgs));
}
/*	Answer a usage count that reflects likely long-term usage. 
	Answer 1 for non-primitives or quick primitives (inst var accessors), 
	2 for methods with interpreter primitives, and 3 for compiled primitives. */
/* Cogit>>#initialMethodUsageCount */
static sqInt
initialMethodUsageCount(void)
{
	if ((primitiveIndex == 1) || (isQuickPrimitiveIndex(primitiveIndex))) {
		return 1;
	}
	if (!(((primitiveDescriptor())->primitiveGenerator))) {
		return 2;
	}
	return 3;
}
/*	Answer a usage count that reflects likely long-term usage. */
/* Cogit>>#initialOpenPICUsageCount */
static sqInt
initialOpenPICUsageCount(void)
{
	return CMMaxUsageCount - 1;
}
/*	Answer the value to put in an inline-cache that is being loaded with the 
	selector. Usually this is simply the selector, but in 64-bits the cache is 
	only 32-bits wide 
	and so the cache is loaded with the index of the selector. */
/* Cogit>>#inlineCacheValueForSelector:in:at: */
static sqInt NoDbgRegParms
inlineCacheValueForSelectorinat(sqInt _selector, CogMethod *_aCogMethod, sqInt _mcpc)
{
	return indexForSelectorinat(_selector, _aCogMethod, _mcpc);
}
/* Cogit>>#inverseBranchFor: */
static sqInt NoDbgRegParms
inverseBranchFor(sqInt _opcode)
{
	switch (_opcode) {
		case JumpLongZero:
		{
			return JumpLongNonZero;
		}
		case JumpLongNonZero:
		{
			return JumpLongZero;
		}
		case JumpZero:
		{
			return JumpNonZero;
		}
		case JumpNonZero:
		{
			return JumpZero;
		}
		case JumpNegative:
		{
			return JumpNonNegative;
		}
		case JumpNonNegative:
		{
			return JumpNegative;
		}
		case JumpOverflow:
		{
			return JumpNoOverflow;
		}
		case JumpNoOverflow:
		{
			return JumpOverflow;
		}
		case JumpCarry:
		{
			return JumpNoCarry;
		}
		case JumpNoCarry:
		{
			return JumpCarry;
		}
		case JumpLess:
		{
			return JumpGreaterOrEqual;
		}
		case JumpGreaterOrEqual:
		{
			return JumpLess;
		}
		case JumpGreater:
		{
			return JumpLessOrEqual;
		}
		case JumpLessOrEqual:
		{
			return JumpGreater;
		}
		case JumpBelow:
		{
			return JumpAboveOrEqual;
		}
		case JumpAboveOrEqual:
		{
			return JumpBelow;
		}
		case JumpAbove:
		{
			return JumpBelowOrEqual;
		}
		case JumpBelowOrEqual:
		{
			return JumpAbove;
		}
		default:
		error("Case not found and no otherwise clause");
	}
	error("invalid opcode for inverse");
	return 0;
}
/*	This value is used to decide between MNU processing 
	or interpretation in the closed PIC aborts. */
/* Cogit>>#isMNUPicAbortDiscriminatorValue */
static sqInt
isMNUPicAbortDiscriminatorValue(void)
{
	return 0;
}
/*	See Cogit class>>initializeAnnotationConstants */
/* Cogit>>#isPCMappedAnnotation: */
static sqInt NoDbgRegParms
isPCMappedAnnotation(sqInt _annotation)
{
	return _annotation >= HasBytecodePC;
}
/* Cogit>>#isPCWithinMethodZone: */
sqInt
isPCWithinMethodZone(void *_address)
{
	return (((usqInt) _address ) >= methodZoneBase) && (((usqInt) _address ) <= (freeStart()));
}
/*	Answer if the instruction preceding retpc is a call instruction. */
/* Cogit>>#isSendReturnPC: */
sqInt
isSendReturnPC(sqInt _retpc)
{
	sqInt _target;

	if (!(isCallPrecedingReturnPC(backEnd, _retpc))) {
		return 0;
	}
	_target = callTargetFromReturnAddress(backEnd, _retpc);
	return ((_target >= firstSend) && (_target <= lastSend)) || ((_target >= methodZoneBase) && (_target <= (freeStart())));
}
/*	Floating-point jumps are a little weird on some processors. Defer to 
	the backEnd to allow it to generate any special code it may need to. */
/* Cogit>>#JumpFPEqual: */
static AbstractInstruction * NoDbgRegParms
gJumpFPEqual(void *_jumpTarget)
{
	/* begin genJumpFPEqual: */
	return genConditionalBranchoperand(JumpFPEqual, ((sqInt) _jumpTarget ));
	/* end genJumpFPEqual: */
}
/*	Floating-point jumps are a little weird on some processors. Defer to 
	the backEnd to allow it to generate any special code it may need to. */
/* Cogit>>#JumpFPGreaterOrEqual: */
static AbstractInstruction * NoDbgRegParms
gJumpFPGreaterOrEqual(void *_jumpTarget)
{
	/* begin genJumpFPGreaterOrEqual: */
	return genConditionalBranchoperand(JumpFPGreaterOrEqual, ((sqInt) _jumpTarget ));
	/* end genJumpFPGreaterOrEqual: */
}
/*	Floating-point jumps are a little weird on some processors. Defer to 
	the backEnd to allow it to generate any special code it may need to. */
/* Cogit>>#JumpFPGreater: */
static AbstractInstruction * NoDbgRegParms
gJumpFPGreater(void *_jumpTarget)
{
	/* begin genJumpFPGreater: */
	return genConditionalBranchoperand(JumpFPGreater, ((sqInt) _jumpTarget ));
	/* end genJumpFPGreater: */
}
/*	Floating-point jumps are a little weird on some processors. Defer to 
	the backEnd to allow it to generate any special code it may need to. */
/* Cogit>>#JumpFPNotEqual: */
static AbstractInstruction * NoDbgRegParms
gJumpFPNotEqual(void *_jumpTarget)
{
	/* begin genJumpFPNotEqual: */
	return genConditionalBranchoperand(JumpFPNotEqual, ((sqInt) _jumpTarget ));
	/* end genJumpFPNotEqual: */
}
/* Cogit>>#Ld1S:Vr:R:Mw: */
static AbstractInstruction * NoDbgRegParms
gLd1SVrRMw(sqInt _aSize, sqInt _aVectorRegister, sqInt _aMemoryRegister, sqInt _anOffset)
{
	return genoperandoperandoperandoperand(Ld1VrRMw, _aSize, _aVectorRegister, _aMemoryRegister, _anOffset);
}
/* Cogit>>#LogicalShiftLeftCq:R: */
static AbstractInstruction * NoDbgRegParms
gLogicalShiftLeftCqR(sqInt _quickConstant, sqInt _reg)
{
	return genoperandoperand(LogicalShiftLeftCqR, _quickConstant, _reg);
}
/* Cogit>>#lastOpcode */
static AbstractInstruction *
lastOpcode(void)
{
	assert(opcodeIndex > 0);
	return abstractInstructionAt(opcodeIndex - 1);
}
/* Cogit>>#linkSendAt:in:to:offset:receiver: */
void
linkSendAtintooffsetreceiver(sqInt _callSiteReturnAddress, CogMethod *sendingMethod, CogMethod *_targetMethod, sqInt _theEntryOffset, sqInt _receiver)
{
	sqInt _address;
	sqInt _extent;
	sqInt _inlineCacheTag;

	assert((_theEntryOffset == cmEntryOffset) || (_theEntryOffset == cmNoCheckEntryOffset));
	assert((_callSiteReturnAddress >= methodZoneBase) && (_callSiteReturnAddress <= (freeStart())));
	_inlineCacheTag = ((_theEntryOffset == cmNoCheckEntryOffset)
		 ? (_targetMethod->selector)
		 : inlineCacheTagForInstance(_receiver));
	_address = ((sqInt) _targetMethod ) + _theEntryOffset;
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		_extent = rewriteInlineCacheAttagtarget(backEnd, _callSiteReturnAddress, _inlineCacheTag, _address);
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		flushICacheFromto(((usqInt) _callSiteReturnAddress ) - _extent, ((usqInt) _callSiteReturnAddress ));
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
}
/* Cogit>>#loadBytesAndGetDescriptor */
static BytecodeDescriptor *
loadBytesAndGetDescriptor(void)
{
	BytecodeDescriptor *_descriptor;

	byte0 = fetchByteofObject(bytecodePC, methodObj);
	_descriptor = generatorAt(byte0);
	loadSubsequentBytesForDescriptorat(_descriptor, bytecodePC);
	return _descriptor;
}
/* Cogit>>#loadSubsequentBytesForDescriptor:at: */
static void NoDbgRegParms
loadSubsequentBytesForDescriptorat(BytecodeDescriptor *_descriptor, sqInt _pc)
{
	if (((_descriptor->numBytes)) > 1) {
		byte1 = fetchByteofObject(_pc + 1, methodObj);
		if (((_descriptor->numBytes)) > 2) {
			byte2 = fetchByteofObject(_pc + 2, methodObj);
			if (((_descriptor->numBytes)) > 3) {
				byte3 = fetchByteofObject(_pc + 3, methodObj);
				if (((_descriptor->numBytes)) > 4) {
					/* begin notYetImplemented */
					/* begin notYetImplemented: */
					{
						logError("Not Yet Implemented!");
						abort();
					}
					/* end notYetImplemented: */
					/* end notYetImplemented */
				}
			}
		}
	}
}
/* Cogit>>#MoveAw:R: */
static AbstractInstruction * NoDbgRegParms
gMoveAwR(sqInt _address, sqInt _reg)
{
	/* begin gen:literal:operand: */
	return checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, _reg));
	/* end gen:literal:operand: */
}
/* Cogit>>#MoveCw:R: */
static AbstractInstruction * NoDbgRegParms
gMoveCwR(sqInt _wordConstant, sqInt _reg)
{
	/* begin gen:literal:operand: */
	return checkLiteralforInstruction(_wordConstant, genoperandoperand(MoveCwR, _wordConstant, _reg));
	/* end gen:literal:operand: */
}
/*	Unlinking/GC/Disassembly support */
/* Cogit>>#mapFor:performUntil:arg: */
static sqInt NoDbgRegParms
mapForperformUntilarg(CogMethod *_cogMethod, sqInt (*_functionSymbol)(sqInt annotation, char *mcpc, sqInt arg), sqInt _arg)
{
	sqInt _annotation;
	usqInt _map;
	sqInt _mapByte;
	sqInt _mcpc;
	sqInt _result;

	/* begin firstMappedPCFor: */
	_mcpc = (((_cogMethod->cpicHasMNUCaseOrCMIsFullBlock))
		 ? ((usqInt) _cogMethod ) + cbNoSwitchEntryOffset
		 : ((usqInt) _cogMethod ) + cmNoCheckEntryOffset);
	/* end firstMappedPCFor: */
	_map = (((usqInt) _cogMethod ) + ((_cogMethod->blockSize))) - 1;
	{
		enumeratingCogMethod = _cogMethod;
	}
	while (((_mapByte = byteAt(_map))) != MapEnd) {
		if (_mapByte >= FirstAnnotation) {
			_mcpc += (_mapByte & DisplacementMask) * 4;
			if ((((_annotation = ((usqInt) _mapByte ) >> AnnotationShift)) == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
				_annotation += _mapByte & DisplacementMask;
				_map -= 1;
			}
			_result = _functionSymbol(_annotation, ((char *) _mcpc ), _arg);
			if (_result != 0) {
				return _result;
			}
		} else {
			if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
				_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
			}
		}
		_map -= 1;
	}
	return 0;
}
/*	Remap all object references in the closed PIC. Answer if any references 
	are young. 
	Set codeModified if any modifications are made. */
/* Cogit>>#mapObjectReferencesInClosedPIC: */
static sqInt NoDbgRegParms
mapObjectReferencesInClosedPIC(CogMethod *_cPIC)
{
	sqInt _i;
	sqInt _pc;
	sqInt _refersToYoung;

	_pc = addressOfEndOfCaseinCPIC(1, _cPIC);
	_refersToYoung = remapMaybeObjRefInClosedPICAt(_pc - (jumpLongByteSize(backEnd)));
	_pc = addressOfEndOfCaseinCPIC((_cPIC->cPICNumCases), _cPIC);
	for (_i = 2; _i <= ((_cPIC->cPICNumCases)); _i += 1) {
		if (remapMaybeObjRefInClosedPICAt((_pc - (jumpLongConditionalByteSize(backEnd))) - (cmpC32RTempByteSize(backEnd)))) {
			_refersToYoung = 1;
		}
		_pc += cPICCaseSize;
	}
	return _refersToYoung;
}
/*	Update all references to objects in the generated runtime. */
/* Cogit>>#mapObjectReferencesInGeneratedRuntime */
static void
mapObjectReferencesInGeneratedRuntime(void)
{
	sqInt _i;
	sqInt _literal;
	sqInt _mappedLiteral;
	usqInt _mcpc;

	for (_i = 0; _i < runtimeObjectRefIndex; _i += 1) {
		_mcpc = objectReferencesInRuntime[_i];
		_literal = unsignedLongAt(_mcpc);
		_mappedLiteral = remapObject(_literal);
		if (_mappedLiteral != _literal) {
			/* begin storeLiteral:atAnnotatedAddress:using: */
			unsignedLongAtput(_mcpc, _mappedLiteral);
			/* end storeLiteral:atAnnotatedAddress:using: */
			codeModified = 1;
		}
	}
}
/*	Update all references to objects in machine code for a become. 
	Unlike incrementalGC or fullGC a method that does not refer to young may 
	refer to young as a result of the become operation. Unlike incrementalGC 
	or fullGC the reference from a Cog method to its methodObject *must not* 
	change since the two are two halves of the same object. */
/* Cogit>>#mapObjectReferencesInMachineCodeForBecome */
static void
mapObjectReferencesInMachineCodeForBecome(void)
{
	sqInt _annotation;
	CogMethod *_cogMethod;
	int _freedPIC;
	sqInt _hasYoungObj;
	sqInt _hasYoungObjPtr;
	usqInt _map;
	sqInt _mapByte;
	sqInt _mcpc;
	sqInt _remappedMethod;
	sqInt _result;
	sqInt _val;

	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	_val = 0;
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		_hasYoungObj = 0;
		_hasYoungObjPtr = ((sqInt) &_hasYoungObj );
		codeModified = (_freedPIC = 0);
		mapObjectReferencesInGeneratedRuntime();
		_cogMethod = ((CogMethod *) methodZoneBase );
		while (_cogMethod < (limitZony())) {
			assert(!_hasYoungObj);
			if (((_cogMethod->cmType)) != CMFree) {
				assert((cogMethodDoesntLookKosher(_cogMethod)) == 0);
				(_cogMethod->selector = remapOop((_cogMethod->selector)));
				if (((_cogMethod->cmType)) == CMPolymorphicIC) {
					if ((isYoung((_cogMethod->selector))) || (mapObjectReferencesInClosedPIC(_cogMethod))) {
						_freedPIC = 1;
						freeMethod(_cogMethod);
					}
				} else {
					if (isYoung((_cogMethod->selector))) {
						_hasYoungObj = 1;
					}
					if (((_cogMethod->cmType)) == CMMethod) {
						assert(((_cogMethod->objectHeader)) == (nullHeaderForMachineCodeMethod()));
						_remappedMethod = remapOop((_cogMethod->methodObject));
						if (_remappedMethod != ((_cogMethod->methodObject))) {
							if (methodHasCogMethod(_remappedMethod)) {
								error("attempt to become two cogged methods");
							}
							if (!(withoutForwardingOnandwithsendToCogit((_cogMethod->methodObject), _remappedMethod, (_cogMethod->cmUsesPenultimateLit), methodhasSameCodeAscheckPenultimate))) {
								error("attempt to become cogged method into different method");
							}
							if ((rawHeaderOf((_cogMethod->methodObject))) == ((sqInt) _cogMethod )) {
								rawHeaderOfput((_cogMethod->methodObject), (_cogMethod->methodHeader));
								{
									(_cogMethod->methodHeader = rawHeaderOf(_remappedMethod));
									(_cogMethod->methodObject = _remappedMethod);
								}
								rawHeaderOfput(_remappedMethod, ((sqInt) _cogMethod ));
							} else {
								assert((noAssertMethodClassAssociationOf((_cogMethod->methodObject))) == (nilObject()));
								{
									(_cogMethod->methodHeader = rawHeaderOf(_remappedMethod));
									(_cogMethod->methodObject = _remappedMethod);
								}
							}
						}
						if (isYoung((_cogMethod->methodObject))) {
							_hasYoungObj = 1;
						}
					}
					/* begin mapFor:performUntil:arg: */
					/* begin firstMappedPCFor: */
					_mcpc = (((_cogMethod->cpicHasMNUCaseOrCMIsFullBlock))
						 ? ((usqInt) _cogMethod ) + cbNoSwitchEntryOffset
						 : ((usqInt) _cogMethod ) + cmNoCheckEntryOffset);
					/* end firstMappedPCFor: */
					_map = (((usqInt) _cogMethod ) + ((_cogMethod->blockSize))) - 1;
					{
						enumeratingCogMethod = _cogMethod;
					}
					while (((_mapByte = byteAt(_map))) != MapEnd) {
						if (_mapByte >= FirstAnnotation) {
							_mcpc += (_mapByte & DisplacementMask) * 4;
							if ((((_annotation = ((usqInt) _mapByte ) >> AnnotationShift)) == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
								_annotation += _mapByte & DisplacementMask;
								_map -= 1;
							}
							_result = remapIfObjectRefpchasYoung(_annotation, ((char *) _mcpc ), _hasYoungObjPtr);
							if (_result != 0) {
								goto l4;
							}
						} else {
							if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
								_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
							}
						}
						_map -= 1;
					}
					l4:
					;
					/* end mapFor:performUntil:arg: */
					if (_hasYoungObj) {
						ensureInYoungReferrers(_cogMethod);
						_hasYoungObj = 0;
					} else {
						(_cogMethod->cmRefersToYoung = 0);
					}
				}
			}
			_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		}
		pruneYoungReferrers();
		if (_freedPIC) {
			unlinkSendsToFree();
		}
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		if (codeModified) {
			flushICacheFromto(((usqInt) codeBase ), ((usqInt) (limitZony()) ));
		}
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
}
/*	Update all references to objects in machine code for a full gc. Since 
	the current (New)ObjectMemory GC makes everything old in a full GC 
	a method not referring to young will not refer to young afterwards */
/* Cogit>>#mapObjectReferencesInMachineCodeForFullGC */
static void
mapObjectReferencesInMachineCodeForFullGC(void)
{
	sqInt _annotation;
	CogMethod *_cogMethod;
	usqInt _map;
	sqInt _mapByte;
	sqInt _mcpc;
	sqInt _result;

	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		codeModified = 0;
		mapObjectReferencesInGeneratedRuntime();
		_cogMethod = ((CogMethod *) methodZoneBase );
		while (_cogMethod < (limitZony())) {
			if (((_cogMethod->cmType)) != CMFree) {
				assert((cogMethodDoesntLookKosher(_cogMethod)) == 0);
				(_cogMethod->selector = remapOop((_cogMethod->selector)));
				if (((_cogMethod->cmType)) == CMPolymorphicIC) {
					assert(!((_cogMethod->cmRefersToYoung)));
					mapObjectReferencesInClosedPIC(_cogMethod);
				} else {
					if (((_cogMethod->cmType)) == CMMethod) {
						assert(((_cogMethod->objectHeader)) == (nullHeaderForMachineCodeMethod()));
						(_cogMethod->methodObject = remapOop((_cogMethod->methodObject)));
					}
					/* begin mapFor:performUntil:arg: */
					/* begin firstMappedPCFor: */
					_mcpc = (((_cogMethod->cpicHasMNUCaseOrCMIsFullBlock))
						 ? ((usqInt) _cogMethod ) + cbNoSwitchEntryOffset
						 : ((usqInt) _cogMethod ) + cmNoCheckEntryOffset);
					/* end firstMappedPCFor: */
					_map = (((usqInt) _cogMethod ) + ((_cogMethod->blockSize))) - 1;
					{
						enumeratingCogMethod = _cogMethod;
					}
					while (((_mapByte = byteAt(_map))) != MapEnd) {
						if (_mapByte >= FirstAnnotation) {
							_mcpc += (_mapByte & DisplacementMask) * 4;
							if ((((_annotation = ((usqInt) _mapByte ) >> AnnotationShift)) == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
								_annotation += _mapByte & DisplacementMask;
								_map -= 1;
							}
							_result = remapIfObjectRefpchasYoung(_annotation, ((char *) _mcpc ), 0);
							if (_result != 0) {
								goto l4;
							}
						} else {
							if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
								_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
							}
						}
						_map -= 1;
					}
					l4:
					;
					/* end mapFor:performUntil:arg: */
				}
			}
			_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		}
		pruneYoungReferrers();
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		if (codeModified) {
			flushICacheFromto(((usqInt) codeBase ), ((usqInt) (limitZony()) ));
		}
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
}
/*	Update all references to objects in machine code for either a Spur 
	scavenging gc 
	or a Squeak V3 incremental GC. Avoid scanning all code by using the 
	youngReferrers list. In a young gc a method referring to young may no 
	longer refer to young, but a 
	method not referring to young cannot and will not refer to young 
	afterwards.  */
/* Cogit>>#mapObjectReferencesInMachineCodeForYoungGC */
static void
mapObjectReferencesInMachineCodeForYoungGC(void)
{
	sqInt _annotation;
	CogMethod *_cogMethod;
	sqInt _hasYoungObj;
	sqInt _hasYoungObjPtr;
	usqInt _map;
	sqInt _mapByte;
	sqInt _mcpc;
	usqInt _pointer;
	sqInt _result;
	sqInt _val;

	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	_val = 0;
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		_hasYoungObj = 0;
		_hasYoungObjPtr = ((sqInt) &_hasYoungObj );
		codeModified = 0;
		_pointer = youngReferrers();
		while (_pointer < limitAddress) {
			assert(!_hasYoungObj);
			_cogMethod = ((CogMethod *) (longAt(_pointer)) );
			if (((_cogMethod->cmType)) == CMFree) {
				assert(!((_cogMethod->cmRefersToYoung)));
			} else {
				assert((cogMethodDoesntLookKosher(_cogMethod)) == 0);
				if ((_cogMethod->cmRefersToYoung)) {
					assert((((_cogMethod->cmType)) == CMMethod) || (((_cogMethod->cmType)) == CMMegamorphicIC));
					(_cogMethod->selector = remapOop((_cogMethod->selector)));
					if (isYoung((_cogMethod->selector))) {
						_hasYoungObj = 1;
					}
					if (((_cogMethod->cmType)) == CMMethod) {
						assert(((_cogMethod->objectHeader)) == (nullHeaderForMachineCodeMethod()));
						(_cogMethod->methodObject = remapOop((_cogMethod->methodObject)));
						if (isYoung((_cogMethod->methodObject))) {
							_hasYoungObj = 1;
						}
					}
					/* begin mapFor:performUntil:arg: */
					/* begin firstMappedPCFor: */
					_mcpc = (((_cogMethod->cpicHasMNUCaseOrCMIsFullBlock))
						 ? ((usqInt) _cogMethod ) + cbNoSwitchEntryOffset
						 : ((usqInt) _cogMethod ) + cmNoCheckEntryOffset);
					/* end firstMappedPCFor: */
					_map = (((usqInt) _cogMethod ) + ((_cogMethod->blockSize))) - 1;
					{
						enumeratingCogMethod = _cogMethod;
					}
					while (((_mapByte = byteAt(_map))) != MapEnd) {
						if (_mapByte >= FirstAnnotation) {
							_mcpc += (_mapByte & DisplacementMask) * 4;
							if ((((_annotation = ((usqInt) _mapByte ) >> AnnotationShift)) == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
								_annotation += _mapByte & DisplacementMask;
								_map -= 1;
							}
							_result = remapIfObjectRefpchasYoung(_annotation, ((char *) _mcpc ), _hasYoungObjPtr);
							if (_result != 0) {
								goto l4;
							}
						} else {
							if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
								_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
							}
						}
						_map -= 1;
					}
					l4:
					;
					/* end mapFor:performUntil:arg: */
					if (_hasYoungObj) {
						_hasYoungObj = 0;
					} else {
						(_cogMethod->cmRefersToYoung = 0);
					}
				}
			}
			_pointer += BytesPerWord;
		}
		pruneYoungReferrers();
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		if (codeModified) {
			flushICacheFromto(((usqInt) codeBase ), ((usqInt) (limitZony()) ));
		}
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
}
/*	Update all references to objects in machine code. */
/* Cogit>>#mapObjectReferencesInMachineCode: */
void
mapObjectReferencesInMachineCode(sqInt _gcMode)
{
	switch (_gcMode) {
		case GCModeNewSpace:
		{
			mapObjectReferencesInMachineCodeForYoungGC();
		}
		break;
		case GCModeFull:
		{
			mapObjectReferencesInMachineCodeForFullGC();
		}
		break;
		case GCModeBecome:
		{
			mapObjectReferencesInMachineCodeForBecome();
		}
		break;
		default:
		error("Case not found and no otherwise clause");
	}
	if (!(asserta((freeStart()) <= (youngReferrers())))) {
		error("youngReferrers list overflowed");
	}
}
/*	Mark objects in machine-code of marked methods (or open PICs with marked 
	selectors).  */
/* Cogit>>#markAndTraceMachineCodeOfMarkedMethods */
void
markAndTraceMachineCodeOfMarkedMethods(void)
{
	sqInt _annotation;
	sqInt _annotation2;
	CogMethod *_cogMethod;
	usqInt _map;
	usqInt _map2;
	sqInt _mapByte;
	sqInt _mapByte2;
	sqInt _mcpc;
	sqInt _mcpc2;
	sqInt _result;
	sqInt _result2;
	sqInt _val;
	sqInt _val2;

	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	_val = 0;
	_val2 = 0;
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		if (leakCheckFullGC()) {
			assert(allMachineCodeObjectReferencesValid());
		}
		codeModified = 0;
		markAndTraceObjectReferencesInGeneratedRuntime();
		_cogMethod = ((CogMethod *) methodZoneBase );
		while (_cogMethod < (limitZony())) {
			if ((((_cogMethod->cmType)) == CMMethod) && (isMarkedOrPermanent((_cogMethod->methodObject)))) {
				/* begin markAndTraceLiteralsIn: */
				assert(((((_cogMethod->cmType)) == CMMethod) && (isMarkedOrPermanent((_cogMethod->methodObject)))) || ((((_cogMethod->cmType)) == CMMegamorphicIC) && ((isImmediate((_cogMethod->selector))) || (isMarkedOrPermanent((_cogMethod->selector))))));
				markAndTraceLiteralinat((_cogMethod->selector), _cogMethod, &((_cogMethod->selector)));
				maybeMarkCountersIn(_cogMethod);
				/* begin mapFor:performUntil:arg: */
				/* begin firstMappedPCFor: */
				_mcpc = (((_cogMethod->cpicHasMNUCaseOrCMIsFullBlock))
					 ? ((usqInt) _cogMethod ) + cbNoSwitchEntryOffset
					 : ((usqInt) _cogMethod ) + cmNoCheckEntryOffset);
				/* end firstMappedPCFor: */
				_map = (((usqInt) _cogMethod ) + ((_cogMethod->blockSize))) - 1;
				{
					enumeratingCogMethod = _cogMethod;
				}
				while (((_mapByte = byteAt(_map))) != MapEnd) {
					if (_mapByte >= FirstAnnotation) {
						_mcpc += (_mapByte & DisplacementMask) * 4;
						if ((((_annotation = ((usqInt) _mapByte ) >> AnnotationShift)) == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
							_annotation += _mapByte & DisplacementMask;
							_map -= 1;
						}
						_result = markLiteralspcmethod(_annotation, ((char *) _mcpc ), ((sqInt) _cogMethod ));
						if (_result != 0) {
							goto l6;
						}
					} else {
						if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
							_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
						}
					}
					_map -= 1;
				}
				l6:
				;
				/* end mapFor:performUntil:arg: */
				/* end markAndTraceLiteralsIn: */
			}
			if ((((_cogMethod->cmType)) == CMMegamorphicIC) && ((isImmediate((_cogMethod->selector))) || (isMarkedOrPermanent((_cogMethod->selector))))) {
				/* begin markAndTraceLiteralsIn: */
				assert(((((_cogMethod->cmType)) == CMMethod) && (isMarkedOrPermanent((_cogMethod->methodObject)))) || ((((_cogMethod->cmType)) == CMMegamorphicIC) && ((isImmediate((_cogMethod->selector))) || (isMarkedOrPermanent((_cogMethod->selector))))));
				markAndTraceLiteralinat((_cogMethod->selector), _cogMethod, &((_cogMethod->selector)));
				maybeMarkCountersIn(_cogMethod);
				/* begin mapFor:performUntil:arg: */
				/* begin firstMappedPCFor: */
				_mcpc2 = (((_cogMethod->cpicHasMNUCaseOrCMIsFullBlock))
					 ? ((usqInt) _cogMethod ) + cbNoSwitchEntryOffset
					 : ((usqInt) _cogMethod ) + cmNoCheckEntryOffset);
				/* end firstMappedPCFor: */
				_map2 = (((usqInt) _cogMethod ) + ((_cogMethod->blockSize))) - 1;
				{
					enumeratingCogMethod = _cogMethod;
				}
				while (((_mapByte2 = byteAt(_map2))) != MapEnd) {
					if (_mapByte2 >= FirstAnnotation) {
						_mcpc2 += (_mapByte2 & DisplacementMask) * 4;
						if ((((_annotation2 = ((usqInt) _mapByte2 ) >> AnnotationShift)) == IsSendCall) && ((((usqInt) ((_mapByte2 = byteAt(_map2 - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
							_annotation2 += _mapByte2 & DisplacementMask;
							_map2 -= 1;
						}
						_result2 = markLiteralspcmethod(_annotation2, ((char *) _mcpc2 ), ((sqInt) _cogMethod ));
						if (_result2 != 0) {
							goto l7;
						}
					} else {
						if (_mapByte2 < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
							_mcpc2 += ((sqInt) (((usqInt) (_mapByte2 - DisplacementX2N) ) << AnnotationShift) ) * 4;
						}
					}
					_map2 -= 1;
				}
				l7:
				;
				/* end mapFor:performUntil:arg: */
				/* end markAndTraceLiteralsIn: */
			}
			_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		}
		if (leakCheckFullGC()) {
			assert(allMachineCodeObjectReferencesValid());
		}
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		if (codeModified) {
			flushICacheFromto(((usqInt) codeBase ), ((usqInt) (limitZony()) ));
		}
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
}
/*	Mark and trace any object references in the generated run-time. */
/* Cogit>>#markAndTraceObjectReferencesInGeneratedRuntime */
static void
markAndTraceObjectReferencesInGeneratedRuntime(void)
{
	sqInt _i;
	sqInt _literal;
	usqInt _mcpc;

	for (_i = 0; _i < runtimeObjectRefIndex; _i += 1) {
		_mcpc = objectReferencesInRuntime[_i];
		_literal = unsignedLongAt(_mcpc);
		markAndTraceLiteralinatpc(_literal, ((CogMethod *) null ), ((usqInt) _mcpc ));
	}
}
/*	Mark and trace objects in the argument and free if it is appropriate. 
	Answer if the method has been freed. firstVisit is a hint used to avoid 
	scanning methods we've already seen. False positives are fine. 
	For a CMMethod this 
	frees if the bytecode method isnt marked, 
	marks and traces object literals and selectors, 
	unlinks sends to targets that should be freed. 
	For a CMClosedPIC this 
	frees if it refers to anything that should be freed or isn't marked. 
	For a CMOpenPIC this 
	frees if the selector isn't marked.this recurses at most one level down */
/* Cogit>>#markAndTraceOrFreeCogMethod:firstVisit: */
static sqInt NoDbgRegParms
markAndTraceOrFreeCogMethodfirstVisit(CogMethod *_cogMethod, sqInt _firstVisit)
{
	sqInt _annotation;
	usqInt _map;
	sqInt _mapByte;
	sqInt _mcpc;
	sqInt _result;
	sqInt _val;

	_val = 0;
	if (((_cogMethod->cmType)) == CMFree) {
		return 1;
	}
	assert((cogMethodDoesntLookKosher(_cogMethod)) == 0);
	if (((_cogMethod->cmType)) == CMMethod) {
		if (!(isMarkedOrPermanent((_cogMethod->methodObject)))) {
			freeMethod(_cogMethod);
			return 1;
		}
		if (_firstVisit) {
			/* begin markLiteralsAndUnlinkUnmarkedSendsIn: */
			assert(((_cogMethod->cmType)) == CMMethod);
			assert(isMarkedOrPermanent((_cogMethod->methodObject)));
			markAndTraceLiteralinat((_cogMethod->selector), _cogMethod, &((_cogMethod->selector)));
			maybeMarkCountersIn(_cogMethod);
			/* begin mapFor:performUntil:arg: */
			/* begin firstMappedPCFor: */
			_mcpc = (((_cogMethod->cpicHasMNUCaseOrCMIsFullBlock))
				 ? ((usqInt) _cogMethod ) + cbNoSwitchEntryOffset
				 : ((usqInt) _cogMethod ) + cmNoCheckEntryOffset);
			/* end firstMappedPCFor: */
			_map = (((usqInt) _cogMethod ) + ((_cogMethod->blockSize))) - 1;
			{
				enumeratingCogMethod = _cogMethod;
			}
			while (((_mapByte = byteAt(_map))) != MapEnd) {
				if (_mapByte >= FirstAnnotation) {
					_mcpc += (_mapByte & DisplacementMask) * 4;
					if ((((_annotation = ((usqInt) _mapByte ) >> AnnotationShift)) == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
						_annotation += _mapByte & DisplacementMask;
						_map -= 1;
					}
					_result = markLiteralsAndUnlinkIfUnmarkedSendpcmethod(_annotation, ((char *) _mcpc ), ((sqInt) _cogMethod ));
					if (_result != 0) {
						goto l3;
					}
				} else {
					if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
						_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
					}
				}
				_map -= 1;
			}
			l3:
			;
			/* end mapFor:performUntil:arg: */
			/* end markLiteralsAndUnlinkUnmarkedSendsIn: */
		}
		return 0;
	}
	if (((_cogMethod->cmType)) == CMPolymorphicIC) {
		if (!(closedPICRefersToUnmarkedObject(_cogMethod))) {
			return 0;
		}
		freeMethod(_cogMethod);
		return 1;
	}
	if (((_cogMethod->cmType)) == CMMegamorphicIC) {
		if (isMarkedOrPermanent((_cogMethod->selector))) {
			return 0;
		}
		freeMethod(_cogMethod);
		return 1;
	}
	assert((((_cogMethod->cmType)) == CMMethod) || ((((_cogMethod->cmType)) == CMPolymorphicIC) || (((_cogMethod->cmType)) == CMMegamorphicIC)));
	return 0;
}
/*	If entryPoint is that of some method, then mark and trace objects in it 
	and free if it is appropriate. 
	Answer if the method has been freed. */
/* Cogit>>#markAndTraceOrFreePICTarget:in: */
static sqInt NoDbgRegParms
markAndTraceOrFreePICTargetin(sqInt _entryPoint, CogMethod *_cPIC)
{
	CogMethod *_targetMethod;

	assert((_entryPoint > methodZoneBase) && (_entryPoint < (freeStart())));
	if ((((usqInt) _cPIC ) <= ((usqInt) _entryPoint )) && ((((usqInt) _cPIC ) + ((_cPIC->blockSize))) >= ((usqInt) _entryPoint ))) {
		return 0;
	}
	_targetMethod = ((CogMethod *) (_entryPoint - cmNoCheckEntryOffset) );
	assert((((_targetMethod->cmType)) == CMMethod) || (((_targetMethod->cmType)) == CMFree));
	return markAndTraceOrFreeCogMethodfirstVisit(_targetMethod, ((usqInt) _targetMethod ) > ((usqInt) _cPIC ));
}
/*	Mark and trace literals. Unlink sends that have unmarked cache tags or 
	targets.  */
/* Cogit>>#markLiteralsAndUnlinkIfUnmarkedSend:pc:method: */
static sqInt NoDbgRegParms
markLiteralsAndUnlinkIfUnmarkedSendpcmethod(sqInt _annotation, char *_mcpc, sqInt _cogMethod)
{
	usqInt _cacheTag2;
	sqInt _cacheTagMarked;
	sqInt _entryPoint2;
	sqInt _literal;
	sqInt _offset2;
	sqInt *_sendTable2;
	sqInt _tagCouldBeObj2;
	CogMethod * _targetCogCode;
	sqInt _unlinkedRoutine;
	sqInt _val;

	_val = 0;
	if (_annotation == IsObjectReference) {
		_literal = unsignedLongAt(((usqInt) _mcpc ));
		if (markAndTraceLiteralinatpc(_literal, ((CogMethod *) _cogMethod ), ((usqInt) _mcpc ))) {
			codeModified = 1;
		}
	}
	if (_annotation >= IsSendCall) {
		/* begin entryCacheTagAndCouldBeObjectAt:annotation:into: */
		_cacheTag2 = inlineCacheTagAt(backEnd, ((sqInt) _mcpc ));
		_entryPoint2 = callTargetFromReturnAddress(backEnd, ((sqInt) _mcpc ));
		_tagCouldBeObj2 = 0;
		{
			_cacheTagMarked = _tagCouldBeObj2 && (cacheTagIsMarked(_cacheTag2));
			if (_entryPoint2 > methodZoneBase) {
				/* begin targetMethodAndSendTableFor:annotation:into: */
				/* begin offsetAndSendTableFor:annotation:into: */
				if (_annotation == IsSendCall) {
					_offset2 = cmEntryOffset;
					_sendTable2 = ordinarySendTrampolines;
				} else {
					if (_annotation == IsDirectedSuperSend) {
						_offset2 = cmNoCheckEntryOffset;
						_sendTable2 = directedSuperSendTrampolines;
					} else {
						if (_annotation == IsDirectedSuperBindingSend) {
							_offset2 = cmNoCheckEntryOffset;
							_sendTable2 = directedSuperBindingSendTrampolines;
						} else {
							assert(_annotation == IsSuperSend);
							_offset2 = cmNoCheckEntryOffset;
							_sendTable2 = superSendTrampolines;
						}
					}
				}
				{
					_targetCogCode = ((CogMethod *) (_entryPoint2 - _offset2) );
					{
						if (!_cacheTagMarked || (markAndTraceOrFreeCogMethodfirstVisit(_targetCogCode, ((usqInt) _targetCogCode ) > ((usqInt) _mcpc )))) {
							/* begin unlinkSendAt:targetMethod:sendTable: */
							_unlinkedRoutine = _sendTable2[((((_targetCogCode->cmNumArgs)) < (NumSendTrampolines - 1)) ? (_targetCogCode->cmNumArgs) : NumSendTrampolines - 1)];
							rewriteInlineCacheAttagtarget(backEnd, ((sqInt) _mcpc ), inlineCacheValueForSelectorinat((_targetCogCode->selector), enumeratingCogMethod, _mcpc), _unlinkedRoutine);
							codeModified = 1;
							/* end unlinkSendAt:targetMethod:sendTable: */
							markAndTraceLiteralinat((_targetCogCode->selector), _targetCogCode, &((_targetCogCode->selector)));
						}
					}
				}
				/* end offsetAndSendTableFor:annotation:into: */
				/* end targetMethodAndSendTableFor:annotation:into: */
			} else {
			}
		}
		/* end entryCacheTagAndCouldBeObjectAt:annotation:into: */
	}
	return 0;
}
/*	Mark and trace literals. */
/* Cogit>>#markLiterals:pc:method: */
static sqInt NoDbgRegParms
markLiteralspcmethod(sqInt _annotation, char *_mcpc, sqInt _cogMethod)
{
	usqInt _cacheTag2;
	sqInt _entryPoint;
	sqInt _literal;
	sqInt _tagCouldBeObj2;

	if (_annotation == IsObjectReference) {
		_literal = unsignedLongAt(((usqInt) _mcpc ));
		if (markAndTraceLiteralinatpc(_literal, ((CogMethod *) _cogMethod ), ((usqInt) _mcpc ))) {
			codeModified = 1;
		}
	}
	if (_annotation >= IsSendCall) {
		/* begin entryCacheTagAndCouldBeObjectAt:annotation:into: */
		_cacheTag2 = inlineCacheTagAt(backEnd, ((sqInt) _mcpc ));
		_entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt) _mcpc ));
		_tagCouldBeObj2 = 0;
		{
			if (_tagCouldBeObj2) {
			}
		}
		/* end entryCacheTagAndCouldBeObjectAt:annotation:into: */
	}
	return 0;
}
/* Cogit>>#markMethodAndReferents: */
void
markMethodAndReferents(CogMethod *_aCogMethod)
{
	sqInt _annotation;
	usqInt _map;
	sqInt _mapByte;
	sqInt _mcpc;
	sqInt _result;

	assert(((_aCogMethod->cmType)) == CMMethod);
	(_aCogMethod->cmUsageCount = CMMaxUsageCount);
	/* begin mapFor:performUntil:arg: */
	/* begin firstMappedPCFor: */
	_mcpc = (((_aCogMethod->cpicHasMNUCaseOrCMIsFullBlock))
		 ? ((usqInt) _aCogMethod ) + cbNoSwitchEntryOffset
		 : ((usqInt) _aCogMethod ) + cmNoCheckEntryOffset);
	/* end firstMappedPCFor: */
	_map = (((usqInt) _aCogMethod ) + ((_aCogMethod->blockSize))) - 1;
	{
		enumeratingCogMethod = _aCogMethod;
	}
	while (((_mapByte = byteAt(_map))) != MapEnd) {
		if (_mapByte >= FirstAnnotation) {
			_mcpc += (_mapByte & DisplacementMask) * 4;
			if ((((_annotation = ((usqInt) _mapByte ) >> AnnotationShift)) == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
				_annotation += _mapByte & DisplacementMask;
				_map -= 1;
			}
			_result = incrementUsageOfTargetIfLinkedSendmcpcignored(_annotation, ((char *) _mcpc ), 0);
			if (_result != 0) {
				goto l3;
			}
		} else {
			if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
				_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
			}
		}
		_map -= 1;
	}
	l3:
	;
	/* end mapFor:performUntil:arg: */
}
/* Cogit>>#maxCogMethodAddress */
usqInt
maxCogMethodAddress(void)
{
	return ((usqInt) (limitZony()) );
}
/*	Check that the header fields are consistent with the type. 
	Answer 0 if it is ok, otherwise answer a code for the error. */
/* Cogit>>#maybeFreeCogMethodDoesntLookKosher: */
static sqInt NoDbgRegParms
maybeFreeCogMethodDoesntLookKosher(CogMethod *_cogMethod)
{
	sqInt _result;

	_result = cogMethodDoesntLookKosher(_cogMethod);
	return ((_result == 2)
		 ? 0
		 : _result);
}
/*	In SIsta Spur counters are held on the heap in pinned objects which must 
	be marked 
	to avoid them being garbage collected. This is the hook through which that 
	happens.  */
/* Cogit>>#maybeMarkCountersIn: */
static void NoDbgRegParms
maybeMarkCountersIn(CogMethod *cogMethod)
{
}
/* Cogit>>#mclassIsSmallInteger */
static sqInt
mclassIsSmallInteger(void)
{
	return ((receiverTags & 7) == 1);
}
/*	Answer the absolute machine code pc matching the zero-relative 
	bytecode pc of a backward branch in cogMethod, given the start 
	of the bytecodes for cogMethod's method object. */
/* Cogit>>#mcPCForBackwardBranch:startBcpc:in: */
usqInt
mcPCForBackwardBranchstartBcpcin(sqInt _bcpc, sqInt _startbcpc, CogMethod *_cogMethod)
{
	sqInt _aMethodObj;
	sqInt _annotation;
	sqInt _bcpc2;
	sqInt _byte;
	BytecodeDescriptor *_descriptor;
	sqInt _distance;
	sqInt _endbcpc;
	CogMethod *_homeMethod;
	sqInt _isBackwardBranch;
	usqInt _isInBlock;
	sqInt _latestContinuation;
	usqInt _map;
	sqInt _mapByte;
	usqInt _mcpc;
	sqInt _nExts;
	sqInt _nextBcpc;
	sqInt _result;
	sqInt _targetPC;

	/* begin mapFor:bcpc:performUntil:arg: */
	assert(((_cogMethod->stackCheckOffset)) > 0);
	_mcpc = ((usqInt) _cogMethod ) + ((_cogMethod->stackCheckOffset));
	_result = ((((0 + ((sqInt) (((usqInt) HasBytecodePC ) << 1) )) & 1) && (((sqInt) ((void *) _bcpc ) ) == _startbcpc))
		 ? ((sqInt) ((char *) _mcpc ) )
		 : 0);
	if (_result != 0) {
		return _result;
	}
	_bcpc2 = _startbcpc;
	_isInBlock = (_cogMethod->cpicHasMNUCaseOrCMIsFullBlock);
	_homeMethod = ((CogMethod *) _cogMethod );
	assert(_startbcpc == (startPCOfMethodHeader((_homeMethod->methodHeader))));
	_map = (((usqInt) _homeMethod ) + ((_homeMethod->blockSize))) - 1;
	_annotation = ((usqInt) (byteAt(_map)) ) >> AnnotationShift;
	assert((_annotation == IsAbsPCReference) || ((_annotation == IsObjectReference) || ((_annotation == IsRelativeCall) || (_annotation == IsDisplacementX2N))));
	_latestContinuation = _startbcpc;
	_aMethodObj = (_homeMethod->methodObject);
	_endbcpc = (numBytesOf(_aMethodObj)) - 1;
	_bcpc2 += deltaToSkipPrimAndErrorStoreInheader(_aMethodObj, (_homeMethod->methodHeader));
	_nExts = 0;
	{
		enumeratingCogMethod = _homeMethod;
	}
	while ((((usqInt) (byteAt(_map)) ) >> AnnotationShift) != HasBytecodePC) {
		_map -= 1;
	}
	_map -= 1;
	while (((_mapByte = byteAt(_map))) != MapEnd) {
		if (_mapByte >= FirstAnnotation) {
			_annotation = ((usqInt) _mapByte ) >> AnnotationShift;
			_mcpc += (_mapByte & DisplacementMask) * 4;
			if (_annotation >= HasBytecodePC) {
				if ((_annotation == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
					_annotation += _mapByte & DisplacementMask;
					_map -= 1;
				}
				while (1) {
					_byte = fetchByteofObject(_bcpc2, _aMethodObj);
					_descriptor = generatorAt(_byte);
					if (_isInBlock) {
						if (_bcpc2 >= _endbcpc) {
							return 0;
						}
					} else {
						if (((_descriptor->isReturn)) && (_bcpc2 >= _latestContinuation)) {
							return 0;
						}
						if (isBranch(_descriptor)) {
							/* begin latestContinuationPCFor:at:exts:in: */
							_distance = ((_descriptor->spanFunction))(_descriptor, _bcpc2, _nExts, _aMethodObj);
							_targetPC = (_bcpc2 + ((_descriptor->numBytes))) + (((_distance < 0) ? 0 : _distance));
							/* end latestContinuationPCFor:at:exts:in: */
							_latestContinuation = ((_latestContinuation < _targetPC) ? _targetPC : _latestContinuation);
						}
					}
					_nextBcpc = _bcpc2 + ((_descriptor->numBytes));
					if (((_descriptor->isMapped)) || (_isInBlock && ((_descriptor->isMappedInBlock)))) 
						break;
					_bcpc2 = _nextBcpc;
					_nExts = (((_descriptor->isExtension))
						 ? _nExts + 1
						 : 0);
				}
				_isBackwardBranch = (isBranch(_descriptor)) && ((assert(((_descriptor->spanFunction)) != null), (((_descriptor->spanFunction))(_descriptor, _bcpc2, _nExts, _aMethodObj)) < 0));
				_result = findBackwardBranchIsBackwardBranchMcpcBcpcMatchingBcpc(_descriptor, ((_isBackwardBranch)
					 ? ((sqInt) (((usqInt) _annotation ) << 1) ) + 1
					 : ((sqInt) (((usqInt) _annotation ) << 1) )), ((char *) _mcpc ), ((_isBackwardBranch)
					 ? _bcpc2 - (2 * _nExts)
					 : _bcpc2), ((void *) _bcpc ));
				if (_result != 0) {
					return _result;
				}
				_bcpc2 = _nextBcpc;
				_nExts = (((_descriptor->isExtension))
					 ? _nExts + 1
					 : 0);
			}
		} else {
			assert(((((usqInt) _mapByte ) >> AnnotationShift) == IsDisplacementX2N) || ((((usqInt) _mapByte ) >> AnnotationShift) == IsAnnotationExtension));
			if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
				_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
			}
		}
		_map -= 1;
	}
	return 0;
	/* end mapFor:bcpc:performUntil:arg: */
}
/*	For the purposes of become: see if the two methods are similar, i.e. can 
	be safely becommed. 
	This is pretty strict. All literals and bytecodes must be identical. Only 
	trailer bytes and header 
	flags can differ. */
/* Cogit>>#method:hasSameCodeAs:checkPenultimate: */
static sqInt NoDbgRegParms
methodhasSameCodeAscheckPenultimate(sqInt _methodA, sqInt _methodB, sqInt _comparePenultimateLiteral)
{
	sqInt _bi;
	sqInt _endPCA;
	sqInt _headerA;
	sqInt _headerB;
	sqInt _li;
	sqInt _numLitsA;

	_headerA = methodHeaderOf(_methodA);
	_headerB = methodHeaderOf(_methodB);
	_numLitsA = literalCountOfMethodHeader(_headerA);
	_endPCA = endPCOf(_methodA);
	if (((argumentCountOfMethodHeader(_headerA)) != (argumentCountOfMethodHeader(_headerB))) || (((temporaryCountOfMethodHeader(_headerA)) != (temporaryCountOfMethodHeader(_headerB))) || (((primitiveIndexOfMethodheader(_methodA, _headerA)) != (primitiveIndexOfMethodheader(_methodB, _headerB))) || ((_numLitsA != (literalCountOfMethodHeader(_headerB))) || (_endPCA > (numBytesOf(_methodB))))))) {
		return 0;
	}
	for (_li = 1; _li < _numLitsA; _li += 1) {
		if ((fetchPointerofObject(_li, _methodA)) != (fetchPointerofObject(_li, _methodB))) {
			if ((_li < (_numLitsA - 1)) || _comparePenultimateLiteral) {
				return 0;
			}
		}
	}
	for (_bi = startPCOfMethod(_methodA); _bi <= _endPCA; _bi += 1) {
		if ((fetchByteofObject(_bi, _methodA)) != (fetchByteofObject(_bi, _methodB))) {
			return 0;
		}
	}
	return 1;
}
/* Cogit>>#minCogMethodAddress */
sqInt
minCogMethodAddress(void)
{
	return methodZoneBase;
}
/* Cogit>>#mnuOffset */
sqInt
mnuOffset(void)
{
	return missOffset;
}
/* Cogit>>#needsFrameIfImmutability: */
static sqInt NoDbgRegParms
needsFrameIfImmutability(sqInt stackDelta)
{
	return IMMUTABILITY;
}
/* Cogit>>#needsFrameIfInBlock: */
static sqInt NoDbgRegParms
needsFrameIfInBlock(sqInt stackDelta)
{
	return inBlock > 0;
}
/* Cogit>>#needsFrameNever: */
static sqInt NoDbgRegParms
needsFrameNever(sqInt stackDelta)
{
	return 0;
}
/* Cogit>>#noAssertMethodClassAssociationOf: */
static sqInt NoDbgRegParms
noAssertMethodClassAssociationOf(sqInt _methodPointer)
{
	return literalofMethod((literalCountOfMethodHeader(noAssertHeaderOf(_methodPointer))) - 1, _methodPointer);
}
/*	Check that no method is maximally marked. A maximal mark is an indication 
	the method has been scanned to increase the usage count of its referent 
	methods.  */
/* Cogit>>#noCogMethodsMaximallyMarked */
static sqInt
noCogMethodsMaximallyMarked(void)
{
	CogMethod *_cogMethod;

	_cogMethod = ((CogMethod *) methodZoneBase );
	while (_cogMethod < (limitZony())) {
		if ((((_cogMethod->cmType)) != CMFree) && (((_cogMethod->cmUsageCount)) == CMMaxUsageCount)) {
			return 0;
		}
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
	}
	return 1;
}
/*	Answer if all targets in the PIC are in-use methods. */
/* Cogit>>#noTargetsFreeInClosedPIC: */
static sqInt NoDbgRegParms
noTargetsFreeInClosedPIC(CogMethod *_cPIC)
{
	return !(cPICHasFreedTargets(_cPIC));
}
/*	Store the generated machine code, answering the last address */
/* Cogit>>#outputInstructionsAt: */
static sqInt NoDbgRegParms
outputInstructionsAt(sqInt _startAddress)
{
	sqInt _absoluteAddress;
	AbstractInstruction *_abstractInstruction;
	sqInt _i;
	sqInt _j;

	_absoluteAddress = _startAddress;
	for (_i = 0; _i < opcodeIndex; _i += 1) {
		_abstractInstruction = abstractInstructionAt(_i);
		assert(((_abstractInstruction->address)) == _absoluteAddress);
		/* begin outputMachineCodeAt: */
		for (_j = 0; _j < ((_abstractInstruction->machineCodeSize)); _j += 4) {
			uint32AtPointerput(_absoluteAddress + _j, (_abstractInstruction->machineCode)[_j / 4]);
		}
		/* end outputMachineCodeAt: */
		_absoluteAddress += (_abstractInstruction->machineCodeSize);
	}
	return _absoluteAddress;
}
/*	Output instructions generated for one of the generated run-time routines, 
	a trampoline, etc */
/* Cogit>>#outputInstructionsForGeneratedRuntimeAt: */
static sqInt NoDbgRegParms
outputInstructionsForGeneratedRuntimeAt(sqInt _startAddress)
{
	sqInt _endAddress;
	sqInt _size;

	computeMaximumSizes();
	(methodLabel->address = _startAddress);
	_size = generateInstructionsAt(_startAddress);
	_endAddress = outputInstructionsAt(_startAddress);
	assert((_startAddress + _size) == _endAddress);
	methodZoneBase = alignUptoRoutineBoundary(_endAddress);
	stopsFromto(backEnd, _endAddress, methodZoneBase - 1);
	return _startAddress;
}
/* Cogit>>#PushCw: */
static AbstractInstruction * NoDbgRegParms
gPushCw(sqInt _wordConstant)
{
	/* begin gen:literal: */
	return checkLiteralforInstruction(_wordConstant, genoperand(PushCw, _wordConstant));
	/* end gen:literal: */
}
/*	Code entry PIC full or miss to an instance of a young class or to a young 
	target method. 
	Attempt to patch the send site to an megamorphic PIC. 
	Answer if the attempt succeeded; in fact it will 
	 
	Only return if the attempt failed. 
	The stack looks like: 
	receiver 
	args 
	sp=>	sender return address */
/* Cogit>>#patchToMegamorphicICFor:numArgs:receiver: */
sqInt
patchToMegamorphicICFornumArgsreceiver(sqInt _selector, sqInt _numArgs, sqInt _receiver)
{
	sqInt _callerReturnAddress;
	sqInt _extent;
	CogMethod *_oPIC;

	_callerReturnAddress = stackTop();
	_oPIC = openPICWithSelector(_selector);
	if (!_oPIC) {
		/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
		/* begin enableCodeZoneWrite */
		if (jitCodeZoneWriteEnabled) {
			error("Code zone writing is not reentrant");
		}
		
#    if READ_ONLY_CODE_ZONE
		{
			
#      if __APPLE__
			{
				pthread_jit_write_protect_np(0);
			}
#      else /* __APPLE__ */
			{
				sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
			}
#      endif /* __APPLE__ */
		}
#    endif /* READ_ONLY_CODE_ZONE */
		jitCodeZoneWriteEnabled = 1;
		/* end enableCodeZoneWrite */
		{
			_oPIC = cogOpenPICSelectornumArgs(_selector, _numArgs);
		}
		/* begin disableCodeZoneWrite */
		
#    if READ_ONLY_CODE_ZONE
		{
			
#      if __APPLE__
			{
				pthread_jit_write_protect_np(1);
			}
#      else /* __APPLE__ */
			{
				sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
			}
#      endif /* __APPLE__ */
		}
#    endif /* READ_ONLY_CODE_ZONE */
		jitCodeZoneWriteEnabled = 0;
		/* end disableCodeZoneWrite */
		{
			if (!((((sqInt) _oPIC ) >= MaxNegativeErrorCode) && (((sqInt) _oPIC ) <= -1))) {
				flushICacheFromto(((usqInt) _oPIC ), ((usqInt) _oPIC ) + openPICSize);
			}
		}
		/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	}
	if ((((sqInt) _oPIC ) >= MaxNegativeErrorCode) && (((sqInt) _oPIC ) <= -1)) {
		if (((sqInt) _oPIC ) == InsufficientCodeSpace) {
			callForCogCompiledCodeCompaction();
		}
		return 0;
	}
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		_extent = rewriteInlineCacheAttagtarget(backEnd, _callerReturnAddress, inlineCacheValueForSelectorinat(_selector, mframeHomeMethodExport(), _callerReturnAddress), ((sqInt) _oPIC ) + cmEntryOffset);
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		flushICacheFromto(((usqInt) _callerReturnAddress ) - _extent, ((usqInt) _callerReturnAddress ));
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	executeCogMethodfromLinkedSendWithReceiver(_oPIC, _receiver);
	return (assert(0), null);
}
/*	The PIC starts with a header of meta-data followed by machine code. 
	The first thing in the machine code stream is the abort section. */
/* Cogit>>#picAbortAddress: */
static usqIntptr_t NoDbgRegParms
picAbortAddress(CogMethod *_cPIC)
{
	return ((sqInt) _cPIC ) + (sizeof(CogMethod));
}
/*	Answer the start of the abort sequence for invoking the interpreter in a 
	closed PIC. */
/* Cogit>>#picInterpretAbortOffset */
static sqInt
picInterpretAbortOffset(void)
{
	return (interpretOffset()) - ((pushLinkRegisterByteSize(backEnd)) + (callInstructionByteSize(backEnd)));
}
/* Cogit>>#printCogMethodFor: */
void
printCogMethodFor(void *_address)
{
	CogMethod *_cogMethod;

	_cogMethod = methodFor(_address);
	if (_cogMethod == 0) {
		if ((codeEntryFor(_address)) == null) {
			{
				print("not a method");
				cr();
			}
		} else {
			{
				print("trampoline ");
				print(codeEntryNameFor(_address));
				cr();
			}
		}
	} else {
		printCogMethod(_cogMethod);
	}
}
/* Cogit>>#printTrampolineTable */
void
printTrampolineTable(void)
{
	sqInt _i;

	for (_i = 0; _i < trampolineTableIndex; _i += 2) {
		{
			printHex(((sqInt) (trampolineAddresses[_i + 1]) ));
			print(": ");
			print(((char *) (trampolineAddresses[_i]) ));
			cr();
		}
	}
}
/* Cogit>>#printWhereIs: */
void
printWhereIs(void *_address)
{
	CogMethod *_cogMethod;
	sqInt _s;
	char * _trampAddr;

	_cogMethod = methodFor(_address);
	if (_cogMethod == 0) {
		_trampAddr = codeEntryFor(_address);
		if (_trampAddr == null) {
			{
				printHex(((sqInt) _address ));
				print(" not in the code zone");
				cr();
			}
		} else {
			{
				printHex(((sqInt) _address ));
				print(" in trampoline ");
				print(codeEntryNameFor(_address));
				print(" (starting at address ");
				printHexnp(_trampAddr);
				print(")");
				cr();
			}
		}
	} else {
		{
			printHex(((sqInt) _address ));
			print(" in cog method ");
		}
		if (((_cogMethod->selector)) == (nilObject())) {
			if ((((_cogMethod->cmType)) == CMMethod) && (((_s = maybeSelectorOfMethod((_cogMethod->methodObject)))) != null)) {
				{
					print("(nil: ");
					printStringOf(_s);
					print(")");
				}
			} else {
				print("(nil)");
			}
		} else {
			printStringOf((_cogMethod->selector));
		}
		{
			print(" (starting at address ");
			printHexnp(((sqInt) _cogMethod ));
			print(")");
			cr();
		}
	}
}
/* Cogit>>#processorHasDivQuoRemAndMClassIsSmallInteger */
static sqInt
processorHasDivQuoRemAndMClassIsSmallInteger(void)
{
	return mclassIsSmallInteger();
}
/* Cogit>>#processorHasMultiplyAndMClassIsSmallInteger */
static sqInt
processorHasMultiplyAndMClassIsSmallInteger(void)
{
	return mclassIsSmallInteger();
}
/* Cogit>>#recordGeneratedRunTime:address: */
static void NoDbgRegParms
recordGeneratedRunTimeaddress(char *_aString, sqInt _address)
{
	{
		trampolineAddresses[trampolineTableIndex] = _aString;
		trampolineAddresses[trampolineTableIndex + 1] = ((char *) _address );
	}
	trampolineTableIndex += 2;
}
/*	This one for C support code. */
/* Cogit>>#recordPrimTraceFunc */
sqInt
recordPrimTraceFunc(void)
{
	return recordPrimTrace();
}
/* Cogit>>#recordRunTimeObjectReferences */
static void
recordRunTimeObjectReferences(void)
{
	sqInt _i;
	AbstractInstruction *_instruction;

	for (_i = 0; _i < opcodeIndex; _i += 1) {
		_instruction = abstractInstructionAt(_i);
		if (((_instruction->annotation)) == IsObjectReference) {
			assert(runtimeObjectRefIndex < NumObjRefsInRuntime);
			assert(!hasYoungReferent);
			if (hasYoungReferent) {
				error("attempt to generate run-time routine containing young object reference.  Cannot initialize Cogit run-time.");
			}
			objectReferencesInRuntime[runtimeObjectRefIndex] = ((usqInt) (((((_instruction->opcode)) == Literal)
				 ? (_instruction->address)
				 : ((_instruction->address)) + ((_instruction->machineCodeSize)))) );
			runtimeObjectRefIndex += 1;
		}
	}
}
/* Cogit>>#registerMaskFor: */
static sqInt NoDbgRegParms
registerMaskFor(sqInt _reg)
{
	return 1ULL << _reg;
}
/* Cogit>>#registerMaskFor:and: */
static sqInt NoDbgRegParms
registerMaskForand(sqInt _reg1, sqInt _reg2)
{
	return (1ULL << _reg1) | (1ULL << _reg2);
}
/* Cogit>>#relocateCallsAndSelfReferencesInMethod: */
static void NoDbgRegParms
relocateCallsAndSelfReferencesInMethod(CogMethod *_cogMethod)
{
	sqInt _annotation;
	sqInt _callDelta;
	usqInt _map;
	sqInt _mapByte;
	sqInt _mcpc;
	sqLong _refDelta;
	sqInt _result;

	_refDelta = (_cogMethod->objectHeader);
	_callDelta = _refDelta;
	assert((((_cogMethod->cmType)) == CMMethod) || (((_cogMethod->cmType)) == CMMegamorphicIC));
	assert((callTargetFromReturnAddress(backEnd, ((sqInt) _cogMethod ) + missOffset)) == (((((_cogMethod->cmType)) == CMMethod)
		 ? methodAbortTrampolineFor((_cogMethod->cmNumArgs))
		 : picAbortTrampolineFor((_cogMethod->cmNumArgs)))));
	relocateCallBeforeReturnPCby(backEnd, ((sqInt) _cogMethod ) + missOffset, -_callDelta);
	/* begin mapFor:performUntil:arg: */
	/* begin firstMappedPCFor: */
	_mcpc = (((_cogMethod->cpicHasMNUCaseOrCMIsFullBlock))
		 ? ((usqInt) _cogMethod ) + cbNoSwitchEntryOffset
		 : ((usqInt) _cogMethod ) + cmNoCheckEntryOffset);
	/* end firstMappedPCFor: */
	_map = (((usqInt) _cogMethod ) + ((_cogMethod->blockSize))) - 1;
	{
		enumeratingCogMethod = _cogMethod;
	}
	while (((_mapByte = byteAt(_map))) != MapEnd) {
		if (_mapByte >= FirstAnnotation) {
			_mcpc += (_mapByte & DisplacementMask) * 4;
			if ((((_annotation = ((usqInt) _mapByte ) >> AnnotationShift)) == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
				_annotation += _mapByte & DisplacementMask;
				_map -= 1;
			}
			_result = relocateIfCallOrMethodReferencemcpcdelta(_annotation, ((char *) _mcpc ), _refDelta);
			if (_result != 0) {
				goto l3;
			}
		} else {
			if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
				_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
			}
		}
		_map -= 1;
	}
	l3:
	;
	/* end mapFor:performUntil:arg: */
}
/* Cogit>>#relocateCallsInClosedPIC: */
static void NoDbgRegParms
relocateCallsInClosedPIC(CogMethod *_cPIC)
{
	sqInt _callDelta;
	sqInt _entryPoint;
	sqInt _i;
	sqInt _pc;
	sqLong _refDelta;
	CogMethod *_targetMethod;

	_refDelta = (_cPIC->objectHeader);
	_callDelta = _refDelta;
	assert((callTargetFromReturnAddress(backEnd, ((sqInt) _cPIC ) + missOffset)) == (picAbortTrampolineFor((_cPIC->cmNumArgs))));
	relocateCallBeforeReturnPCby(backEnd, ((sqInt) _cPIC ) + missOffset, -_callDelta);
	_pc = ((sqInt) _cPIC ) + firstCPICCaseOffset;
	for (_i = 1; _i <= ((_cPIC->cPICNumCases)); _i += 1) {
		_pc = addressOfEndOfCaseinCPIC(_i, _cPIC);
		if (_i == 1) {
			_entryPoint = jumpLongTargetBeforeFollowingAddress(backEnd, _pc);
		} else {
			/* begin jumpLongConditionalTargetBeforeFollowingAddress: */
			_entryPoint = jumpLongTargetBeforeFollowingAddress(((AbstractInstruction *) backEnd ), _pc);
			/* end jumpLongConditionalTargetBeforeFollowingAddress: */
		}
		if ((((usqInt) _cPIC ) <= ((usqInt) _entryPoint )) && ((((usqInt) _cPIC ) + ((_cPIC->blockSize))) >= ((usqInt) _entryPoint ))) {
		} else {
			_targetMethod = ((CogMethod *) (_entryPoint - cmNoCheckEntryOffset) );
			assert(((_targetMethod->cmType)) == CMMethod);
			if (_i == 1) {
				relocateJumpLongBeforeFollowingAddressby(backEnd, _pc, -(_callDelta - ((_targetMethod->objectHeader))));
			}
 else {
				relocateJumpLongConditionalBeforeFollowingAddressby(backEnd, _pc, -(_callDelta - ((_targetMethod->objectHeader))));
			}
		}
	}
	assert(((_cPIC->cPICNumCases)) > 0);
	relocateMethodReferenceBeforeAddressby(backEnd, (addressOfEndOfCaseinCPIC(2, _cPIC)) + (loadPICLiteralByteSize(backEnd)), _refDelta);
	relocateJumpLongBeforeFollowingAddressby(backEnd, ((sqInt) _cPIC ) + cPICEndOfCodeOffset, -_callDelta);
}
/* Cogit>>#relocateIfCallOrMethodReference:mcpc:delta: */
static sqInt NoDbgRegParms
relocateIfCallOrMethodReferencemcpcdelta(sqInt _annotation, char *_mcpc, sqInt _refDelta)
{
	sqInt _callDelta;
	sqInt _entryPoint;
	sqInt _offset2;
	sqInt *_sendTable2;
	CogMethod *_targetMethod;
	sqInt _unlinkedRoutine;

	_callDelta = _refDelta;
	if (_annotation >= IsSendCall) {
		_entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt) _mcpc ));
		if (_entryPoint <= methodZoneBase) {
			relocateCallBeforeReturnPCby(backEnd, ((sqInt) _mcpc ), -_callDelta);
			return 0;
		}
		/* begin offsetAndSendTableFor:annotation:into: */
		if (_annotation == IsSendCall) {
			_offset2 = cmEntryOffset;
			_sendTable2 = ordinarySendTrampolines;
		} else {
			if (_annotation == IsDirectedSuperSend) {
				_offset2 = cmNoCheckEntryOffset;
				_sendTable2 = directedSuperSendTrampolines;
			} else {
				if (_annotation == IsDirectedSuperBindingSend) {
					_offset2 = cmNoCheckEntryOffset;
					_sendTable2 = directedSuperBindingSendTrampolines;
				} else {
					assert(_annotation == IsSuperSend);
					_offset2 = cmNoCheckEntryOffset;
					_sendTable2 = superSendTrampolines;
				}
			}
		}
		{
			_targetMethod = ((CogMethod *) (_entryPoint - _offset2) );
			if (((_targetMethod->cmType)) != CMFree) {
				relocateCallBeforeReturnPCby(backEnd, ((sqInt) _mcpc ), -(_callDelta - ((_targetMethod->objectHeader))));
				return 0;
			}
			_unlinkedRoutine = _sendTable2[((((_targetMethod->cmNumArgs)) < (NumSendTrampolines - 1)) ? (_targetMethod->cmNumArgs) : NumSendTrampolines - 1)];
			rewriteInlineCacheAttagtarget(backEnd, ((sqInt) _mcpc ), indexForSelectorinat((_targetMethod->selector), enumeratingCogMethod, _mcpc), _unlinkedRoutine - _callDelta);
			return 0;
		}
		/* end offsetAndSendTableFor:annotation:into: */
	}
	if (_annotation == IsRelativeCall) {
		relocateCallBeforeReturnPCby(backEnd, ((sqInt) _mcpc ), -_callDelta);
		return 0;
	}
	if (_annotation == IsAbsPCReference) {
		relocateMethodReferenceBeforeAddressby(backEnd, ((sqInt) _mcpc ), _refDelta);
		return 0;
	}
	return 0;
}
/* Cogit>>#remapIfObjectRef:pc:hasYoung: */
static sqInt NoDbgRegParms
remapIfObjectRefpchasYoung(sqInt _annotation, char *_mcpc, sqInt _hasYoungPtr)
{
	usqInt _cacheTag2;
	sqInt _callSiteReturnAddress;
	sqInt _entryPoint2;
	sqInt _literal;
	sqInt _mappedCacheTag;
	sqInt _mappedLiteral;
	sqInt _offset2;
	sqInt _tagCouldBeObj2;
	CogMethod * _targetCogCode;

	if (_annotation == IsObjectReference) {
		_literal = unsignedLongAt(((usqInt) _mcpc ));
		if (couldBeObject(_literal)) {
			_mappedLiteral = remapObject(_literal);
			if (_literal != _mappedLiteral) {
				/* begin storeLiteral:atAnnotatedAddress:using: */
				unsignedLongAtput(((usqInt) _mcpc ), _mappedLiteral);
				/* end storeLiteral:atAnnotatedAddress:using: */
				codeModified = 1;
			}
			if ((_hasYoungPtr != 0) && (isYoung(_mappedLiteral))) {
				(((sqInt *) _hasYoungPtr ))[0] = 1;
			}
		}
	}
	if (_annotation >= IsSendCall) {
		/* begin entryCacheTagAndCouldBeObjectAt:annotation:into: */
		_cacheTag2 = inlineCacheTagAt(backEnd, ((sqInt) _mcpc ));
		_entryPoint2 = callTargetFromReturnAddress(backEnd, ((sqInt) _mcpc ));
		_tagCouldBeObj2 = 0;
		{
			if (_tagCouldBeObj2 && (couldBeObject(_cacheTag2))) {
				_mappedCacheTag = remapObject(_cacheTag2);
				if (_cacheTag2 != _mappedCacheTag) {
					/* begin rewriteInlineCacheTag:at: */
					_callSiteReturnAddress = ((usqInt) _mcpc );
					longAtput(pcRelativeAddressAt(((AbstractInstruction *) backEnd ), _callSiteReturnAddress - 8), _mappedCacheTag);
					/* end rewriteInlineCacheTag:at: */
					codeModified = 1;
				}
				if ((_hasYoungPtr != 0) && (isYoung(_mappedCacheTag))) {
					(((sqInt *) _hasYoungPtr ))[0] = 1;
				}
			}
			if (_hasYoungPtr != 0) {
				if (_entryPoint2 > methodZoneBase) {
					/* begin targetMethodAndSendTableFor:annotation:into: */
					/* begin offsetAndSendTableFor:annotation:into: */
					if (_annotation == IsSendCall) {
						_offset2 = cmEntryOffset;
					} else {
						if (_annotation == IsDirectedSuperSend) {
							_offset2 = cmNoCheckEntryOffset;
						} else {
							if (_annotation == IsDirectedSuperBindingSend) {
								_offset2 = cmNoCheckEntryOffset;
							} else {
								assert(_annotation == IsSuperSend);
								_offset2 = cmNoCheckEntryOffset;
							}
						}
					}
					{
						_targetCogCode = ((CogMethod *) (_entryPoint2 - _offset2) );
						{
							if (isYoung((_targetCogCode->selector))) {
								(((sqInt *) _hasYoungPtr ))[0] = 1;
							}
						}
					}
					/* end offsetAndSendTableFor:annotation:into: */
					/* end targetMethodAndSendTableFor:annotation:into: */
				}
			}
		}
		/* end entryCacheTagAndCouldBeObjectAt:annotation:into: */
	}
	return 0;
}
/*	Remap a potential object reference from a closed PIC. 
	This may be an object reference, an inline cache tag or null. 
	Answer if the updated literal is young. 
	mcpc is the address of the next instruction following either 
	the load of the method literal or the compare of the class tag. */
/* Cogit>>#remapMaybeObjRefInClosedPICAt: */
static sqInt NoDbgRegParms
remapMaybeObjRefInClosedPICAt(sqInt _mcpc)
{
	sqInt _object;
	sqInt _subject;

	_object = literalBeforeFollowingAddress(backEnd, _mcpc);
	if (!(couldBeObject(_object))) {
		return 0;
	}
	_subject = remapOop(_object);
	if (_object != _subject) {
		storeLiteralbeforeFollowingAddress(backEnd, _subject, _mcpc);
		codeModified = 1;
	}
	return isYoungObject(getMemoryMap(), _subject);
}
/*	Rewrite the three values involved in a CPIC case. Used by the initialize & 
	extend CPICs. 
	c.f. expectedClosedPICPrototype:write the obj ref/operand via the second ldr */
/* Cogit>>#rewritePICCaseAt:tag:objRef:target: */
static void NoDbgRegParms
rewritePICCaseAttagobjReftarget(sqInt _followingAddress, sqInt _newTag, sqInt _newObjRef, sqInt _newTarget)
{
	sqInt _classTagPC;
	sqInt _methodObjPC;

	_methodObjPC = (_followingAddress - (jumpLongConditionalByteSize(backEnd))) - (cmpC32RTempByteSize(backEnd));
	storeLiteralbeforeFollowingAddress(backEnd, _newObjRef, _methodObjPC);
	_classTagPC = _followingAddress - (jumpLongConditionalByteSize(backEnd));
	/* begin storeLiteral32:beforeFollowingAddress: */
	storeLiteralbeforeFollowingAddress(((AbstractInstruction *) backEnd ), _newTag, _classTagPC);
	/* end storeLiteral32:beforeFollowingAddress: */
	rewriteJumpLongAttarget(backEnd, _followingAddress, _newTarget);
}
/* Cogit>>#St1S:Vr:R:Mw: */

#if FEATURE_JIT_SIMD
static AbstractInstruction * NoDbgRegParms
gSt1SVrRMw(sqInt _aSize, sqInt _aVectorRegister, sqInt _aMemoryRegister, sqInt _anOffset)
{
	return genoperandoperandoperandoperand(St1VrRMw, _aSize, _aVectorRegister, _aMemoryRegister, _anOffset);
}
#endif /* FEATURE_JIT_SIMD */
/* Cogit>>#SubCw:R: */
static AbstractInstruction * NoDbgRegParms
gSubCwR(sqInt _wordConstant, sqInt _reg)
{
	/* begin gen:literal:operand: */
	return checkLiteralforInstruction(_wordConstant, genoperandoperand(SubCwR, _wordConstant, _reg));
	/* end gen:literal:operand: */
}
/*	Free the method as paremeter taking care of enabling/disabling the code 
	zone. To be used by the interpreter and by usages that are not already 
	enabling code zone writing */
/* Cogit>>#safeFreeMethod: */
void
safeFreeMethod(sqInt _cogMethod)
{
	/* begin enableCodeZoneWriteDuring: */
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		freeMethod(_cogMethod);
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	/* end enableCodeZoneWriteDuring: */
}
/*	Change a JIT'ed method's header, enabling code zone wrote. */
/* Cogit>>#setHeaderOopOf:to: */
void
setHeaderOopOfto(CogMethod *_cogMethod, sqInt _aMethodHeaderOop)
{
	assert(((_cogMethod->cmType)) == CMMethod);
	/* begin enableCodeZoneWriteDuring: */
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		(_cogMethod->methodHeader = _aMethodHeaderOop);
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	/* end enableCodeZoneWriteDuring: */
}
/* Cogit>>#setPostCompileHook: */
void
setPostCompileHook(void (*_aFunction)(CogMethod *))
{
	postCompileHook = _aFunction;
}
/*	If a method is compiled to machine code via a block entry it won't have a 
	selector. A subsequent send can find the method and hence fill in the 
	selector.  */
/* Cogit>>#setSelectorOf:to: */
void
setSelectorOfto(CogMethod *_cogMethod, sqInt _aSelectorOop)
{
	assert(((_cogMethod->cmType)) == CMMethod);
	/* begin enableCodeZoneWriteDuring: */
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		(_cogMethod->selector = _aSelectorOop);
		if (isYoung(_aSelectorOop)) {
			ensureInYoungReferrers(_cogMethod);
		}
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	/* end enableCodeZoneWriteDuring: */
}
/* Cogit>>#sizeOfTrampoline: */
int
sizeOfTrampoline(char *_address)
{
	sqInt _i;

	for (_i = 0; _i <= (trampolineTableIndex - 3); _i += 2) {
		if (_address == (trampolineAddresses[_i + 1])) {
			if (((_i + 3) > NumTrampolines) * 2) {
				return (methodZoneBase()) - ((sqInt) (trampolineAddresses[_i + 1]) );
			}
			return ((sqInt) (trampolineAddresses[_i + 3]) ) - ((sqInt) (trampolineAddresses[_i + 1]) );
		}
	}
	return 0;
}
/*	Answer a fake value for the method oop in other than the first case in the 
	PIC prototype. 
	Since we use MoveUniqueCw:R: it must not be confused with a 
	method-relative address. */
/* Cogit>>#subsequentPrototypeMethodOop */
static sqInt
subsequentPrototypeMethodOop(void)
{
	return (((((usqInt) 195929424 ) >= ((methodLabel->address))) && (((usqInt) 195929424 ) < (youngReferrers())))
		 ? 233496237
		 : 195929424);
}
/* Cogit>>#TstCq:R: */
static AbstractInstruction * NoDbgRegParms
gTstCqR(sqInt _quickConstant, sqInt _reg)
{
	AbstractInstruction *_anInstruction;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(TstCqR, _quickConstant, _reg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_quickConstant));
	}
	return _anInstruction;
	/* end checkQuickConstant:forInstruction: */
}
/* Cogit>>#traceLinkedSendOffset */
sqInt
traceLinkedSendOffset(void)
{
	return (cmNoCheckEntryOffset + (callInstructionByteSize(backEnd))) + (pushLinkRegisterByteSize(backEnd));
}
/*	Encode true and false and 0 to N such that they can't be confused for 
	register numbers (including NoReg) 
	and can be tested for by isTrampolineArgConstant: and decoded by 
	trampolineArgValue:  */
/* Cogit>>#trampolineArgConstant: */
static sqInt NoDbgRegParms
trampolineArgConstant(sqInt _booleanOrInteger)
{
	assert(_booleanOrInteger >= 0);
	return -2 - _booleanOrInteger;
}
/* Cogit>>#trampolineName:numArgs: */
static char * NoDbgRegParms
trampolineNamenumArgs(char *_routinePrefix, sqInt _numArgs)
{
	char *_theString;

	/* begin trampolineName:numArgs:limit: */
	_theString = malloc((strlen(_routinePrefix)) + 6);
	sprintf(_theString, "%s%cArgs", _routinePrefix, ((((int) _numArgs ) <= (NumSendTrampolines - 2))
		 ? '0' + ((int) _numArgs )
		 : 'N'));
	return _theString;
	/* end trampolineName:numArgs:limit: */
}
/*	Malloc a string with the contents for the trampoline table */
/* Cogit>>#trampolineName:numArgs:limit: */
static char * NoDbgRegParms
trampolineNamenumArgslimit(char *_routinePrefix, int _numArgs, sqInt _argsLimit)
{
	char *_theString;

	_theString = malloc((strlen(_routinePrefix)) + 6);
	sprintf(_theString, "%s%cArgs", _routinePrefix, ((_numArgs <= _argsLimit)
		 ? '0' + _numArgs
		 : 'N'));
	return _theString;
}
/* Cogit>>#trampolineName:numRegArgs: */
static char * NoDbgRegParms
trampolineNamenumRegArgs(char *_routinePrefix, sqInt _numArgs)
{
	sqInt _argsLimit;
	char *_theString;

	/* begin trampolineName:numArgs:limit: */
	_argsLimit = 2;
	_theString = malloc((strlen(_routinePrefix)) + 6);
	sprintf(_theString, "%s%cArgs", _routinePrefix, ((((int) _numArgs ) <= _argsLimit)
		 ? '0' + ((int) _numArgs )
		 : 'N'));
	return _theString;
	/* end trampolineName:numArgs:limit: */
}
/* Cogit>>#unknownBytecode */
static sqInt
unknownBytecode(void)
{
	return EncounteredUnknownBytecode;
}
/*	Unlink all sends in cog methods. */
/* Cogit>>#unlinkAllSends */
void
unlinkAllSends(void)
{
	sqInt _annotation;
	CogMethod *_cogMethod;
	usqInt _map;
	sqInt _mapByte;
	sqInt _mcpc;
	sqInt _result;

	if (!methodZoneBase) {
		return;
	}
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		_cogMethod = ((CogMethod *) methodZoneBase );
		voidOpenPICList();
		while (_cogMethod < (limitZony())) {
			if (((_cogMethod->cmType)) == CMMethod) {
				/* begin mapFor:performUntil:arg: */
				/* begin firstMappedPCFor: */
				_mcpc = (((_cogMethod->cpicHasMNUCaseOrCMIsFullBlock))
					 ? ((usqInt) _cogMethod ) + cbNoSwitchEntryOffset
					 : ((usqInt) _cogMethod ) + cmNoCheckEntryOffset);
				/* end firstMappedPCFor: */
				_map = (((usqInt) _cogMethod ) + ((_cogMethod->blockSize))) - 1;
				{
					enumeratingCogMethod = _cogMethod;
				}
				while (((_mapByte = byteAt(_map))) != MapEnd) {
					if (_mapByte >= FirstAnnotation) {
						_mcpc += (_mapByte & DisplacementMask) * 4;
						if ((((_annotation = ((usqInt) _mapByte ) >> AnnotationShift)) == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
							_annotation += _mapByte & DisplacementMask;
							_map -= 1;
						}
						_result = unlinkIfLinkedSendpcignored(_annotation, ((char *) _mcpc ), 0);
						if (_result != 0) {
							goto l4;
						}
					} else {
						if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
							_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
						}
					}
					_map -= 1;
				}
				l4:
				;
				/* end mapFor:performUntil:arg: */
			} else {
				if (((_cogMethod->cmType)) != CMFree) {
					freeMethod(_cogMethod);
				}
			}
			_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		}
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		if (((usqInt) methodZoneBase ) < ((usqInt) (limitZony()) )) {
			flushICacheFromto(((usqInt) methodZoneBase ), ((usqInt) (limitZony()) ));
		}
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
}
/* Cogit>>#unlinkIfFreeOrLinkedSend:pc:of: */
static sqInt NoDbgRegParms
unlinkIfFreeOrLinkedSendpcof(sqInt _annotation, char *_mcpc, sqInt _theSelector)
{
	sqInt _entryPoint;
	sqInt _offset2;
	sqInt *_sendTable2;
	CogMethod * _targetCogCode;
	sqInt _unlinkedRoutine;

	if (_annotation >= IsSendCall) {
		_entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt) _mcpc ));
		if (_entryPoint > methodZoneBase) {
			/* begin targetMethodAndSendTableFor:annotation:into: */
			/* begin offsetAndSendTableFor:annotation:into: */
			if (_annotation == IsSendCall) {
				_offset2 = cmEntryOffset;
				_sendTable2 = ordinarySendTrampolines;
			} else {
				if (_annotation == IsDirectedSuperSend) {
					_offset2 = cmNoCheckEntryOffset;
					_sendTable2 = directedSuperSendTrampolines;
				} else {
					if (_annotation == IsDirectedSuperBindingSend) {
						_offset2 = cmNoCheckEntryOffset;
						_sendTable2 = directedSuperBindingSendTrampolines;
					} else {
						assert(_annotation == IsSuperSend);
						_offset2 = cmNoCheckEntryOffset;
						_sendTable2 = superSendTrampolines;
					}
				}
			}
			{
				_targetCogCode = ((CogMethod *) (_entryPoint - _offset2) );
				{
					if ((((_targetCogCode->cmType)) == CMFree) || (((_targetCogCode->selector)) == _theSelector)) {
						/* begin unlinkSendAt:targetMethod:sendTable: */
						_unlinkedRoutine = _sendTable2[((((_targetCogCode->cmNumArgs)) < (NumSendTrampolines - 1)) ? (_targetCogCode->cmNumArgs) : NumSendTrampolines - 1)];
						rewriteInlineCacheAttagtarget(backEnd, ((sqInt) _mcpc ), inlineCacheValueForSelectorinat((_targetCogCode->selector), enumeratingCogMethod, _mcpc), _unlinkedRoutine);
						codeModified = 1;
						/* end unlinkSendAt:targetMethod:sendTable: */
					}
				}
			}
			/* end offsetAndSendTableFor:annotation:into: */
			/* end targetMethodAndSendTableFor:annotation:into: */
		}
	}
	return 0;
}
/* Cogit>>#unlinkIfInvalidClassSend:pc:ignored: */
static sqInt NoDbgRegParms
unlinkIfInvalidClassSendpcignored(sqInt _annotation, char *_mcpc, sqInt superfluity)
{
	sqInt _entryPoint;
	sqInt _offset2;
	sqInt *_sendTable2;
	CogMethod * _targetCogCode;
	sqInt _unlinkedRoutine;

	if (_annotation >= IsSendCall) {
		_entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt) _mcpc ));
		if (_entryPoint > methodZoneBase) {
			/* begin targetMethodAndSendTableFor:annotation:into: */
			/* begin offsetAndSendTableFor:annotation:into: */
			if (_annotation == IsSendCall) {
				_offset2 = cmEntryOffset;
				_sendTable2 = ordinarySendTrampolines;
			} else {
				if (_annotation == IsDirectedSuperSend) {
					_offset2 = cmNoCheckEntryOffset;
					_sendTable2 = directedSuperSendTrampolines;
				} else {
					if (_annotation == IsDirectedSuperBindingSend) {
						_offset2 = cmNoCheckEntryOffset;
						_sendTable2 = directedSuperBindingSendTrampolines;
					} else {
						assert(_annotation == IsSuperSend);
						_offset2 = cmNoCheckEntryOffset;
						_sendTable2 = superSendTrampolines;
					}
				}
			}
			{
				_targetCogCode = ((CogMethod *) (_entryPoint - _offset2) );
				{
					if (!(((_annotation == IsSuperSend) || ((_annotation >= IsDirectedSuperSend) && (_annotation <= IsDirectedSuperBindingSend))) || (((_targetCogCode->cmType)) == CMMegamorphicIC))) {
						if (!(isValidClassTag(inlineCacheTagAt(backEnd, ((sqInt) _mcpc ))))) {
							/* begin unlinkSendAt:targetMethod:sendTable: */
							_unlinkedRoutine = _sendTable2[((((_targetCogCode->cmNumArgs)) < (NumSendTrampolines - 1)) ? (_targetCogCode->cmNumArgs) : NumSendTrampolines - 1)];
							rewriteInlineCacheAttagtarget(backEnd, ((sqInt) _mcpc ), inlineCacheValueForSelectorinat((_targetCogCode->selector), enumeratingCogMethod, _mcpc), _unlinkedRoutine);
							codeModified = 1;
							/* end unlinkSendAt:targetMethod:sendTable: */
						}
					}
				}
			}
			/* end offsetAndSendTableFor:annotation:into: */
			/* end targetMethodAndSendTableFor:annotation:into: */
		}
	}
	return 0;
}
/* Cogit>>#unlinkIfLinkedSendToFree:pc:ignored: */
static sqInt NoDbgRegParms
unlinkIfLinkedSendToFreepcignored(sqInt _annotation, char *_mcpc, sqInt superfluity)
{
	sqInt _entryPoint;
	sqInt _offset2;
	sqInt *_sendTable2;
	CogMethod * _targetCogCode;
	sqInt _unlinkedRoutine;

	if (_annotation >= IsSendCall) {
		_entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt) _mcpc ));
		if (_entryPoint > methodZoneBase) {
			/* begin targetMethodAndSendTableFor:annotation:into: */
			/* begin offsetAndSendTableFor:annotation:into: */
			if (_annotation == IsSendCall) {
				_offset2 = cmEntryOffset;
				_sendTable2 = ordinarySendTrampolines;
			} else {
				if (_annotation == IsDirectedSuperSend) {
					_offset2 = cmNoCheckEntryOffset;
					_sendTable2 = directedSuperSendTrampolines;
				} else {
					if (_annotation == IsDirectedSuperBindingSend) {
						_offset2 = cmNoCheckEntryOffset;
						_sendTable2 = directedSuperBindingSendTrampolines;
					} else {
						assert(_annotation == IsSuperSend);
						_offset2 = cmNoCheckEntryOffset;
						_sendTable2 = superSendTrampolines;
					}
				}
			}
			{
				_targetCogCode = ((CogMethod *) (_entryPoint - _offset2) );
				{
					if (((_targetCogCode->cmType)) == CMFree) {
						/* begin unlinkSendAt:targetMethod:sendTable: */
						_unlinkedRoutine = _sendTable2[((((_targetCogCode->cmNumArgs)) < (NumSendTrampolines - 1)) ? (_targetCogCode->cmNumArgs) : NumSendTrampolines - 1)];
						rewriteInlineCacheAttagtarget(backEnd, ((sqInt) _mcpc ), inlineCacheValueForSelectorinat((_targetCogCode->selector), enumeratingCogMethod, _mcpc), _unlinkedRoutine);
						codeModified = 1;
						/* end unlinkSendAt:targetMethod:sendTable: */
					}
				}
			}
			/* end offsetAndSendTableFor:annotation:into: */
			/* end targetMethodAndSendTableFor:annotation:into: */
		}
	}
	return 0;
}
/* Cogit>>#unlinkIfLinkedSend:pc:ignored: */
static sqInt NoDbgRegParms
unlinkIfLinkedSendpcignored(sqInt _annotation, char *_mcpc, sqInt superfluity)
{
	sqInt _entryPoint;
	sqInt _offset2;
	sqInt *_sendTable2;
	CogMethod * _targetCogCode;
	sqInt _unlinkedRoutine;

	if (_annotation >= IsSendCall) {
		_entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt) _mcpc ));
		if (_entryPoint > methodZoneBase) {
			/* begin targetMethodAndSendTableFor:annotation:into: */
			/* begin offsetAndSendTableFor:annotation:into: */
			if (_annotation == IsSendCall) {
				_offset2 = cmEntryOffset;
				_sendTable2 = ordinarySendTrampolines;
			} else {
				if (_annotation == IsDirectedSuperSend) {
					_offset2 = cmNoCheckEntryOffset;
					_sendTable2 = directedSuperSendTrampolines;
				} else {
					if (_annotation == IsDirectedSuperBindingSend) {
						_offset2 = cmNoCheckEntryOffset;
						_sendTable2 = directedSuperBindingSendTrampolines;
					} else {
						assert(_annotation == IsSuperSend);
						_offset2 = cmNoCheckEntryOffset;
						_sendTable2 = superSendTrampolines;
					}
				}
			}
			{
				_targetCogCode = ((CogMethod *) (_entryPoint - _offset2) );
				{
					/* begin unlinkSendAt:targetMethod:sendTable: */
					_unlinkedRoutine = _sendTable2[((((_targetCogCode->cmNumArgs)) < (NumSendTrampolines - 1)) ? (_targetCogCode->cmNumArgs) : NumSendTrampolines - 1)];
					rewriteInlineCacheAttagtarget(backEnd, ((sqInt) _mcpc ), inlineCacheValueForSelectorinat((_targetCogCode->selector), enumeratingCogMethod, _mcpc), _unlinkedRoutine);
					codeModified = 1;
					/* end unlinkSendAt:targetMethod:sendTable: */
				}
			}
			/* end offsetAndSendTableFor:annotation:into: */
			/* end targetMethodAndSendTableFor:annotation:into: */
		}
	}
	return 0;
}
/* Cogit>>#unlinkIfLinkedSend:pc:to: */
static sqInt NoDbgRegParms
unlinkIfLinkedSendpcto(sqInt _annotation, char *_mcpc, sqInt _theCogMethod)
{
	sqInt _entryPoint;
	sqInt _offset2;
	sqInt *_sendTable2;
	CogMethod * _targetCogCode;
	sqInt _unlinkedRoutine;

	if (_annotation >= IsSendCall) {
		_entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt) _mcpc ));
		if (_entryPoint > methodZoneBase) {
			/* begin targetMethodAndSendTableFor:annotation:into: */
			/* begin offsetAndSendTableFor:annotation:into: */
			if (_annotation == IsSendCall) {
				_offset2 = cmEntryOffset;
				_sendTable2 = ordinarySendTrampolines;
			} else {
				if (_annotation == IsDirectedSuperSend) {
					_offset2 = cmNoCheckEntryOffset;
					_sendTable2 = directedSuperSendTrampolines;
				} else {
					if (_annotation == IsDirectedSuperBindingSend) {
						_offset2 = cmNoCheckEntryOffset;
						_sendTable2 = directedSuperBindingSendTrampolines;
					} else {
						assert(_annotation == IsSuperSend);
						_offset2 = cmNoCheckEntryOffset;
						_sendTable2 = superSendTrampolines;
					}
				}
			}
			{
				_targetCogCode = ((CogMethod *) (_entryPoint - _offset2) );
				{
					if (((sqInt) _targetCogCode ) == _theCogMethod) {
						/* begin unlinkSendAt:targetMethod:sendTable: */
						_unlinkedRoutine = _sendTable2[((((_targetCogCode->cmNumArgs)) < (NumSendTrampolines - 1)) ? (_targetCogCode->cmNumArgs) : NumSendTrampolines - 1)];
						rewriteInlineCacheAttagtarget(backEnd, ((sqInt) _mcpc ), inlineCacheValueForSelectorinat((_targetCogCode->selector), enumeratingCogMethod, _mcpc), _unlinkedRoutine);
						codeModified = 1;
						/* end unlinkSendAt:targetMethod:sendTable: */
					}
				}
			}
			/* end offsetAndSendTableFor:annotation:into: */
			/* end targetMethodAndSendTableFor:annotation:into: */
		}
	}
	return 0;
}
/*	Unlink all sends in cog methods whose class tag is that of a forwarded 
	class.  */
/* Cogit>>#unlinkSendsLinkedForInvalidClasses */
void
unlinkSendsLinkedForInvalidClasses(void)
{
	sqInt _annotation;
	CogMethod *_cogMethod;
	int _freedPIC;
	usqInt _map;
	sqInt _mapByte;
	sqInt _mcpc;
	sqInt _result;

	if (!methodZoneBase) {
		return;
	}
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		_cogMethod = ((CogMethod *) methodZoneBase );
		codeModified = (_freedPIC = 0);
		while (_cogMethod < (limitZony())) {
			if (((_cogMethod->cmType)) == CMMethod) {
				/* begin mapFor:performUntil:arg: */
				/* begin firstMappedPCFor: */
				_mcpc = (((_cogMethod->cpicHasMNUCaseOrCMIsFullBlock))
					 ? ((usqInt) _cogMethod ) + cbNoSwitchEntryOffset
					 : ((usqInt) _cogMethod ) + cmNoCheckEntryOffset);
				/* end firstMappedPCFor: */
				_map = (((usqInt) _cogMethod ) + ((_cogMethod->blockSize))) - 1;
				{
					enumeratingCogMethod = _cogMethod;
				}
				while (((_mapByte = byteAt(_map))) != MapEnd) {
					if (_mapByte >= FirstAnnotation) {
						_mcpc += (_mapByte & DisplacementMask) * 4;
						if ((((_annotation = ((usqInt) _mapByte ) >> AnnotationShift)) == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
							_annotation += _mapByte & DisplacementMask;
							_map -= 1;
						}
						_result = unlinkIfInvalidClassSendpcignored(_annotation, ((char *) _mcpc ), 0);
						if (_result != 0) {
							goto l4;
						}
					} else {
						if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
							_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
						}
					}
					_map -= 1;
				}
				l4:
				;
				/* end mapFor:performUntil:arg: */
			} else {
				if ((((_cogMethod->cmType)) == CMPolymorphicIC) && (cPICHasForwardedClass(_cogMethod))) {
					freeMethod(_cogMethod);
					_freedPIC = 1;
				}
			}
			_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		}
		if (_freedPIC) {
			unlinkSendsToFree();
		}
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		if (codeModified) {
			flushICacheFromto(((usqInt) methodZoneBase ), ((usqInt) (limitZony()) ));
		}
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
}
/*	Unlink all sends in cog methods. Free all Closed PICs with the selector, 
	or with an MNU case if isMNUSelector. First check if any method actually 
	has the selector; if not there can't be any linked send to it. This 
	routine (including descendents) is performance critical. It contributes 
	perhaps 30% of entire execution time in Compiler recompileAll. */
/* Cogit>>#unlinkSendsOf:isMNUSelector: */
void
unlinkSendsOfisMNUSelector(sqInt _selector, sqInt _isMNUSelector)
{
	sqInt _annotation;
	CogMethod *_cogMethod;
	usqInt _map;
	sqInt _mapByte;
	sqInt _mcpc;
	int _mustScanAndUnlink;
	sqInt _result;

	if (!methodZoneBase) {
		return;
	}
	/* begin enableCodeZoneWriteDuring: */
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		_cogMethod = ((CogMethod *) methodZoneBase );
		_mustScanAndUnlink = 0;
		if (_isMNUSelector) {
			while (_cogMethod < (limitZony())) {
				if (((_cogMethod->cmType)) != CMFree) {
					if (((_cogMethod->cpicHasMNUCaseOrCMIsFullBlock)) && (((_cogMethod->cmType)) == CMPolymorphicIC)) {
						assert(((_cogMethod->cmType)) == CMPolymorphicIC);
						freeMethod(_cogMethod);
						_mustScanAndUnlink = 1;
					} else {
						if (((_cogMethod->selector)) == _selector) {
							_mustScanAndUnlink = 1;
							if (((_cogMethod->cmType)) == CMPolymorphicIC) {
								freeMethod(_cogMethod);
							}
						}
					}
				}
				_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
			}
		}
 else {
			while (_cogMethod < (limitZony())) {
				if ((((_cogMethod->cmType)) != CMFree) && (((_cogMethod->selector)) == _selector)) {
					_mustScanAndUnlink = 1;
					if (((_cogMethod->cmType)) == CMPolymorphicIC) {
						freeMethod(_cogMethod);
					}
				}
				_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
			}
		}
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	/* end enableCodeZoneWriteDuring: */
	if (!_mustScanAndUnlink) {
		return;
	}
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		codeModified = 0;
		_cogMethod = ((CogMethod *) methodZoneBase );
		while (_cogMethod < (limitZony())) {
			if (((_cogMethod->cmType)) == CMMethod) {
				/* begin mapFor:performUntil:arg: */
				/* begin firstMappedPCFor: */
				_mcpc = (((_cogMethod->cpicHasMNUCaseOrCMIsFullBlock))
					 ? ((usqInt) _cogMethod ) + cbNoSwitchEntryOffset
					 : ((usqInt) _cogMethod ) + cmNoCheckEntryOffset);
				/* end firstMappedPCFor: */
				_map = (((usqInt) _cogMethod ) + ((_cogMethod->blockSize))) - 1;
				{
					enumeratingCogMethod = _cogMethod;
				}
				while (((_mapByte = byteAt(_map))) != MapEnd) {
					if (_mapByte >= FirstAnnotation) {
						_mcpc += (_mapByte & DisplacementMask) * 4;
						if ((((_annotation = ((usqInt) _mapByte ) >> AnnotationShift)) == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
							_annotation += _mapByte & DisplacementMask;
							_map -= 1;
						}
						_result = unlinkIfFreeOrLinkedSendpcof(_annotation, ((char *) _mcpc ), _selector);
						if (_result != 0) {
							goto l4;
						}
					} else {
						if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
							_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
						}
					}
					_map -= 1;
				}
				l4:
				;
				/* end mapFor:performUntil:arg: */
			}
			_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		}
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		if (codeModified) {
			flushICacheFromto(((usqInt) methodZoneBase ), ((usqInt) (limitZony()) ));
		}
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
}
/*	Unlink all sends in cog methods to free methods and/or pics. */
/* Cogit>>#unlinkSendsToFree */
void
unlinkSendsToFree(void)
{
	sqInt _annotation;
	CogMethod *_cogMethod;
	usqInt _map;
	sqInt _mapByte;
	sqInt _mcpc;
	sqInt _result;

	if (!methodZoneBase) {
		return;
	}
	codeModified = 0;
	_cogMethod = ((CogMethod *) methodZoneBase );
	while (_cogMethod < (limitZony())) {
		if (((_cogMethod->cmType)) == CMMethod) {
			/* begin mapFor:performUntil:arg: */
			/* begin firstMappedPCFor: */
			_mcpc = (((_cogMethod->cpicHasMNUCaseOrCMIsFullBlock))
				 ? ((usqInt) _cogMethod ) + cbNoSwitchEntryOffset
				 : ((usqInt) _cogMethod ) + cmNoCheckEntryOffset);
			/* end firstMappedPCFor: */
			_map = (((usqInt) _cogMethod ) + ((_cogMethod->blockSize))) - 1;
			{
				enumeratingCogMethod = _cogMethod;
			}
			while (((_mapByte = byteAt(_map))) != MapEnd) {
				if (_mapByte >= FirstAnnotation) {
					_mcpc += (_mapByte & DisplacementMask) * 4;
					if ((((_annotation = ((usqInt) _mapByte ) >> AnnotationShift)) == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
						_annotation += _mapByte & DisplacementMask;
						_map -= 1;
					}
					_result = unlinkIfLinkedSendToFreepcignored(_annotation, ((char *) _mcpc ), 0);
					if (_result != 0) {
						goto l3;
					}
				} else {
					if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
						_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
					}
				}
				_map -= 1;
			}
			l3:
			;
			/* end mapFor:performUntil:arg: */
		} else {
			if (((_cogMethod->cmType)) == CMPolymorphicIC) {
				assert(noTargetsFreeInClosedPIC(_cogMethod));
			}
		}
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
	}
}
/*	Unlink all sends in cog methods to a particular target method. 
	If targetMethodObject isn't actually a method (perhaps being 
	used via invokeAsMethod) then there's nothing to do. */
/* Cogit>>#unlinkSendsTo:andFreeIf: */
void
unlinkSendsToandFreeIf(sqInt _targetMethodObject, sqInt _freeIfTrue)
{
	sqInt _annotation;
	CogMethod *_cogMethod;
	int _freedPIC;
	usqInt _map;
	sqInt _mapByte;
	sqInt _mcpc;
	sqInt _result;
	CogMethod *_targetMethod;

	if (!((isOopCompiledMethod(_targetMethodObject)) && (methodHasCogMethod(_targetMethodObject)))) {
		return;
	}
	_targetMethod = cogMethodOf(_targetMethodObject);
	if (!methodZoneBase) {
		return;
	}
	codeModified = (_freedPIC = 0);
	_cogMethod = ((CogMethod *) methodZoneBase );
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		while (_cogMethod < (limitZony())) {
			if (((_cogMethod->cmType)) == CMMethod) {
				/* begin mapFor:performUntil:arg: */
				/* begin firstMappedPCFor: */
				_mcpc = (((_cogMethod->cpicHasMNUCaseOrCMIsFullBlock))
					 ? ((usqInt) _cogMethod ) + cbNoSwitchEntryOffset
					 : ((usqInt) _cogMethod ) + cmNoCheckEntryOffset);
				/* end firstMappedPCFor: */
				_map = (((usqInt) _cogMethod ) + ((_cogMethod->blockSize))) - 1;
				{
					enumeratingCogMethod = _cogMethod;
				}
				while (((_mapByte = byteAt(_map))) != MapEnd) {
					if (_mapByte >= FirstAnnotation) {
						_mcpc += (_mapByte & DisplacementMask) * 4;
						if ((((_annotation = ((usqInt) _mapByte ) >> AnnotationShift)) == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
							_annotation += _mapByte & DisplacementMask;
							_map -= 1;
						}
						_result = unlinkIfLinkedSendpcto(_annotation, ((char *) _mcpc ), ((sqInt) _targetMethod ));
						if (_result != 0) {
							goto l4;
						}
					} else {
						if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
							_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
						}
					}
					_map -= 1;
				}
				l4:
				;
				/* end mapFor:performUntil:arg: */
			} else {
				if ((((_cogMethod->cmType)) == CMPolymorphicIC) && (cPICHasTarget(_cogMethod, _targetMethod))) {
					freeMethod(_cogMethod);
					_freedPIC = 1;
				}
			}
			_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		}
		if (_freeIfTrue) {
			freeMethod(_targetMethod);
		}
		if (_freedPIC) {
			unlinkSendsToFree();
		}
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		if (!_freedPIC && codeModified) {
			flushICacheFromto(((usqInt) methodZoneBase ), ((usqInt) (limitZony()) ));
		}
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
}
/* Cogit>>#XorCw:R: */
static AbstractInstruction * NoDbgRegParms
gXorCwR(sqInt _wordConstant, sqInt _reg)
{
	/* begin gen:literal:operand: */
	return checkLiteralforInstruction(_wordConstant, genoperandoperand(XorCwR, _wordConstant, _reg));
	/* end gen:literal:operand: */
}
/*	Access for the object representations when they need to prepend code to 
	trampolines. Eliminate stale dependent info. */
/* Cogit>>#zeroOpcodeIndex */
static void
zeroOpcodeIndex(void)
{
	sqInt _i;

	for (_i = 0; _i < opcodeIndex; _i += 1) {
		((abstractOpcodes[_i]).dependent = null);
	}
	zeroOpcodeIndexForNewOpcodes();
}
/*	Access for the object representations when they need to prepend code to 
	trampolines.  */
/* Cogit>>#zeroOpcodeIndexForNewOpcodes */
static void
zeroOpcodeIndexForNewOpcodes(void)
{
	opcodeIndex = 0;
	/* begin resetLiterals */
	firstOpcodeIndex = 1U << 16;
	nextLiteralIndex = (lastDumpedLiteralIndex = 0);
	/* end resetLiterals */
}
/* CogMethod>>#counters */
static sqInt NoDbgRegParms
counters(CogMethod * self_in_counters)
{
	return 0;
}
/* CogMethodZone>>#addAllToYoungReferrers */
void
addAllToYoungReferrers(void)
{
	CogMethod *_cogMethod;

	/* begin enableCodeZoneWriteDuring: */
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		_cogMethod = ((CogMethod *) baseAddress );
		while (_cogMethod < (limitZony())) {
			if ((((_cogMethod->cmType)) == CMMethod) || (((_cogMethod->cmType)) == CMMegamorphicIC)) {
				ensureInYoungReferrers(_cogMethod);
			}
			_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		}
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	/* end enableCodeZoneWriteDuring: */
}
/* CogMethodZone>>#addToMegamorphicICList: */
static void NoDbgRegParms
addToMegamorphicICList(CogMethod *_anOpenPIC)
{
	assert(((_anOpenPIC->cmType)) == CMMegamorphicIC);
	assert((openPICList == null) || (((openPICList->cmType)) == CMMegamorphicIC));
	(_anOpenPIC->nextOpenPIC = ((usqInt) openPICList ));
	openPICList = _anOpenPIC;
}
/* CogMethodZone>>#addToYoungReferrers: */
static void NoDbgRegParms
addToYoungReferrers(CogMethod *_cogMethod)
{
	assert(youngReferrers <= limitAddress);
	assert((occurrencesInYoungReferrers(_cogMethod)) == 0);
	assert((_cogMethod->cmRefersToYoung));
	assert((youngReferrers <= limitAddress) && (youngReferrers >= (limitAddress - (methodCount * BytesPerWord))));
	if (!(asserta((limitAddress - (methodCount * BytesPerWord)) >= mzFreeStart))) {
		error("no room on youngReferrers list");
	}
	youngReferrers -= BytesPerWord;
	longAtput(youngReferrers, ((usqInt) _cogMethod ));
}
/* CogMethodZone>>#allocate: */
static usqInt NoDbgRegParms
allocate(sqInt _numBytes)
{
	usqInt _allocation;
	sqInt _roundedBytes;

	_roundedBytes = (_numBytes + 7) & -8;
	if ((mzFreeStart + _roundedBytes) >= (limitAddress - (methodCount * BytesPerWord))) {
		return 0;
	}
	_allocation = mzFreeStart;
	mzFreeStart += _roundedBytes;
	methodCount += 1;
	return _allocation;
}
/*	Free all methods */
/* CogMethodZone>>#clearCogCompiledCode */
static void
clearCogCompiledCode(void)
{
	CogMethod *_cogMethod;

	/* begin enableCodeZoneWriteDuring: */
	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		_cogMethod = ((CogMethod *) baseAddress );
		while (((usqInt) _cogMethod ) < mzFreeStart) {
			if (((_cogMethod->cmType)) == CMMethod) {
				freeMethod(_cogMethod);
			}
			_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		}
		manageFromto(baseAddress, limitAddress);
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
	/* end enableCodeZoneWriteDuring: */
}
/* CogMethodZone>>#compactCompiledCode */
static void
compactCompiledCode(void)
{
	unsigned short _byteSize;
	CogMethod *_dest;
	sqLong _objectHeaderValue;
	CogMethod *_source;

	compactionInProgress = 1;
	_objectHeaderValue = nullHeaderForMachineCodeMethod();
	_source = ((CogMethod *) baseAddress );
	voidOpenPICList();
	methodCount = 0;
	while ((_source < (limitZony())) && (((_source->cmType)) != CMFree)) {
		assert((cogMethodDoesntLookKosher(_source)) == 0);
		(_source->objectHeader = _objectHeaderValue);
		if (((_source->cmUsageCount)) > 0) {
			(_source->cmUsageCount = ((_source->cmUsageCount)) / 2);
		}
		if (((_source->cmType)) == CMMegamorphicIC) {
			addToMegamorphicICList(_source);
		}
		methodCount += 1;
		_source = ((CogMethod *) (roundUpLength(((sqInt) _source ) + ((_source->blockSize)))) );
	}
	if (_source >= (limitZony())) {
		{
			haltmsg("no free methods; cannot compact.");
			return;
		}
	}
	_dest = _source;
	while (_source < (limitZony())) {
		assert((maybeFreeCogMethodDoesntLookKosher(_source)) == 0);
		_byteSize = (_source->blockSize);
		if (((_source->cmType)) != CMFree) {
			methodCount += 1;
			memmove(_dest, _source, _byteSize);
			(_dest->objectHeader = _objectHeaderValue);
			if (((_dest->cmType)) == CMMethod) {
				if (((sqInt) (rawHeaderOf((_dest->methodObject))) ) == ((sqInt) _source )) {
					rawHeaderOfput((_dest->methodObject), ((sqInt) _dest ));
				}
 else {
					assert((noAssertMethodClassAssociationOf((_dest->methodObject))) == (nilObject()));
				}
			} else {
				if (((_dest->cmType)) == CMMegamorphicIC) {
					addToMegamorphicICList(_dest);
				}
			}
			if (((_dest->cmUsageCount)) > 0) {
				(_dest->cmUsageCount = ((_dest->cmUsageCount)) / 2);
			}
			_dest = ((CogMethod *) (roundUpLength(((sqInt) _dest ) + ((_dest->blockSize)))) );
		}
		_source = ((CogMethod *) (roundUpLength(((sqInt) _source ) + _byteSize)) );
	}
	mzFreeStart = ((usqInt) _dest );
	methodBytesFreedSinceLastCompaction = 0;
	compactionInProgress = 0;
}
/* CogMethodZone>>#ensureInYoungReferrers: */
static void NoDbgRegParms
ensureInYoungReferrers(CogMethod *_cogMethod)
{
	if (!((_cogMethod->cmRefersToYoung))) {
		assert((occurrencesInYoungReferrers(_cogMethod)) == 0);
		(_cogMethod->cmRefersToYoung = 1);
		addToYoungReferrers(_cogMethod);
	}
}
/* CogMethodZone>>#followForwardedLiteralsInOpenPICList */
static void
followForwardedLiteralsInOpenPICList(void)
{
	CogMethod *_openPIC;

	_openPIC = openPICList;
	while (_openPIC != null) {
		followForwardedLiteralsIn(_openPIC);
		_openPIC = ((CogMethod *) ((_openPIC->nextOpenPIC)) );
	}
}
/* CogMethodZone>>#freeMethod: */
void
freeMethod(CogMethod *_cogMethod)
{
	assert(((_cogMethod->cmType)) != CMFree);
	assert((cogMethodDoesntLookKosher(_cogMethod)) == 0);
	if (((_cogMethod->cmType)) == CMMethod) {
		if (((sqInt) (rawHeaderOf((_cogMethod->methodObject))) ) == ((sqInt) _cogMethod )) {
			rawHeaderOfput((_cogMethod->methodObject), (_cogMethod->methodHeader));
		}
 else {
			assert((noAssertMethodClassAssociationOf((_cogMethod->methodObject))) == (nilObject()));
		}
	}
	if (((_cogMethod->cmType)) == CMMegamorphicIC) {
		removeFromOpenPICList(_cogMethod);
	}
	(_cogMethod->cmRefersToYoung = 0);
	(_cogMethod->cmType = CMFree);
	methodBytesFreedSinceLastCompaction += (_cogMethod->blockSize);
}
/*	Free methods, preferring older methods for compaction, up to some 
	fraction, currently a quarter. */
/* CogMethodZone>>#freeOlderMethodsForCompaction */
static void
freeOlderMethodsForCompaction(void)
{
	sqInt _amountToFree;
	CogMethod *_cogMethod;
	int _freeableUsage;
	sqInt _freedSoFar;
	sqInt _initialFreeSpace;
	sqInt _zoneSize;

	_zoneSize = limitAddress - baseAddress;
	_initialFreeSpace = (limitAddress - mzFreeStart) + methodBytesFreedSinceLastCompaction;
	_freedSoFar = _initialFreeSpace;
	_amountToFree = _zoneSize / 4;
	_freeableUsage = 0;
	do {
		_cogMethod = ((CogMethod *) baseAddress );
		while ((((usqInt) _cogMethod ) < mzFreeStart) && (_freedSoFar < _amountToFree)) {
			if ((((_cogMethod->cmType)) != CMFree) && (((_cogMethod->cmUsageCount)) <= _freeableUsage)) {
				freeMethod(_cogMethod);
				_freedSoFar += (_cogMethod->blockSize);
			}
			_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		}
	} while ((_freedSoFar < _amountToFree) && (((_freeableUsage += 1)) < CMMaxUsageCount));
}
/*	Answer that all entries in youngReferrers are in-use and have the 
	cmRefersToYoung flag set. 
	Used to check that the youngreferrers pruning routines work correctly. */
/* CogMethodZone>>#kosherYoungReferrers */
static sqInt
kosherYoungReferrers(void)
{
	CogMethod *_cogMethod;
	usqInt _pointer;

	if ((youngReferrers > limitAddress) || (youngReferrers < mzFreeStart)) {
		return 0;
	}
	_pointer = youngReferrers;
	while (_pointer < limitAddress) {
		_cogMethod = ((CogMethod *) (longAt(_pointer)) );
		if (!((((_cogMethod->cmType)) != CMFree) && ((_cogMethod->cmRefersToYoung)))) {
			return 0;
		}
		_pointer += BytesPerWord;
	}
	return 1;
}
/* CogMethodZone>>#manageFrom:to: */
static void NoDbgRegParms
manageFromto(sqInt _theStartAddress, sqInt _theLimitAddress)
{
	mzFreeStart = (baseAddress = _theStartAddress);
	youngReferrers = (limitAddress = _theLimitAddress);
	openPICList = null;
	methodBytesFreedSinceLastCompaction = 0;
	methodCount = 0;
}
/* CogMethodZone>>#methodFor: */
CogMethod *
methodFor(void *_address)
{
	CogMethod *_cogMethod;
	CogMethod *_nextMethod;

	_cogMethod = ((CogMethod *) baseAddress );
	while ((_cogMethod < (limitZony())) && (((usqInt) _cogMethod ) <= ((usqInt) _address ))) {
		/* begin methodAfter: */
		_nextMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		/* end methodAfter: */
		if (_nextMethod == _cogMethod) {
			return 0;
		}
		if ((((usqInt) _address ) >= ((usqInt) _cogMethod )) && (((usqInt) _address ) < ((usqInt) _nextMethod ))) {
			return _cogMethod;
		}
		_cogMethod = _nextMethod;
	}
	return 0;
}
/* CogMethodZone>>#methodsCompiledToMachineCodeInto: */
sqInt
methodsCompiledToMachineCodeInto(sqInt _arrayObj)
{
	CogMethod *_cogMethod;
	int _methodIndex;

	_methodIndex = 0;
	_cogMethod = ((CogMethod *) baseAddress );
	while (_cogMethod < (limitZony())) {
		if (((_cogMethod->cmType)) == CMMethod) {
			storePointerUncheckedofObjectwithValue(_methodIndex, _arrayObj, (_cogMethod->methodObject));
			_methodIndex += 1;
		}
		/* begin methodAfter: */
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		/* end methodAfter: */
	}
	return _methodIndex;
}
/* CogMethodZone>>#numMethods */
sqInt
numMethods(void)
{
	return methodCount;
}
/* CogMethodZone>>#numMethodsOfType: */
sqInt
numMethodsOfType(sqInt _cogMethodType)
{
	CogMethod *_cogMethod;
	int _n;

	_n = 0;
	_cogMethod = ((CogMethod *) baseAddress );
	while (_cogMethod < (limitZony())) {
		if (((_cogMethod->cmType)) == _cogMethodType) {
			_n += 1;
		}
		/* begin methodAfter: */
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		/* end methodAfter: */
	}
	return _n;
}
/* CogMethodZone>>#occurrencesInYoungReferrers: */
static sqInt NoDbgRegParms
occurrencesInYoungReferrers(CogMethod *_cogMethod)
{
	int _count;
	usqInt _pointer;

	assert(youngReferrers <= limitAddress);
	_count = 0;
	_pointer = youngReferrers;
	while (_pointer < limitAddress) {
		if (((sqInt) _cogMethod ) == (longAt(_pointer))) {
			_count += 1;
		}
		_pointer += BytesPerWord;
	}
	return _count;
}
/* CogMethodZone>>#openPICWithSelector: */
static CogMethod * NoDbgRegParms
openPICWithSelector(sqInt _aSelector)
{
	CogMethod *_openPIC;

	_openPIC = openPICList;
	do {
		if ((_openPIC == null) || (((_openPIC->selector)) == _aSelector)) {
			return _openPIC;
		}
		_openPIC = ((CogMethod *) ((_openPIC->nextOpenPIC)) );
	} while (1);
	return 0;
}
/*	Some methods have been freed. Compute how much each survivor needs to 
	move during the ensuing compaction and record it in the objectHeader 
	field.  
	For Sista, where we want PICs to last so they can be observed, we need to 
	keep PICs unless 
	they are definitely unused. So we need to identify unused PICs. So in 
	planCompact, zero the 
	usage counts of all PICs, saving the actual usage count in 
	blockEntryOffset. Then in 
	relocateMethodsPreCompaction (actually in 
	relocateIfCallOrMethodReference:mcpc:delta:) restore the usage counts of 
	used PICs. Finally in compactCompiledCode, clear the blockEntryOffset 
	of the unused PICs; they will then have a zero count and be reclaimed in 
	the next code compaction. */
/* CogMethodZone>>#planCompaction */
static void
planCompaction(void)
{
	CogMethod *_cogMethod;
	int _delta;

	_delta = 0;
	_cogMethod = ((CogMethod *) baseAddress );
	while (((usqInt) _cogMethod ) < mzFreeStart) {
		if (((_cogMethod->cmType)) == CMFree) {
			_delta -= (_cogMethod->blockSize);
		} else {
			assert((cogMethodDoesntLookKosher(_cogMethod)) == 0);
			(_cogMethod->objectHeader = _delta);
		}
		/* begin methodAfter: */
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		/* end methodAfter: */
	}
}
/* CogMethodZone>>#printCogMethods */
void
printCogMethods(void)
{
	CogMethod *_cogMethod;
	sqInt _nc;
	sqInt _nf;
	sqInt _nm;
	sqInt _no;
	int _nu;

	_nm = (_nc = (_no = (_nf = (_nu = 0))));
	_cogMethod = ((CogMethod *) baseAddress );
	while (_cogMethod < (limitZony())) {
		printCogMethod(_cogMethod);
		switch ((_cogMethod->cmType)) {
			case CMFree:
			{
				_nf += 1;
			}
			break;
			case CMMethod:
			{
				_nm += 1;
			}
			break;
			case CMPolymorphicIC:
			{
				_nc += 1;
			}
			break;
			case CMMegamorphicIC:
			{
				_no += 1;
			}
			break;
			default:
			{
				_nu += 1;
			}
		}
		/* begin methodAfter: */
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		/* end methodAfter: */
	}
	{
		print("CMMethod ");
		printNum(_nm);
		print(" CMClosedPIC ");
		printNum(_nc);
		print(" CMOpenPIC ");
		printNum(_no);
		print(" CMFree ");
		printNum(_nf);
	}
	if (_nu > 0) {
		{
			print(" UNKNOWN ");
			printNum(_nu);
		}
	}
	{
		print(" total ");
		printNum((((_nm + _nc) + _no) + _nf) + _nu);
		cr();
	}
}
/* CogMethodZone>>#printCogMethodsOfType: */
void
printCogMethodsOfType(sqInt _cmType)
{
	CogMethod *_cogMethod;

	_cogMethod = ((CogMethod *) baseAddress );
	while (_cogMethod < (limitZony())) {
		if (((_cogMethod->cmType)) == _cmType) {
			printCogMethod(_cogMethod);
		}
		/* begin methodAfter: */
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		/* end methodAfter: */
	}
}
/* CogMethodZone>>#printCogMethodsWithMethod: */
void
printCogMethodsWithMethod(sqInt _methodOop)
{
	CogMethod *_cogMethod;

	_cogMethod = ((CogMethod *) baseAddress );
	while (_cogMethod < (limitZony())) {
		if ((((_cogMethod->cmType)) != CMFree) && (((_cogMethod->methodObject)) == _methodOop)) {
			printCogMethod(_cogMethod);
		}
		/* begin methodAfter: */
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		/* end methodAfter: */
	}
}
/* CogMethodZone>>#printCogMethodsWithPrimitive: */
void
printCogMethodsWithPrimitive(sqInt _primIdx)
{
	CogMethod *_cogMethod;

	_cogMethod = ((CogMethod *) baseAddress );
	while (_cogMethod < (limitZony())) {
		if ((((_cogMethod->cmType)) == CMMethod) && (_primIdx == (primitiveIndexOfMethodheader((_cogMethod->methodObject), (_cogMethod->methodHeader))))) {
			printCogMethod(_cogMethod);
		}
		/* begin methodAfter: */
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		/* end methodAfter: */
	}
}
/* CogMethodZone>>#printCogMethodsWithSelector: */
void
printCogMethodsWithSelector(sqInt _selectorOop)
{
	CogMethod *_cogMethod;

	_cogMethod = ((CogMethod *) baseAddress );
	while (_cogMethod < (limitZony())) {
		if ((((_cogMethod->cmType)) != CMFree) && (((_cogMethod->selector)) == _selectorOop)) {
			printCogMethod(_cogMethod);
		}
		/* begin methodAfter: */
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		/* end methodAfter: */
	}
}
/* CogMethodZone>>#printCogYoungReferrers */
void
printCogYoungReferrers(void)
{
	CogMethod *_cogMethod;
	usqInt _pointer;

	_pointer = youngReferrers;
	while (_pointer < limitAddress) {
		_cogMethod = ((CogMethod *) (longAt(_pointer)) );
		if (!((_cogMethod->cmRefersToYoung))) {
			print("*");
		}
		if (((_cogMethod->cmType)) == CMFree) {
			print("!");
		}
		if (!(((_cogMethod->cmRefersToYoung)) && (((_cogMethod->cmType)) != CMFree))) {
			print(" ");
		}
		printCogMethod(_cogMethod);
		_pointer += BytesPerWord;
	}
}
/* CogMethodZone>>#printOpenPICList */
sqInt
printOpenPICList(void)
{
	int _n;
	CogMethod *_openPIC;

	_n = 0;
	_openPIC = openPICList;
	while (!(_openPIC == null)) {
		_n += 1;
		printCogMethod(_openPIC);
		_openPIC = ((CogMethod *) ((_openPIC->nextOpenPIC)) );
	}
	return _n;
}
/* CogMethodZone>>#pruneYoungReferrers */
static sqInt
pruneYoungReferrers(void)
{
	usqInt _dest;
	usqInt _next;
	usqInt _source;

	assert(youngReferrers <= limitAddress);
	if (youngReferrers == limitAddress) {
		return null;
	}
	_dest = limitAddress;
	while (1) {
		_next = _dest - BytesPerWord;
		if (!((_next >= youngReferrers) && (((((CogMethod *) (longAt(_next)) ))->cmRefersToYoung)))) 
			break;
		_dest = _next;
	}
	assert(_dest >= youngReferrers);
	_source = _dest - BytesPerWord;
	while (_source >= youngReferrers) {
		if (((((CogMethod *) (longAt(_source)) ))->cmRefersToYoung)) {
			assert(_source < (_dest - BytesPerWord));
			longAtput((_dest -= BytesPerWord), longAt(_source));
		}
		_source -= BytesPerWord;
	}
	youngReferrers = _dest;
	assert(kosherYoungReferrers());
	return 0;
}
/*	This method compacts the young referrers array, and updates the references 
	to the methods were moved.Young referrers is an array that holds references to CogMethods that 
	references objects that are in the new space. 
	The young referrers array is stored at the end of the code cache, it grows 
	towards lower addresses. 
	The variable youngReferrers points to the lowest entry in the array, and 
	it spans up to the limitAddress */
/* CogMethodZone>>#relocateAndPruneYoungReferrers */
static sqInt
relocateAndPruneYoungReferrers(void)
{
	CogMethod *_cogMethod;
	usqInt _dest;
	usqInt _next;
	usqInt _source;

	assert(youngReferrers <= limitAddress);
	if (youngReferrers == limitAddress) {
		return null;
	}
	_dest = limitAddress;
	while (1) {
		_next = _dest - BytesPerWord;
		if (!((_next >= youngReferrers) && ((((((_cogMethod = ((CogMethod *) (longAt(_next)) )))->cmType)) != CMFree) && ((_cogMethod->cmRefersToYoung))))) 
			break;
		if (((_cogMethod->objectHeader)) != 0) {
			longAtput(_next, ((sqInt) _cogMethod ) + ((_cogMethod->objectHeader)));
		}
		_dest = _next;
	}
	assert(_dest >= youngReferrers);
	_source = _dest - BytesPerWord;
	while (_source >= youngReferrers) {
		_cogMethod = ((CogMethod *) (longAt(_source)) );
		if ((((_cogMethod->cmType)) != CMFree) && ((_cogMethod->cmRefersToYoung))) {
			assert(_source < (_dest - BytesPerWord));
			if (((_cogMethod->objectHeader)) != 0) {
				_cogMethod = ((CogMethod *) (((sqInt) _cogMethod ) + ((sqInt) ((_cogMethod->objectHeader)) )) );
			}
			longAtput((_dest -= BytesPerWord), ((sqInt) _cogMethod ));
		}
		_source -= BytesPerWord;
	}
	youngReferrers = _dest;
	return 0;
}
/*	All surviving methods have had the amount they are going to relocate by 
	stored in their objectHeader fields. Relocate all relative calls so that 
	after the compaction of both the method containing each call and the call 
	target the calls invoke the same target. */
/* CogMethodZone>>#relocateMethodsPreCompaction */
static sqInt
relocateMethodsPreCompaction(void)
{
	CogMethod *_cogMethod;

	_cogMethod = ((CogMethod *) baseAddress );
	while (((usqInt) _cogMethod ) < mzFreeStart) {
		if (((_cogMethod->cmType)) != CMFree) {
			if (((_cogMethod->cmType)) == CMPolymorphicIC) {
				relocateCallsInClosedPIC(_cogMethod);
			}
 else {
				relocateCallsAndSelfReferencesInMethod(_cogMethod);
			}
		}
		/* begin methodAfter: */
		_cogMethod = ((CogMethod *) (roundUpLength(((sqInt) _cogMethod ) + ((_cogMethod->blockSize)))) );
		/* end methodAfter: */
	}
	relocateAndPruneYoungReferrers();
	return 1;
}
/* CogMethodZone>>#removeFromOpenPICList: */
static sqInt NoDbgRegParms
removeFromOpenPICList(CogMethod *_anOpenPIC)
{
	CogMethod *_prevPIC;

	assert(((_anOpenPIC->cmType)) == CMMegamorphicIC);
	if (!openPICList) {
		return null;
	}
	assert((((openPICList->cmType)) == CMMegamorphicIC) && ((((openPICList->nextOpenPIC)) == null) || ((((((CogMethod *) ((openPICList->nextOpenPIC)) ))->cmType)) == CMMegamorphicIC)));
	if (_anOpenPIC == openPICList) {
		openPICList = ((CogMethod *) ((_anOpenPIC->nextOpenPIC)) );
		return null;
	}
	_prevPIC = openPICList;
	do {
		assert((_prevPIC != null) && (((_prevPIC->cmType)) == CMMegamorphicIC));
		if (((_prevPIC->nextOpenPIC)) == ((usqInt) _anOpenPIC )) {
			(_prevPIC->nextOpenPIC = (_anOpenPIC->nextOpenPIC));
			return null;
		}
		_prevPIC = ((CogMethod *) ((_prevPIC->nextOpenPIC)) );
	} while (1);
	return 0;
}
/* CogMethodZone>>#voidOpenPICList */
static void
voidOpenPICList(void)
{
	openPICList = null;
}
/* CogMethodZone>>#voidYoungReferrersPostTenureAll */
static void
voidYoungReferrersPostTenureAll(void)
{
	CogMethod *_cogMethod;
	usqInt _pointer;

	assert(youngReferrers <= limitAddress);
	_pointer = youngReferrers;
	while (_pointer < limitAddress) {
		_cogMethod = ((CogMethod *) (longAt(_pointer)) );
		if (((_cogMethod->cmType)) != CMFree) {
			(_cogMethod->cmRefersToYoung = 0);
		}
		_pointer += BytesPerWord;
	}
	youngReferrers = limitAddress;
}
/* CogMethodZone>>#whereIsMaybeCodeThing: */
char *
whereIsMaybeCodeThing(sqInt _anOop)
{
	if (oopisGreaterThanOrEqualToandLessThan(_anOop, codeBase, limitAddress)) {
		if (oopisLessThan(_anOop, methodZoneBase)) {
			return " is in generated runtime";
		}
		if (oopisLessThan(_anOop, mzFreeStart)) {
			return " is in generated methods";
		}
		if (oopisLessThan(_anOop, youngReferrers)) {
			return " is in code zone";
		}
		return " is in young referrers";
	}
	return null;
}
/* CogMethodZone>>#zoneAlignment */
static sqInt
zoneAlignment(void)
{
	return 8;
}
/* CogObjectRepresentation>>#checkValidObjectReference: */
static sqInt NoDbgRegParms
checkValidObjectReference(sqInt _anOop)
{
	return (!(isImmediate(_anOop))) && ((heapMapAtWord(pointerForOop(_anOop))) != 0);
}
/* CogObjectRepresentation>>#genCmpClassFloatCompactIndexR: */
static AbstractInstruction * NoDbgRegParms
genCmpClassFloatCompactIndexR(sqInt _reg)
{
	AbstractInstruction *_anInstruction;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(CmpCqR, ClassFloatCompactIndex, _reg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(ClassFloatCompactIndex));
	}
	return _anInstruction;
	/* end checkQuickConstant:forInstruction: */
}
/*	Get the method header (first word) of a CompiledMethod into headerReg. 
	Deal with the method possibly being cogged. */
/* CogObjectRepresentation>>#genGetMethodHeaderOf:into:scratch: */
static sqInt NoDbgRegParms
genGetMethodHeaderOfintoscratch(sqInt _methodReg, sqInt _headerReg, sqInt _scratchReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_jumpNotCogged;
	sqInt _offset;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, _methodReg, _headerReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	_jumpNotCogged = genJumpSmallInteger(_headerReg);
	/* begin MoveMw:r:R: */
	_offset = offsetof(CogMethod, methodHeader);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, _offset, _headerReg, _headerReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_offset));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end MoveMw:r:R: */
	jmpTarget(_jumpNotCogged, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return 0;
}
/* CogObjectRepresentation>>#genLoadSlot:sourceReg:destReg: */
static sqInt NoDbgRegParms
genLoadSlotsourceRegdestReg(sqInt _index, sqInt _sourceReg, sqInt _destReg)
{
	AbstractInstruction *_anInstruction;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveMwrR, (_index * BytesPerWord) + BaseHeaderSize, _sourceReg, _destReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral((_index * BytesPerWord) + BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	return 0;
}
/*	Primitive generator used to mark primitives that have no machine code 
	implementation This works as a null pattern. 
	Then primitive generation will just compile a call to the 
	interpreter-version of the primitive 
	 */
/* CogObjectRepresentation>>#genNonImplementedPrimitive */
static sqInt
genNonImplementedPrimitive(void)
{
	return UnimplementedPrimitive;
}
/* CogObjectRepresentation>>#genPrimitiveAdd */
static sqInt
genPrimitiveAdd(void)
{
	AbstractInstruction *_jumpNotSI;
	AbstractInstruction *_jumpOvfl;

	if (!(mclassIsSmallInteger())) {
		return UnimplementedPrimitive;
	}
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, ClassReg);
	/* end MoveR:R: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genRemoveSmallIntegerTagsInScratchReg(ClassReg);
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, ClassReg);
	/* end AddR:R: */
	/* begin JumpOverflow: */
	_jumpOvfl = genConditionalBranchoperand(JumpOverflow, ((sqInt) 0 ));
	/* end JumpOverflow: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, ClassReg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpOvfl, jmpTarget(_jumpNotSI, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
}
/* CogObjectRepresentation>>#genPrimitiveAsFloat */
static sqInt
genPrimitiveAsFloat(void)
{
	AbstractInstruction *_jumpFailAlloc;

	if (!(mclassIsSmallInteger())) {
		return UnimplementedPrimitive;
	}
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, ReceiverResultReg, TempReg);
	/* end MoveR:R: */
	genConvertSmallIntegerToIntegerInReg(TempReg);
	/* begin ConvertR:Rd: */
	genoperandoperand(ConvertRRd, TempReg, DPFPReg0);
	/* end ConvertR:Rd: */
	_jumpFailAlloc = genAllocFloatValueintoscratchRegscratchReg(DPFPReg0, SendNumArgsReg, ClassReg, TempReg);
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpFailAlloc, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return 0;
}
/* CogObjectRepresentation>>#genPrimitiveBitAnd */
static sqInt
genPrimitiveBitAnd(void)
{
	AbstractInstruction *_jumpNotSI;

	if (!(mclassIsSmallInteger())) {
		return UnimplementedPrimitive;
	}
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	/* begin AndR:R: */
	genoperandoperand(AndRR, Arg0Reg, ReceiverResultReg);
	/* end AndR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpNotSI, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return CompletePrimitive;
}
/* CogObjectRepresentation>>#genPrimitiveBitOr */
static sqInt
genPrimitiveBitOr(void)
{
	AbstractInstruction *_jumpNotSI;

	if (!(mclassIsSmallInteger())) {
		return UnimplementedPrimitive;
	}
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	/* begin OrR:R: */
	genoperandoperand(OrRR, Arg0Reg, ReceiverResultReg);
	/* end OrR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpNotSI, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return CompletePrimitive;
}
/*	rTemp := rArg0 
	rClass := tTemp 
	rTemp := rTemp & 1 
	jz nonInt 
	rClass >>= 1 
	cmp 0,rClass 
	jge neg 
	cmp 31,rClass // numSmallIntegerBits, jge for sign 
	jge tooBig 
	rTemp := rReceiver 
	rTemp <<= rClass 
	rTemp >>= rClass (arithmetic) 
	cmp rTemp,rReceiver 
	jnz ovfl 
	rReceiver := rReceiver - 1 
	rReceiver := rReceiver <<= rClass 
	rReceiver := rReceiver + 1 
	ret 
	neg: 
	rClass := 0 - rClass 
	cmp 31,rClass // numSmallIntegerBits 
	jge inRange 
	rClass := 31 
	inRange 
	rReceiver := rReceiver >>= rClass. 
	rReceiver := rReceiver | smallIntegerTags. 
	ret 
	ovfl 
	tooBig 
	nonInt: 
	fail */
/* CogObjectRepresentation>>#genPrimitiveBitShift */
static sqInt
genPrimitiveBitShift(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_jumpInRange;
	AbstractInstruction *_jumpNegative;
	AbstractInstruction *_jumpNotSI;
	AbstractInstruction *_jumpOvfl;
	AbstractInstruction *_jumpTooBig;
	sqInt _quickConstant;
	sqInt _quickConstant2;
	sqInt _quickConstant3;

	if (!(mclassIsSmallInteger())) {
		return UnimplementedPrimitive;
	}
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, ClassReg);
	/* end MoveR:R: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(ClassReg);
	if (!(setsConditionCodesFor(lastOpcode(), JumpNegative))) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, 0, ClassReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin JumpNegative: */
	_jumpNegative = genConditionalBranchoperand(JumpNegative, ((sqInt) 0 ));
	/* end JumpNegative: */
	/* begin CmpCq:R: */
	_quickConstant = numSmallIntegerBits();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpGreaterOrEqual: */
	_jumpTooBig = genConditionalBranchoperand(JumpGreaterOrEqual, ((sqInt) 0 ));
	/* end JumpGreaterOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, ReceiverResultReg, TempReg);
	/* end MoveR:R: */
	/* begin LogicalShiftLeftR:R: */
	genoperandoperand(LogicalShiftLeftRR, ClassReg, TempReg);
	/* end LogicalShiftLeftR:R: */
	/* begin ArithmeticShiftRightR:R: */
	genoperandoperand(ArithmeticShiftRightRR, ClassReg, TempReg);
	/* end ArithmeticShiftRightR:R: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, TempReg, ReceiverResultReg);
	/* end CmpR:R: */
	/* begin JumpNonZero: */
	_jumpOvfl = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	genRemoveSmallIntegerTagsInScratchReg(ReceiverResultReg);
	/* begin LogicalShiftLeftR:R: */
	genoperandoperand(LogicalShiftLeftRR, ClassReg, ReceiverResultReg);
	/* end LogicalShiftLeftR:R: */
	genAddSmallIntegerTagsTo(ReceiverResultReg);
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpNegative, genoperand(NegateR, ClassReg));
	/* begin CmpCq:R: */
	_quickConstant2 = numSmallIntegerBits();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant2, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpLessOrEqual: */
	_jumpInRange = genConditionalBranchoperand(JumpLessOrEqual, ((sqInt) 0 ));
	/* end JumpLessOrEqual: */
	/* begin MoveCq:R: */
	_quickConstant3 = numSmallIntegerBits();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(MoveCqR, _quickConstant3, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(_quickConstant3));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end MoveCq:R: */
	jmpTarget(_jumpInRange, genoperandoperand(ArithmeticShiftRightRR, ClassReg, ReceiverResultReg));
	genClearAndSetSmallIntegerTagsIn(ReceiverResultReg);
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpNotSI, jmpTarget(_jumpTooBig, jmpTarget(_jumpOvfl, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
}
/* CogObjectRepresentation>>#genPrimitiveBitXor */
static sqInt
genPrimitiveBitXor(void)
{
	AbstractInstruction *_jumpNotSI;

	if (!(mclassIsSmallInteger())) {
		return UnimplementedPrimitive;
	}
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genRemoveSmallIntegerTagsInScratchReg(Arg0Reg);
	/* begin XorR:R: */
	genoperandoperand(XorRR, Arg0Reg, ReceiverResultReg);
	/* end XorR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpNotSI, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return CompletePrimitive;
}
/* CogObjectRepresentation>>#genPrimitiveClass */
static sqInt
genPrimitiveClass(void)
{
	sqInt reg;
	sqInt _reg;

	_reg = ReceiverResultReg;
	if (methodOrBlockNumArgs > 0) {
		if (methodOrBlockNumArgs > 1) {
			return UnimplementedPrimitive;
		}
		/* begin genLoadArgAtDepth:into: */
		reg = (_reg = Arg0Reg);
		assert(0 < (numRegArgs()));
		/* end genLoadArgAtDepth:into: */
	}
	if ((genGetClassObjectOfintoscratchReginstRegIsReceiver(_reg, ReceiverResultReg, TempReg, _reg == ReceiverResultReg)) == BadRegisterSet) {
		genGetClassObjectOfintoscratchReginstRegIsReceiver(_reg, ClassReg, TempReg, _reg == ReceiverResultReg);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, ClassReg, ReceiverResultReg);
		/* end MoveR:R: */
	}
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	return UnfailingPrimitive;
}
/* CogObjectRepresentation>>#genPrimitiveDiv */
static sqInt
genPrimitiveDiv(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_convert;
	AbstractInstruction *_jumpExact;
	AbstractInstruction *_jumpIsSI;
	AbstractInstruction *_jumpNotSI;
	AbstractInstruction *_jumpSameSign;
	AbstractInstruction *_jumpZero;

	if (!(processorHasDivQuoRemAndMClassIsSmallInteger())) {
		return UnimplementedPrimitive;
	}
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, ClassReg);
	/* end MoveR:R: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(ClassReg);
	if (!(setsConditionCodesFor(lastOpcode(), JumpZero))) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, 0, ClassReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin JumpZero: */
	_jumpZero = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, ReceiverResultReg, TempReg);
	/* end MoveR:R: */
	genConvertSmallIntegerToIntegerInReg(TempReg);
	gDivRRQuoRem(ClassReg, TempReg, TempReg, ClassReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 0, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpZero: */
	_jumpExact = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* begin XorR:R: */
	genoperandoperand(XorRR, ClassReg, Arg1Reg);
	/* end XorR:R: */
	if (!(setsConditionCodesFor(lastOpcode(), JumpZero))) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(CmpCqR, 0, Arg1Reg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin JumpGreaterOrEqual: */
	_jumpSameSign = genConditionalBranchoperand(JumpGreaterOrEqual, ((sqInt) 0 ));
	/* end JumpGreaterOrEqual: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(SubCqR, 1, TempReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	jmpTarget(_jumpSameSign, (_convert = genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	genConvertIntegerToSmallIntegerInReg(TempReg);
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, TempReg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpExact, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	_jumpIsSI = genJumpIsSmallIntegerValuescratch(TempReg, Arg1Reg);
	jmpTarget(_jumpIsSI, _convert);
	jmpTarget(_jumpZero, jmpTarget(_jumpNotSI, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
}
/* CogObjectRepresentation>>#genPrimitiveDivide */
static sqInt
genPrimitiveDivide(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_jumpInexact;
	AbstractInstruction *_jumpNotSI;
	AbstractInstruction *_jumpOverflow;
	AbstractInstruction *_jumpZero;

	if (!(processorHasDivQuoRemAndMClassIsSmallInteger())) {
		return UnimplementedPrimitive;
	}
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, ClassReg);
	/* end MoveR:R: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(ClassReg);
	/* begin JumpZero: */
	_jumpZero = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, ReceiverResultReg, TempReg);
	/* end MoveR:R: */
	genConvertSmallIntegerToIntegerInReg(TempReg);
	gDivRRQuoRem(ClassReg, TempReg, TempReg, ClassReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(CmpCqR, 0, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpNonZero: */
	_jumpInexact = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	_jumpOverflow = genJumpNotSmallIntegerValuescratch(TempReg, Arg1Reg);
	genConvertIntegerToSmallIntegerInReg(TempReg);
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, TempReg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpOverflow, jmpTarget(_jumpInexact, jmpTarget(_jumpZero, jmpTarget(_jumpNotSI, genoperandoperand(Label, (labelCounter += 1), bytecodePC)))));
	return CompletePrimitive;
}
/* CogObjectRepresentation>>#genPrimitiveEqual */
static sqInt
genPrimitiveEqual(void)
{
	return genSmallIntegerComparisonorDoubleComparisoninvert(JumpZero, gJumpFPEqual, 0);
}
/* CogObjectRepresentation>>#genPrimitiveFloatAdd */
static sqInt
genPrimitiveFloatAdd(void)
{
	return genFloatArithmeticpreOpCheckboxed(AddRdRd, null, 1);
}
/* CogObjectRepresentation>>#genPrimitiveFloatDivide */
static sqInt
genPrimitiveFloatDivide(void)
{
	return genFloatArithmeticpreOpCheckboxed(DivRdRd, genDoubleFailIfZeroArgRcvrarg, 1);
}
/* CogObjectRepresentation>>#genPrimitiveFloatEqual */
static sqInt
genPrimitiveFloatEqual(void)
{
	return genFloatComparisoninvertboxed(gJumpFPEqual, 0, 1);
}
/* CogObjectRepresentation>>#genPrimitiveFloatGreaterOrEqual */
static sqInt
genPrimitiveFloatGreaterOrEqual(void)
{
	return genFloatComparisoninvertboxed(gJumpFPGreaterOrEqual, 0, 1);
}
/* CogObjectRepresentation>>#genPrimitiveFloatGreaterThan */
static sqInt
genPrimitiveFloatGreaterThan(void)
{
	return genFloatComparisoninvertboxed(gJumpFPGreater, 0, 1);
}
/* CogObjectRepresentation>>#genPrimitiveFloatLessOrEqual */
static sqInt
genPrimitiveFloatLessOrEqual(void)
{
	return genFloatComparisoninvertboxed(gJumpFPGreaterOrEqual, 1, 1);
}
/* CogObjectRepresentation>>#genPrimitiveFloatLessThan */
static sqInt
genPrimitiveFloatLessThan(void)
{
	return genFloatComparisoninvertboxed(gJumpFPGreater, 1, 1);
}
/* CogObjectRepresentation>>#genPrimitiveFloatMultiply */
static sqInt
genPrimitiveFloatMultiply(void)
{
	return genFloatArithmeticpreOpCheckboxed(MulRdRd, null, 1);
}
/* CogObjectRepresentation>>#genPrimitiveFloatNotEqual */
static sqInt
genPrimitiveFloatNotEqual(void)
{
	return genFloatComparisoninvertboxed(gJumpFPNotEqual, 0, 1);
}
/* CogObjectRepresentation>>#genPrimitiveFloatSquareRoot */
static sqInt
genPrimitiveFloatSquareRoot(void)
{
	AbstractInstruction *_jumpFailAlloc;

	genGetDoubleValueOfinto(ReceiverResultReg, DPFPReg0);
	/* begin SqrtRd: */
	genoperand(SqrtRd, DPFPReg0);
	/* end SqrtRd: */
	_jumpFailAlloc = genAllocFloatValueintoscratchRegscratchReg(DPFPReg0, SendNumArgsReg, ClassReg, TempReg);
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpFailAlloc, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return 0;
}
/* CogObjectRepresentation>>#genPrimitiveFloatSubtract */
static sqInt
genPrimitiveFloatSubtract(void)
{
	return genFloatArithmeticpreOpCheckboxed(SubRdRd, null, 1);
}
/*	Only works for the receiver for now */
/* CogObjectRepresentation>>#genPrimitiveFormat */
static sqInt
genPrimitiveFormat(void)
{
	AbstractInstruction * _jumpIsImm;
	AbstractInstruction * _primitiveFailure;

	if (methodOrBlockNumArgs > 0) {
		return UnimplementedPrimitive;
	}
	_jumpIsImm = genJumpImmediate(ReceiverResultReg);
	genGetFormatOfinto(ReceiverResultReg, ReceiverResultReg);
	genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	/* begin Label */
	_primitiveFailure = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
	/* end Label */
	jmpTarget(_jumpIsImm, _primitiveFailure);
	return CompletePrimitive;
}
/* CogObjectRepresentation>>#genPrimitiveGreaterOrEqual */
static sqInt
genPrimitiveGreaterOrEqual(void)
{
	return genSmallIntegerComparisonorDoubleComparisoninvert(JumpGreaterOrEqual, gJumpFPGreaterOrEqual, 0);
}
/* CogObjectRepresentation>>#genPrimitiveGreaterThan */
static sqInt
genPrimitiveGreaterThan(void)
{
	return genSmallIntegerComparisonorDoubleComparisoninvert(JumpGreater, gJumpFPGreater, 0);
}
/* CogObjectRepresentation>>#genPrimitiveIdentical */
static sqInt
genPrimitiveIdentical(void)
{
	return genPrimitiveIdenticalOrNotIf(0);
}
/* CogObjectRepresentation>>#genPrimitiveLessOrEqual */
static sqInt
genPrimitiveLessOrEqual(void)
{
	return genSmallIntegerComparisonorDoubleComparisoninvert(JumpLessOrEqual, gJumpFPGreaterOrEqual, 1);
}
/* CogObjectRepresentation>>#genPrimitiveLessThan */
static sqInt
genPrimitiveLessThan(void)
{
	return genSmallIntegerComparisonorDoubleComparisoninvert(JumpLess, gJumpFPGreater, 1);
}
/* CogObjectRepresentation>>#genPrimitiveMod */
static sqInt
genPrimitiveMod(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_jumpExact;
	AbstractInstruction *_jumpNotSI;
	AbstractInstruction *_jumpSameSign;
	AbstractInstruction *_jumpZero;

	if (!(processorHasDivQuoRemAndMClassIsSmallInteger())) {
		return UnimplementedPrimitive;
	}
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, ClassReg);
	/* end MoveR:R: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genRemoveSmallIntegerTagsInScratchReg(ClassReg);
	/* begin JumpZero: */
	_jumpZero = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, ClassReg, Arg1Reg);
	/* end MoveR:R: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, ReceiverResultReg, TempReg);
	/* end MoveR:R: */
	genRemoveSmallIntegerTagsInScratchReg(TempReg);
	gDivRRQuoRem(ClassReg, TempReg, TempReg, ClassReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, 0, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpZero: */
	_jumpExact = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* begin XorR:R: */
	genoperandoperand(XorRR, ClassReg, Arg1Reg);
	/* end XorR:R: */
	if (!(setsConditionCodesFor(lastOpcode(), JumpZero))) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, 0, Arg1Reg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin JumpGreaterOrEqual: */
	_jumpSameSign = genConditionalBranchoperand(JumpGreaterOrEqual, ((sqInt) 0 ));
	/* end JumpGreaterOrEqual: */
	/* begin XorR:R: */
	genoperandoperand(XorRR, ClassReg, Arg1Reg);
	/* end XorR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg1Reg, ClassReg);
	/* end AddR:R: */
	jmpTarget(_jumpSameSign, jmpTarget(_jumpExact, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	genSetSmallIntegerTagsIn(ClassReg);
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, ClassReg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpZero, jmpTarget(_jumpNotSI, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
}
/* CogObjectRepresentation>>#genPrimitiveMultiply */
static sqInt
genPrimitiveMultiply(void)
{
	AbstractInstruction *_jumpNotSI;
	AbstractInstruction *_jumpOvfl;

	if (!(processorHasMultiplyAndMClassIsSmallInteger())) {
		return UnimplementedPrimitive;
	}
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, ClassReg);
	/* end MoveR:R: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, ReceiverResultReg, Arg1Reg);
	/* end MoveR:R: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(ClassReg);
	genRemoveSmallIntegerTagsInScratchReg(Arg1Reg);
	/* begin MulR:R: */
	genMulRR(backEnd, Arg1Reg, ClassReg);
	/* end MulR:R: */
	/* begin JumpMultiplyOverflow: */
	/* begin genJumpMultiplyOverflow: */
	_jumpOvfl = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end genJumpMultiplyOverflow: */
	/* end JumpMultiplyOverflow: */
	genSetSmallIntegerTagsIn(ClassReg);
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, ClassReg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpOvfl, jmpTarget(_jumpNotSI, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
}
/*	subclasses override if they can */
/* CogObjectRepresentation>>#genPrimitiveNewMethod */
static sqInt
genPrimitiveNewMethod(void)
{
	return UnimplementedPrimitive;
}
/* CogObjectRepresentation>>#genPrimitiveNotEqual */
static sqInt
genPrimitiveNotEqual(void)
{
	return genSmallIntegerComparisonorDoubleComparisoninvert(JumpNonZero, gJumpFPNotEqual, 0);
}
/* CogObjectRepresentation>>#genPrimitiveNotIdentical */
static sqInt
genPrimitiveNotIdentical(void)
{
	return genPrimitiveIdenticalOrNotIf(1);
}
/* CogObjectRepresentation>>#genPrimitiveQuo */
static sqInt
genPrimitiveQuo(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_convert;
	AbstractInstruction *_jumpExact;
	AbstractInstruction *_jumpIsSI;
	AbstractInstruction *_jumpNotSI;
	AbstractInstruction *_jumpZero;

	if (!(processorHasDivQuoRemAndMClassIsSmallInteger())) {
		return UnimplementedPrimitive;
	}
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, ClassReg);
	/* end MoveR:R: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(ClassReg);
	if (!(setsConditionCodesFor(lastOpcode(), JumpZero))) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, 0, ClassReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin JumpZero: */
	_jumpZero = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, ReceiverResultReg, TempReg);
	/* end MoveR:R: */
	genConvertSmallIntegerToIntegerInReg(TempReg);
	gDivRRQuoRem(ClassReg, TempReg, TempReg, ClassReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, 0, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpZero: */
	_jumpExact = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* begin Label */
	_convert = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
	/* end Label */
	genConvertIntegerToSmallIntegerInReg(TempReg);
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, TempReg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpExact, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	_jumpIsSI = genJumpIsSmallIntegerValuescratch(TempReg, Arg1Reg);
	jmpTarget(_jumpIsSI, _convert);
	jmpTarget(_jumpZero, jmpTarget(_jumpNotSI, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
}
/* CogObjectRepresentation>>#genPrimitiveSmallFloatAdd */
static sqInt
genPrimitiveSmallFloatAdd(void)
{
	return genFloatArithmeticpreOpCheckboxed(AddRdRd, null, 0);
}
/* CogObjectRepresentation>>#genPrimitiveSmallFloatDivide */
static sqInt
genPrimitiveSmallFloatDivide(void)
{
	return genFloatArithmeticpreOpCheckboxed(DivRdRd, genDoubleFailIfZeroArgRcvrarg, 0);
}
/* CogObjectRepresentation>>#genPrimitiveSmallFloatEqual */
static sqInt
genPrimitiveSmallFloatEqual(void)
{
	return genFloatComparisoninvertboxed(gJumpFPEqual, 0, 0);
}
/* CogObjectRepresentation>>#genPrimitiveSmallFloatGreaterOrEqual */
static sqInt
genPrimitiveSmallFloatGreaterOrEqual(void)
{
	return genFloatComparisoninvertboxed(gJumpFPGreaterOrEqual, 0, 0);
}
/* CogObjectRepresentation>>#genPrimitiveSmallFloatGreaterThan */
static sqInt
genPrimitiveSmallFloatGreaterThan(void)
{
	return genFloatComparisoninvertboxed(gJumpFPGreater, 0, 0);
}
/* CogObjectRepresentation>>#genPrimitiveSmallFloatLessOrEqual */
static sqInt
genPrimitiveSmallFloatLessOrEqual(void)
{
	return genFloatComparisoninvertboxed(gJumpFPGreaterOrEqual, 1, 0);
}
/* CogObjectRepresentation>>#genPrimitiveSmallFloatLessThan */
static sqInt
genPrimitiveSmallFloatLessThan(void)
{
	return genFloatComparisoninvertboxed(gJumpFPGreater, 1, 0);
}
/* CogObjectRepresentation>>#genPrimitiveSmallFloatMultiply */
static sqInt
genPrimitiveSmallFloatMultiply(void)
{
	return genFloatArithmeticpreOpCheckboxed(MulRdRd, null, 0);
}
/* CogObjectRepresentation>>#genPrimitiveSmallFloatNotEqual */
static sqInt
genPrimitiveSmallFloatNotEqual(void)
{
	return genFloatComparisoninvertboxed(gJumpFPNotEqual, 0, 0);
}
/* CogObjectRepresentation>>#genPrimitiveSmallFloatSquareRoot */
static sqInt
genPrimitiveSmallFloatSquareRoot(void)
{
	AbstractInstruction *_jumpFailAlloc;
	AbstractInstruction *_jumpNegative;

	genGetSmallFloatValueOfscratchinto(ReceiverResultReg, SendNumArgsReg, DPFPReg0);
	{
		/* begin XorRd:Rd: */
		genoperandoperand(XorRdRd, DPFPReg1, DPFPReg1);
		/* end XorRd:Rd: */
		/* begin CmpRd:Rd: */
		genoperandoperand(CmpRdRd, DPFPReg0, DPFPReg1);
		/* end CmpRd:Rd: */
	}
	_jumpNegative = gJumpFPGreater(0);
	/* begin SqrtRd: */
	genoperand(SqrtRd, DPFPReg0);
	/* end SqrtRd: */
	_jumpFailAlloc = genAllocFloatValueintoscratchRegscratchReg(DPFPReg0, SendNumArgsReg, ClassReg, TempReg);
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpNegative, jmpTarget(_jumpFailAlloc, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return 0;
}
/* CogObjectRepresentation>>#genPrimitiveSmallFloatSubtract */
static sqInt
genPrimitiveSmallFloatSubtract(void)
{
	return genFloatArithmeticpreOpCheckboxed(SubRdRd, null, 0);
}
/* CogObjectRepresentation>>#genPrimitiveSubtract */
static sqInt
genPrimitiveSubtract(void)
{
	AbstractInstruction *_jumpNotSI;
	AbstractInstruction *_jumpOvfl;

	if (!(mclassIsSmallInteger())) {
		return UnimplementedPrimitive;
	}
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, ReceiverResultReg, TempReg);
	/* end MoveR:R: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, Arg0Reg, TempReg);
	/* end SubR:R: */
	/* begin JumpOverflow: */
	_jumpOvfl = genConditionalBranchoperand(JumpOverflow, ((sqInt) 0 ));
	/* end JumpOverflow: */
	genAddSmallIntegerTagsTo(TempReg);
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, TempReg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpOvfl, jmpTarget(_jumpNotSI, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
}
/* CogObjectRepresentation>>#genSmallIntegerComparison: */
static sqInt NoDbgRegParms
genSmallIntegerComparison(sqInt _jumpOpcode)
{
	AbstractInstruction *_anInstruction;
	sqInt _constant;
	AbstractInstruction *_jumpFail;
	AbstractInstruction *_jumpTrue;

	if (!(mclassIsSmallInteger())) {
		return UnimplementedPrimitive;
	}
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpFail = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, Arg0Reg, ReceiverResultReg);
	/* end CmpR:R: */
	_jumpTrue = genConditionalBranchoperand(_jumpOpcode, 0);
	/* begin genMoveConstant:R: */
	_constant = falseObject();
	if (shouldAnnotateObjectReference(_constant)) {
		annotateobjRef(gMoveCwR(_constant, ReceiverResultReg), _constant);
	} else {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, _constant, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_constant));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* end genMoveConstant:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpTrue, genMoveConstantR(trueObject(), ReceiverResultReg));
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpFail, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return CompletePrimitive;
}
/*	Stack looks like 
	return address */
/* CogObjectRepresentation>>#genSmallIntegerComparison:orDoubleComparison:invert: */
static sqInt NoDbgRegParms
genSmallIntegerComparisonorDoubleComparisoninvert(sqInt _jumpOpcode, AbstractInstruction * NoDbgRegParms (*_jumpFPOpcodeGenerator)(void *), sqInt _invertComparison)
{
	AbstractInstruction *_anInstruction;
	sqInt _constant;
	AbstractInstruction *_jumpCond;
	AbstractInstruction *_jumpFail;
	AbstractInstruction *_jumpNonInt;
	sqInt _r;

	_jumpNonInt = ((AbstractInstruction *) 0 );
	_r = genSmallIntegerComparison(_jumpOpcode);
	if (_r < 0) {
		return _r;
	}
	
#  if defined(DPFPReg0)
	{
		{
			_jumpNonInt = genJumpImmediate(Arg0Reg);
		}
		genGetCompactClassIndexNonImmOfinto(Arg0Reg, SendNumArgsReg);
		genCmpClassFloatCompactIndexR(SendNumArgsReg);
		/* begin JumpNonZero: */
		_jumpFail = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		genConvertSmallIntegerToIntegerInReg(ReceiverResultReg);
		/* begin ConvertR:Rd: */
		genoperandoperand(ConvertRRd, ReceiverResultReg, DPFPReg0);
		/* end ConvertR:Rd: */
		genGetDoubleValueOfinto(Arg0Reg, DPFPReg1);
		if (_invertComparison) {
			/* begin CmpRd:Rd: */
			genoperandoperand(CmpRdRd, DPFPReg0, DPFPReg1);
			/* end CmpRd:Rd: */
		}
 else {
			/* begin CmpRd:Rd: */
			genoperandoperand(CmpRdRd, DPFPReg1, DPFPReg0);
			/* end CmpRd:Rd: */
		}
		_jumpCond = _jumpFPOpcodeGenerator(0);
		/* begin genMoveConstant:R: */
		_constant = falseObject();
		if (shouldAnnotateObjectReference(_constant)) {
			annotateobjRef(gMoveCwR(_constant, ReceiverResultReg), _constant);
		} else {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperand(MoveCqR, _constant, ReceiverResultReg);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(_constant));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		/* end genMoveConstant:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		jmpTarget(_jumpCond, genMoveConstantR(trueObject(), ReceiverResultReg));
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		{
			jmpTarget(_jumpNonInt, jmpTarget(_jumpFail, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
		}
	}
#  endif /* defined(DPFPReg0) */
	return CompletePrimitive;
}
/* CogObjectRepresentation>>#isUnannotatableConstant: */
static sqInt NoDbgRegParms
isUnannotatableConstant(CogSimStackEntry *_simStackEntry)
{
	return (((_simStackEntry->type)) == SSConstant) && ((isImmediate((_simStackEntry->constant))) || (!(shouldAnnotateObjectReference((_simStackEntry->constant)))));
}
/* CogObjectRepresentationFor64BitSpur>>#classForInlineCacheTag: */
static sqInt NoDbgRegParms
classForInlineCacheTag(sqInt _classIndex)
{
	return classOrNilAtIndex(_classIndex);
}
/* CogObjectRepresentationFor64BitSpur>>#genAddSmallIntegerTagsTo: */
static sqInt NoDbgRegParms
genAddSmallIntegerTagsTo(sqInt _aRegister)
{
	AbstractInstruction *_anInstruction;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(AddCqR, 1, _aRegister);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	return 0;
}
/* CogObjectRepresentationFor64BitSpur>>#genAlloc64BitPositiveIntegerValue:into:scratchReg:scratchReg: */
static AbstractInstruction * NoDbgRegParms
genAlloc64BitPositiveIntegerValueintoscratchRegscratchReg(sqInt _valueReg, sqInt _resultReg, sqInt _scratch1, sqInt scratch2)
{
	sqInt _address;
	sqInt _address2;
	sqInt _allocSize;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction * _jumpFail;
	usqLong _newLPIHeader;
	sqInt _quickConstant;

	_allocSize = BaseHeaderSize + BytesPerWord;
	_newLPIHeader = headerForSlotsformatclassIndex(1, firstByteFormat(), ClassLargePositiveIntegerCompactIndex);
	/* begin MoveAw:R: */
	_address = freeStartAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, _resultReg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(LoadEffectiveAddressMwrR, _allocSize, _resultReg, _scratch1);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_allocSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin CmpCq:R: */
	_quickConstant = getScavengeThreshold();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _scratch1);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpFail = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:Aw: */
	_address2 = freeStartAddress();
	/* begin gen:operand:literal: */
	checkLiteralforInstruction(_address2, genoperandoperand(MoveRAw, _scratch1, _address2));
	/* end gen:operand:literal: */
	/* end MoveR:Aw: */
	/* begin genStoreHeader:intoNewInstance:using: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction4 = genoperandoperand(MoveCqR, _newLPIHeader, _scratch1);
		if (usesOutOfLineLiteral(_anInstruction4)) {
			(_anInstruction4->dependent = locateLiteral(_newLPIHeader));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction22 = genoperandoperandoperand(MoveRMwr, _scratch1, 0, _resultReg);
		if (usesOutOfLineLiteral(_anInstruction22)) {
			(_anInstruction22->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* end genStoreHeader:intoNewInstance:using: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperandoperand(MoveRMwr, _valueReg, BaseHeaderSize, _resultReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	return _jumpFail;
}
/* CogObjectRepresentationFor64BitSpur>>#genAlloc64BitSignedIntegerValue:into:scratchReg:scratchReg: */
static AbstractInstruction * NoDbgRegParms
genAlloc64BitSignedIntegerValueintoscratchRegscratchReg(sqInt _valueReg, sqInt _resultReg, sqInt _scratch1, sqInt scratch2)
{
	sqInt _address;
	sqInt _address2;
	sqInt _allocSize;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction * _jumpFail;
	AbstractInstruction * _jumpNeg;
	usqLong _newLNIHeader;
	sqInt _quickConstant;

	_allocSize = BaseHeaderSize + BytesPerWord;
	_newLNIHeader = headerForSlotsformatclassIndex(1, firstByteFormat(), ClassLargeNegativeIntegerCompactIndex);
	/* begin MoveAw:R: */
	_address = freeStartAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, _resultReg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(LoadEffectiveAddressMwrR, _allocSize, _resultReg, _scratch1);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_allocSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin CmpCq:R: */
	_quickConstant = getScavengeThreshold();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _scratch1);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpFail = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:Aw: */
	_address2 = freeStartAddress();
	/* begin gen:operand:literal: */
	checkLiteralforInstruction(_address2, genoperandoperand(MoveRAw, _scratch1, _address2));
	/* end gen:operand:literal: */
	/* end MoveR:Aw: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(MoveCqR, _newLNIHeader, _scratch1);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_newLNIHeader));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(CmpCqR, 0, _valueReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpLess: */
	_jumpNeg = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
	/* end JumpLess: */
	assert((headerForSlotsformatclassIndex(0, 0, 1)) == 1);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction5 = genoperandoperand(AddCqR, ClassLargePositiveIntegerCompactIndex - ClassLargeNegativeIntegerCompactIndex, _scratch1);
	if (usesOutOfLineLiteral(_anInstruction5)) {
		(_anInstruction5->dependent = locateLiteral(ClassLargePositiveIntegerCompactIndex - ClassLargeNegativeIntegerCompactIndex));
	}
	/* end checkQuickConstant:forInstruction: */
	jmpTarget(_jumpNeg, checkQuickConstantforInstruction(0, genoperandoperandoperand(MoveRMwr, _scratch1, 0, _resultReg)));
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction6 = genoperandoperandoperand(MoveRMwr, _valueReg, BaseHeaderSize, _resultReg);
	if (usesOutOfLineLiteral(_anInstruction6)) {
		(_anInstruction6->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	return _jumpFail;
}
/*	Override to answer a SmallFloat64 if possible. */
/* CogObjectRepresentationFor64BitSpur>>#genAllocFloatValue:into:scratchReg:scratchReg: */
static AbstractInstruction * NoDbgRegParms
genAllocFloatValueintoscratchRegscratchReg(sqInt _dpreg, sqInt _resultReg, sqInt _scratch1, sqInt scratch2)
{
	sqInt _address;
	sqInt _address2;
	usqIntptr_t _allocSize;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_jumpFail;
	AbstractInstruction *_jumpFail2;
	AbstractInstruction *_jumpMerge;
	AbstractInstruction *_jumpNotSF;
	usqLong _newFloatHeader;
	sqInt _quickConstant;

	/* begin MoveRd:R: */
	assert(BytesPerWord == 8);
	genoperandoperand(MoveRdR, _dpreg, _resultReg);
	/* end MoveRd:R: */
	_jumpNotSF = genJumpNotSmallFloatValueBitsscratch(_resultReg, _scratch1);
	genConvertBitsToSmallFloatInscratch(_resultReg, _scratch1);
	/* begin Jump: */
	_jumpMerge = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpNotSF, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	{
		_allocSize = BaseHeaderSize + (sizeof(double));
		_newFloatHeader = headerForSlotsformatclassIndex((sizeof(double)) / BytesPerWord, firstLongFormat(), ClassFloatCompactIndex);
		/* begin MoveAw:R: */
		_address = freeStartAddress();
		/* begin gen:literal:operand: */
		checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, _resultReg));
		/* end gen:literal:operand: */
		/* end MoveAw:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(LoadEffectiveAddressMwrR, _allocSize, _resultReg, _scratch1);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_allocSize));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin CmpCq:R: */
		_quickConstant = getScavengeThreshold();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _scratch1);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpAboveOrEqual: */
		_jumpFail2 = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
		/* end JumpAboveOrEqual: */
		/* begin MoveR:Aw: */
		_address2 = freeStartAddress();
		/* begin gen:operand:literal: */
		checkLiteralforInstruction(_address2, genoperandoperand(MoveRAw, _scratch1, _address2));
		/* end gen:operand:literal: */
		/* end MoveR:Aw: */
		/* begin genStoreHeader:intoNewInstance:using: */
		{
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction4 = genoperandoperand(MoveCqR, _newFloatHeader, _scratch1);
			if (usesOutOfLineLiteral(_anInstruction4)) {
				(_anInstruction4->dependent = locateLiteral(_newFloatHeader));
			}
			/* end checkQuickConstant:forInstruction: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction22 = genoperandoperandoperand(MoveRMwr, _scratch1, 0, _resultReg);
			if (usesOutOfLineLiteral(_anInstruction22)) {
				(_anInstruction22->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		/* end genStoreHeader:intoNewInstance:using: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperandoperand(MoveRdM64r, _dpreg, BaseHeaderSize, _resultReg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(BaseHeaderSize));
		}
		/* end checkQuickConstant:forInstruction: */
		_jumpFail = _jumpFail2;
	}
	jmpTarget(_jumpMerge, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return _jumpFail;
}
/*	Must be pointer */
/* CogObjectRepresentationFor64BitSpur>>#genBoxedOrSmallFloat:scratchReg:into: */
static AbstractInstruction * NoDbgRegParms
genBoxedOrSmallFloatscratchReginto(sqInt _floatOopReg, sqInt _scratchReg, sqInt _destReg)
{
	AbstractInstruction *_jumpFail;
	AbstractInstruction *_jumpFail2;
	AbstractInstruction *_jumpFailClass;
	AbstractInstruction *_jumpImmediate;
	AbstractInstruction *_jumpMerge;
	AbstractInstruction *_jumpMerge2;
	AbstractInstruction *_jumpNonSmallFloat;

	_jumpNonSmallFloat = genJumpNotSmallFloat(_floatOopReg);
	genGetSmallFloatValueOfscratchinto(_floatOopReg, _scratchReg, _destReg);
	/* begin Jump: */
	_jumpMerge = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpNonSmallFloat, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	{
		_jumpImmediate = genJumpImmediate(_floatOopReg);
		genGetCompactClassIndexNonImmOfinto(_floatOopReg, _scratchReg);
		genCmpClassFloatCompactIndexR(_scratchReg);
		/* begin JumpNonZero: */
		_jumpFailClass = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		genGetDoubleValueOfinto(_floatOopReg, _destReg);
		/* begin Jump: */
		_jumpMerge2 = genoperand(Jump, ((sqInt) 0 ));
		/* end Jump: */
		jmpTarget(_jumpImmediate, jmpTarget(_jumpFailClass, (_jumpFail2 = genoperand(Jump, ((sqInt) 0 )))));
		jmpTarget(_jumpMerge2, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
		_jumpFail = _jumpFail2;
	}
	jmpTarget(_jumpMerge, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return _jumpFail;
}
/*	Set the SmallInteger tag bits when the tag bits may be filled with 
	garbage.  */
/* CogObjectRepresentationFor64BitSpur>>#genClearAndSetSmallIntegerTagsIn: */
static sqInt NoDbgRegParms
genClearAndSetSmallIntegerTagsIn(sqInt _scratchReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	sqInt _quickConstant;

	{
		/* begin AndCq:R: */
		_quickConstant = -1 - (tagMask());
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(AndCqR, _quickConstant, _scratchReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end AndCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(OrCqR, 1, _scratchReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	return 0;
}
/*	Convert the in-SmallFloat64-range floating point value in integer register 
	into a tagged SmallFloat64 oop. 
	c.f. Spur64BitMemoryManager>>smallFloatObjectOf: */
/* CogObjectRepresentationFor64BitSpur>>#genConvertBitsToSmallFloatIn:scratch: */
static sqInt NoDbgRegParms
genConvertBitsToSmallFloatInscratch(sqInt _reg, sqInt scratch)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_jumpZero;
	sqInt _quickConstant;
	sqInt _quickConstant2;

	{
		/* begin RotateLeftCq:R: */
		genoperandoperand(RotateLeftCqR, 1, _reg);
		/* end RotateLeftCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, 1, _reg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin JumpBelowOrEqual: */
	_jumpZero = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin SubCq:R: */
	_quickConstant = ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(SubCqR, _quickConstant, _reg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end SubCq:R: */
	jmpTarget(_jumpZero, gLogicalShiftLeftCqR(numTagBits(), _reg));
	/* begin AddCq:R: */
	_quickConstant2 = smallFloatTag();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(AddCqR, _quickConstant2, _reg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AddCq:R: */
	return 0;
}
/*	Convert the Character in reg to a SmallInteger, assuming 
	the Character's value is a valid character. */
/* CogObjectRepresentationFor64BitSpur>>#genConvertCharacterToSmallIntegerInReg: */
static void NoDbgRegParms
genConvertCharacterToSmallIntegerInReg(sqInt _reg)
{
	AbstractInstruction *_anInstruction;
	sqInt _quickConstant;

	/* begin SubCq:R: */
	_quickConstant = (characterTag()) - (smallIntegerTag());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(SubCqR, _quickConstant, _reg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end SubCq:R: */
}
/* CogObjectRepresentationFor64BitSpur>>#genConvertDataFormat:numSlots:intoBytes: */
static void NoDbgRegParms
genConvertDataFormatnumSlotsintoBytes(sqInt _formatReg, sqInt _slotsRegister, sqInt _destReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction * _jumpBytesDone;
	AbstractInstruction * _jumpIsBytes;
	AbstractInstruction * _jumpIsLongs;
	AbstractInstruction * _jumpIsShorts;
	AbstractInstruction * _jumpLongLongsDone;
	AbstractInstruction * _jumpLongsDone;
	AbstractInstruction * _jumpShortsDone;
	sqInt _quickConstant;
	sqInt _quickConstant2;
	sqInt _quickConstant3;

	if (_slotsRegister != _destReg) {
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, _slotsRegister, _destReg);
		/* end MoveR:R: */
	}
	/* begin CmpCq:R: */
	_quickConstant = firstByteFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpIsBytes = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant2 = firstShortFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant2, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpIsShorts = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant3 = firstLongFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant3, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant3));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpIsLongs = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin LogicalShiftLeftCq:R: */
	genoperandoperand(LogicalShiftLeftCqR, shiftForWord(), _destReg);
	/* end LogicalShiftLeftCq:R: */
	/* begin Jump: */
	_jumpLongLongsDone = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpIsBytes, gLogicalShiftLeftCqR(shiftForWord(), _destReg));
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AndCqR, BytesPerWord - 1, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BytesPerWord - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, _formatReg, _destReg);
	/* end SubR:R: */
	/* begin Jump: */
	_jumpBytesDone = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpIsShorts, gLogicalShiftLeftCqR((shiftForWord()) - 1, _destReg));
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction5 = genoperandoperand(AndCqR, (((usqInt) BytesPerWord ) >> 1) - 1, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction5)) {
		(_anInstruction5->dependent = locateLiteral((((usqInt) BytesPerWord ) >> 1) - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, _formatReg, _destReg);
	/* end SubR:R: */
	/* begin LogicalShiftLeftCq:R: */
	genoperandoperand(LogicalShiftLeftCqR, 1, _destReg);
	/* end LogicalShiftLeftCq:R: */
	/* begin Jump: */
	_jumpShortsDone = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpIsLongs, gLogicalShiftLeftCqR((shiftForWord()) - 2, _destReg));
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction6 = genoperandoperand(AndCqR, (((usqInt) BytesPerWord ) >> 2) - 1, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction6)) {
		(_anInstruction6->dependent = locateLiteral((((usqInt) BytesPerWord ) >> 2) - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, _formatReg, _destReg);
	/* end SubR:R: */
	/* begin LogicalShiftLeftCq:R: */
	genoperandoperand(LogicalShiftLeftCqR, 2, _destReg);
	/* end LogicalShiftLeftCq:R: */
	/* begin Jump: */
	_jumpLongsDone = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpLongLongsDone, jmpTarget(_jumpLongsDone, jmpTarget(_jumpShortsDone, jmpTarget(_jumpBytesDone, genoperandoperand(Label, (labelCounter += 1), bytecodePC)))));
}
/* CogObjectRepresentationFor64BitSpur>>#genConvertIntegerToSmallIntegerInReg: */
static sqInt NoDbgRegParms
genConvertIntegerToSmallIntegerInReg(sqInt _reg)
{
	AbstractInstruction *_anInstruction;
	sqInt _quickConstant;

	/* begin LogicalShiftLeftCq:R: */
	_quickConstant = numTagBits();
	genoperandoperand(LogicalShiftLeftCqR, _quickConstant, _reg);
	/* end LogicalShiftLeftCq:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(AddCqR, 1, _reg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	return 0;
}
/*	Convert the SmallFloat in reg to its identityHash as a SmallInteger. 
	Rotate the sign bit from bit 3 (zero-relative) to the sign bit.  
	c.f. Spur64BitMemoryManager>>rotatedFloatBitsOf: */
/* CogObjectRepresentationFor64BitSpur>>#genConvertSmallFloatToSmallFloatHashAsIntegerInReg:scratch: */
static sqInt NoDbgRegParms
genConvertSmallFloatToSmallFloatHashAsIntegerInRegscratch(sqInt _reg, sqInt _scratch)
{
	AbstractInstruction *_anInstruction;
	sqInt _quickConstant;
	sqInt _quickConstant2;

	assert(((((usqInt) (smallFloatTag()) ) >> 1) - (smallIntegerTag())) == (smallIntegerTag()));
	{
		/* begin LogicalShiftRightCq:R: */
		genoperandoperand(LogicalShiftRightCqR, 1, _reg);
		/* end LogicalShiftRightCq:R: */
		gAndCqRR(1U << ((numTagBits()) - 1), _reg, _scratch);
		/* begin SubR:R: */
		genoperandoperand(SubRR, _scratch, _reg);
		/* end SubR:R: */
		/* begin SubCq:R: */
		_quickConstant2 = (((usqInt) (smallFloatTag()) ) >> 1) - (smallIntegerTag());
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(SubCqR, _quickConstant2, _reg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_quickConstant2));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end SubCq:R: */
		/* begin LogicalShiftLeftCq:R: */
		_quickConstant = 0x3F - ((numTagBits()) - 1);
		genoperandoperand(LogicalShiftLeftCqR, _quickConstant, _scratch);
		/* end LogicalShiftLeftCq:R: */
		/* begin OrR:R: */
		genoperandoperand(OrRR, _scratch, _reg);
		/* end OrR:R: */
	}
	return 0;
}
/*	Convert the SmallInteger in reg to a Character, assuming 
	the SmallInteger's value is a valid character. */
/* CogObjectRepresentationFor64BitSpur>>#genConvertSmallIntegerToCharacterInReg: */
static void NoDbgRegParms
genConvertSmallIntegerToCharacterInReg(sqInt _reg)
{
	AbstractInstruction *_anInstruction;
	sqInt _quickConstant;

	/* begin AddCq:R: */
	_quickConstant = (characterTag()) - (smallIntegerTag());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(AddCqR, _quickConstant, _reg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AddCq:R: */
}
/* CogObjectRepresentationFor64BitSpur>>#genConvertSmallIntegerToIntegerInReg: */
static sqInt NoDbgRegParms
genConvertSmallIntegerToIntegerInReg(sqInt _reg)
{
	sqInt _quickConstant;

	/* begin ArithmeticShiftRightCq:R: */
	_quickConstant = numTagBits();
	genoperandoperand(ArithmeticShiftRightCqR, _quickConstant, _reg);
	/* end ArithmeticShiftRightCq:R: */
	return 0;
}
/* CogObjectRepresentationFor64BitSpur>>#genFloatArithmetic:preOpCheck:boxed: */
static sqInt NoDbgRegParms
genFloatArithmeticpreOpCheckboxed(sqInt _arithmeticOperator, AbstractInstruction *(*_preOpCheckOrNil)(int rcvrReg, int argReg), sqInt _rcvrBoxed)
{
	AbstractInstruction *_doOp;
	AbstractInstruction *_jumpFailAlloc;
	AbstractInstruction *_jumpFailCheck;
	AbstractInstruction *_jumpImmediate;
	AbstractInstruction *_jumpNotBoxedFloat;
	AbstractInstruction *_jumpNotSmallFloat;
	AbstractInstruction *_jumpNotSmallInteger;

	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	_jumpFailCheck = ((AbstractInstruction *) 0 );
	/* end genLoadArgAtDepth:into: */
	if (_rcvrBoxed) {
		genGetDoubleValueOfinto(ReceiverResultReg, DPFPReg0);
	}
 else {
		genGetSmallFloatValueOfscratchinto(ReceiverResultReg, TempReg, DPFPReg0);
	}
	_jumpNotSmallFloat = genJumpNotSmallFloat(Arg0Reg);
	genGetSmallFloatValueOfscratchinto(Arg0Reg, TempReg, DPFPReg1);
	/* begin Label */
	_doOp = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
	/* end Label */
	if (_preOpCheckOrNil) {
		_jumpFailCheck = _preOpCheckOrNil(DPFPReg0, DPFPReg1);
	}
	genoperandoperand(_arithmeticOperator, DPFPReg1, DPFPReg0);
	_jumpFailAlloc = genAllocFloatValueintoscratchRegscratchReg(DPFPReg0, SendNumArgsReg, ClassReg, TempReg);
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpNotSmallFloat, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	_jumpNotSmallInteger = genJumpNotSmallInteger(Arg0Reg);
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin ConvertR:Rd: */
	genoperandoperand(ConvertRRd, Arg1Reg, DPFPReg1);
	/* end ConvertR:Rd: */
	/* begin Jump: */
	genoperand(Jump, ((sqInt) _doOp ));
	/* end Jump: */
	jmpTarget(_jumpNotSmallInteger, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	_jumpImmediate = genJumpImmediate(Arg0Reg);
	genGetCompactClassIndexNonImmOfinto(Arg0Reg, SendNumArgsReg);
	genCmpClassFloatCompactIndexR(SendNumArgsReg);
	/* begin JumpNonZero: */
	_jumpNotBoxedFloat = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	genGetDoubleValueOfinto(Arg0Reg, DPFPReg1);
	/* begin Jump: */
	genoperand(Jump, ((sqInt) _doOp ));
	/* end Jump: */
	jmpTarget(_jumpImmediate, jmpTarget(_jumpNotBoxedFloat, jmpTarget(_jumpNotSmallInteger, jmpTarget(_jumpFailAlloc, genoperandoperand(Label, (labelCounter += 1), bytecodePC)))));
	if (_preOpCheckOrNil) {
		jmpTarget(_jumpFailCheck, ((AbstractInstruction *) ((_jumpFailAlloc->operands)[0]) ));
	}
	return 0;
}
/* CogObjectRepresentationFor64BitSpur>>#genFloatComparison:invert:boxed: */
static sqInt NoDbgRegParms
genFloatComparisoninvertboxed(AbstractInstruction *(*_jumpOpcodeGenerator)(void *), sqInt _invertComparison, sqInt _rcvrBoxed)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction * _compare;
	sqInt _constant;
	AbstractInstruction *_jumpCond;
	AbstractInstruction *_jumpImmediate;
	AbstractInstruction *_jumpNotBoxedFloat;
	AbstractInstruction *_jumpNotSmallFloat;
	AbstractInstruction *_jumpNotSmallInteger;

	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	if (_rcvrBoxed) {
		genGetDoubleValueOfinto(ReceiverResultReg, DPFPReg0);
	}
 else {
		genGetSmallFloatValueOfscratchinto(ReceiverResultReg, TempReg, DPFPReg0);
	}
	_jumpNotSmallFloat = genJumpNotSmallFloat(Arg0Reg);
	genGetSmallFloatValueOfscratchinto(Arg0Reg, TempReg, DPFPReg1);
	if (_invertComparison) {
		/* begin CmpRd:Rd: */
		_compare = genoperandoperand(CmpRdRd, DPFPReg0, DPFPReg1);
		/* end CmpRd:Rd: */
	}
 else {
		/* begin CmpRd:Rd: */
		_compare = genoperandoperand(CmpRdRd, DPFPReg1, DPFPReg0);
		/* end CmpRd:Rd: */
	}
	_jumpCond = _jumpOpcodeGenerator(0);
	/* begin genMoveConstant:R: */
	_constant = falseObject();
	if (shouldAnnotateObjectReference(_constant)) {
		annotateobjRef(gMoveCwR(_constant, ReceiverResultReg), _constant);
	} else {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, _constant, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_constant));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* end genMoveConstant:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpCond, genMoveConstantR(trueObject(), ReceiverResultReg));
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpNotSmallFloat, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	_jumpNotSmallInteger = genJumpNotSmallInteger(Arg0Reg);
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin ConvertR:Rd: */
	genoperandoperand(ConvertRRd, Arg0Reg, DPFPReg1);
	/* end ConvertR:Rd: */
	/* begin Jump: */
	genoperand(Jump, ((sqInt) _compare ));
	/* end Jump: */
	jmpTarget(_jumpNotSmallInteger, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	_jumpImmediate = genJumpImmediate(Arg0Reg);
	genGetCompactClassIndexNonImmOfinto(Arg0Reg, SendNumArgsReg);
	genCmpClassFloatCompactIndexR(SendNumArgsReg);
	/* begin JumpNonZero: */
	_jumpNotBoxedFloat = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	genGetDoubleValueOfinto(Arg0Reg, DPFPReg1);
	/* begin Jump: */
	genoperand(Jump, ((sqInt) _compare ));
	/* end Jump: */
	jmpTarget(_jumpImmediate, jmpTarget(_jumpNotBoxedFloat, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
}
/*	Fetch the instance's identity hash into destReg, encoded as a 
	SmallInteger.  */
/* CogObjectRepresentationFor64BitSpur>>#genGetHashFieldNonImmOf:asSmallIntegerInto: */
static sqInt NoDbgRegParms
genGetHashFieldNonImmOfasSmallIntegerInto(sqInt _instReg, sqInt _destReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _quickConstant;
	sqInt _quickConstant2;
	sqInt _quickConstant3;

	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMwrR, 0, _instReg, _destReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin LogicalShiftRightCq:R: */
		_quickConstant = (identityHashFullWordShift()) - (numTagBits());
		genoperandoperand(LogicalShiftRightCqR, _quickConstant, _destReg);
		/* end LogicalShiftRightCq:R: */
		/* begin AndCq:R: */
		_quickConstant2 = ((sqInt) (((usqInt) (identityHashHalfWordMask()) ) << (numTagBits())) );
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(AndCqR, _quickConstant2, _destReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(_quickConstant2));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end AndCq:R: */
		/* begin AddCq:R: */
		_quickConstant3 = smallIntegerTag();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperand(AddCqR, _quickConstant3, _destReg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(_quickConstant3));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end AddCq:R: */
	}
	return 0;
}
/*	Fetch the instance's identity hash into destReg, unencoded. */
/* CogObjectRepresentationFor64BitSpur>>#genGetHashFieldNonImmOf:into: */
static sqInt NoDbgRegParms
genGetHashFieldNonImmOfinto(sqInt _instReg, sqInt _destReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	sqInt _quickConstant;

	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMwrR, 0, _instReg, _destReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin LogicalShiftRightCq:R: */
		genoperandoperand(LogicalShiftRightCqR, 32, _destReg);
		/* end LogicalShiftRightCq:R: */
		/* begin AndCq:R: */
		_quickConstant = identityHashHalfWordMask();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(AndCqR, _quickConstant, _destReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end AndCq:R: */
	}
	return 0;
}
/*	Extract the inline cache tag for the object in sourceReg into destReg. The 
	inline cache tag for a given object is the value loaded in inline caches 
	to distinguish 
	objects of different classes. In Spur this is either the tags for 
	immediates, or 
	the receiver's classIndex. Answer the label for the start of the sequence. */
/* CogObjectRepresentationFor64BitSpur>>#genGetInlineCacheClassTagFrom:into: */
static AbstractInstruction * NoDbgRegParms
genGetInlineCacheClassTagFrominto(sqInt _sourceReg, sqInt _destReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_entryLabel;
	AbstractInstruction *_jumpImm;
	sqInt _quickConstant;

	/* begin Label */
	_entryLabel = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
	/* end Label */
	gAndCqRR(tagMask(), _sourceReg, _destReg);
	/* begin JumpNonZero: */
	_jumpImm = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	flag("endianness");
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveMwrR, 0, _sourceReg, _destReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AndCq:R: */
	_quickConstant = classIndexMask();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(AndCqR, _quickConstant, _destReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AndCq:R: */
	jmpTarget(_jumpImm, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return _entryLabel;
}
/*	Get the size in byte-sized slots of the object in srcReg into destReg. 
	srcReg may equal destReg. 
	destReg <- numSlots << self shiftForWord - (fmt bitAnd: 7). 
	Assumes the object in srcReg has a byte format, i.e. 16 to 23 or 24 to 31 */
/* CogObjectRepresentationFor64BitSpur>>#genGetNumBytesOf:into: */
static sqInt NoDbgRegParms
genGetNumBytesOfinto(sqInt _srcReg, sqInt _destReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_jmp;
	sqInt _quickConstant;

	genGetRawSlotSizeOfNonImminto(_srcReg, _destReg);
	/* begin CmpCq:R: */
	_quickConstant = numSlotsMask();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(CmpCqR, _quickConstant, _destReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpLess: */
	_jmp = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
	/* end JumpLess: */
	genGetOverflowSlotsOfinto(_srcReg, _destReg);
	jmpTarget(_jmp, gLogicalShiftLeftCqR(shiftForWord(), _destReg));
	genGetBitsofFormatByteOfinto(7, _srcReg, TempReg);
	/* begin SubR:R: */
	genoperandoperand(SubRR, TempReg, _destReg);
	/* end SubR:R: */
	return 0;
}
/* CogObjectRepresentationFor64BitSpur>>#genGetOverflowSlotsOf:into: */
static sqInt NoDbgRegParms
genGetOverflowSlotsOfinto(sqInt _srcReg, sqInt _destReg)
{
	AbstractInstruction *_anInstruction;

	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMwrR, -BaseHeaderSize, _srcReg, _destReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(-BaseHeaderSize));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin LogicalShiftLeftCq:R: */
		genoperandoperand(LogicalShiftLeftCqR, 8, _destReg);
		/* end LogicalShiftLeftCq:R: */
		/* begin LogicalShiftRightCq:R: */
		genoperandoperand(LogicalShiftRightCqR, 8, _destReg);
		/* end LogicalShiftRightCq:R: */
	}
	return 0;
}
/*	Convert the SmallFloat oop in ooppReg into the corresponding float value 
	in dpReg. 
	c.f. Spur64BitMemoryManager>>smallFloatBitsOf: */
/* CogObjectRepresentationFor64BitSpur>>#genGetSmallFloatValueOf:scratch:into: */
static sqInt NoDbgRegParms
genGetSmallFloatValueOfscratchinto(sqInt _oopReg, sqInt _scratch, sqInt _dpReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_jumpSFZero;
	sqInt _quickConstant;
	sqInt _quickConstant2;

	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, _oopReg, _scratch);
		/* end MoveR:R: */
		/* begin LogicalShiftRightCq:R: */
		_quickConstant = numTagBits();
		genoperandoperand(LogicalShiftRightCqR, _quickConstant, _scratch);
		/* end LogicalShiftRightCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, 1, _scratch);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin JumpLessOrEqual: */
	_jumpSFZero = genConditionalBranchoperand(JumpLessOrEqual, ((sqInt) 0 ));
	/* end JumpLessOrEqual: */
	/* begin AddCq:R: */
	_quickConstant2 = ((sqInt) (((usqInt) (smallFloatExponentOffset()) ) << ((smallFloatMantissaBits()) + 1)) );
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(AddCqR, _quickConstant2, _scratch);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AddCq:R: */
	jmpTarget(_jumpSFZero, genoperandoperand(RotateRightCqR, 1, _scratch));
	/* begin MoveR:Rd: */
	assert(BytesPerWord == 8);
	genoperandoperand(MoveRRd, _scratch, _dpReg);
	/* end MoveR:Rd: */
	return 0;
}
/* CogObjectRepresentationFor64BitSpur>>#genIntegerTo64BitPositiveIntegerValue:into:scratchReg:scratchReg: */
static AbstractInstruction * NoDbgRegParms
genIntegerTo64BitPositiveIntegerValueintoscratchRegscratchReg(sqInt _valueReg, sqInt _resultReg, sqInt _scratch1, sqInt _scratch2)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_jumpFail;
	AbstractInstruction *_jumpMerge;
	AbstractInstruction *_jumpNotSmallInteger;
	sqInt _quickConstant;

	/* begin MoveR:R: */
	genoperandoperand(MoveRR, _valueReg, _scratch1);
	/* end MoveR:R: */
	/* begin LogicalShiftRightCq:R: */
	_quickConstant = (numSmallIntegerBits()) - 1;
	genoperandoperand(LogicalShiftRightCqR, _quickConstant, _scratch1);
	/* end LogicalShiftRightCq:R: */
	if (!(setsConditionCodesFor(lastOpcode(), JumpZero))) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, 0, _scratch1);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin JumpNonZero: */
	_jumpNotSmallInteger = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, _valueReg, _resultReg);
	/* end MoveR:R: */
	genConvertIntegerToSmallIntegerInReg(_resultReg);
	/* begin Jump: */
	_jumpMerge = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpNotSmallInteger, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	_jumpFail = genAlloc64BitPositiveIntegerValueintoscratchRegscratchReg(_valueReg, _resultReg, _scratch1, _scratch2);
	jmpTarget(_jumpMerge, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return _jumpFail;
}
/* CogObjectRepresentationFor64BitSpur>>#genIntegerTo64BitSignedIntegerValue:into:scratchReg:scratchReg: */
static AbstractInstruction * NoDbgRegParms
genIntegerTo64BitSignedIntegerValueintoscratchRegscratchReg(sqInt _valueReg, sqInt _resultReg, sqInt _scratch1, sqInt _scratch2)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_jumpFail;
	AbstractInstruction *_jumpMerge;
	AbstractInstruction *_jumpNotSmallInteger;
	sqInt _quickConstant;

	/* begin MoveR:R: */
	genoperandoperand(MoveRR, _valueReg, _scratch1);
	/* end MoveR:R: */
	/* begin ArithmeticShiftRightCq:R: */
	_quickConstant = numSmallIntegerBits();
	genoperandoperand(ArithmeticShiftRightCqR, _quickConstant, _scratch1);
	/* end ArithmeticShiftRightCq:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(AddCqR, 1, _scratch1);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, 1, _scratch1);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpAbove: */
	_jumpNotSmallInteger = genConditionalBranchoperand(JumpAbove, ((sqInt) 0 ));
	/* end JumpAbove: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, _valueReg, _resultReg);
	/* end MoveR:R: */
	genConvertIntegerToSmallIntegerInReg(_resultReg);
	/* begin Jump: */
	_jumpMerge = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpNotSmallInteger, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	_jumpFail = genAlloc64BitSignedIntegerValueintoscratchRegscratchReg(_valueReg, _resultReg, _scratch1, _scratch2);
	jmpTarget(_jumpMerge, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return _jumpFail;
}
/*	Generate a test for aRegister containing an integer value in the 
	SmallInteger range, and a jump if so, answering the jump. 
	c.f. Spur64BitMemoryManager>>isIntegerValue: */
/* CogObjectRepresentationFor64BitSpur>>#genJumpIsSmallIntegerValue:scratch: */
static AbstractInstruction * NoDbgRegParms
genJumpIsSmallIntegerValuescratch(sqInt _aRegister, sqInt _scratchReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _quickConstant;
	sqInt _quickConstant2;

	return (/* begin MoveR:R: */ genoperandoperand(MoveRR, _aRegister, _scratchReg) /* end MoveR:R: */, /* begin ArithmeticShiftRightCq:R: */ (_quickConstant = 0x3F - (numTagBits())), genoperandoperand(ArithmeticShiftRightCqR, _quickConstant, _scratchReg) /* end ArithmeticShiftRightCq:R: */, /* begin checkQuickConstant:forInstruction: */ (_anInstruction = genoperandoperand(AddCqR, 1, _scratchReg)), ((usesOutOfLineLiteral(_anInstruction))
		 ? (_anInstruction->dependent = locateLiteral(1))
		 : 0) /* end checkQuickConstant:forInstruction: */, /* begin AndCq:R: */ (_quickConstant2 = (1U << ((numTagBits()) + 1)) - 1), /* begin checkQuickConstant:forInstruction: */ (_anInstruction2 = genoperandoperand(AndCqR, _quickConstant2, _scratchReg)), ((usesOutOfLineLiteral(_anInstruction2))
		 ? (_anInstruction2->dependent = locateLiteral(_quickConstant2))
		 : 0) /* end checkQuickConstant:forInstruction: */ /* end AndCq:R: */, /* begin checkQuickConstant:forInstruction: */ (_anInstruction3 = genoperandoperand(CmpCqR, 1, _scratchReg)), ((usesOutOfLineLiteral(_anInstruction3))
		 ? (_anInstruction3->dependent = locateLiteral(1))
		 : 0) /* end checkQuickConstant:forInstruction: */, /* begin JumpLessOrEqual: */ genConditionalBranchoperand(JumpLessOrEqual, ((sqInt) 0 )) /* end JumpLessOrEqual: */);
}
/*	Generate a compare and branch to test if aRegister contains other than a 
	Character.  */
/* CogObjectRepresentationFor64BitSpur>>#genJumpNotCharacter: */
static AbstractInstruction * NoDbgRegParms
genJumpNotCharacter(sqInt _reg)
{
	AbstractInstruction *_anInstruction;
	sqInt _quickConstant;

	return (/* begin TstCq:R: */ (_quickConstant = characterTag()), /* begin checkQuickConstant:forInstruction: */ (_anInstruction = genoperandoperand(TstCqR, _quickConstant, _reg)), ((usesOutOfLineLiteral(_anInstruction))
		 ? (_anInstruction->dependent = locateLiteral(_quickConstant))
		 : 0) /* end checkQuickConstant:forInstruction: */ /* end TstCq:R: */, /* begin JumpZero: */ genConditionalBranchoperand(JumpZero, ((sqInt) 0 )) /* end JumpZero: */);
}
/*	Generate a test to check that the integer register contains a floating 
	point value within the SmallFloat64 range, 
	and answer the jump. c.f. Spur64BitMemoryManager>>isSmallFloatValue: */
/* CogObjectRepresentationFor64BitSpur>>#genJumpNotSmallFloatValueBits:scratch: */
static AbstractInstruction * NoDbgRegParms
genJumpNotSmallFloatValueBitsscratch(sqInt _reg, sqInt _exponent)
{
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_jumpFail;
	AbstractInstruction *_jumpMaxExponent;
	AbstractInstruction *_jumpMinExponent;
	AbstractInstruction *_jumpTest;
	AbstractInstruction *_jumpZeroMantissa;
	sqInt _quickConstant;
	sqInt _quickConstant3;
	sqInt _quickConstant4;
	sqInt _quickConstant5;

	flag("if we combine the exponent range test with the conversion to tagged representation we test for a zero exponent only once. further, if we extract tags once into a scratch on the input side we test for immediates, SmallInteger and SmallFloat using the same intermediate result.  so to do is to move fp arithmetic into the object representations");
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, _reg, _exponent);
	/* end MoveR:R: */
	{
		{
			/* begin LogicalShiftLeftCq:R: */
			genoperandoperand(LogicalShiftLeftCqR, 1, _exponent);
			/* end LogicalShiftLeftCq:R: */
			/* begin LogicalShiftRightCq:R: */
			_quickConstant = (smallFloatMantissaBits()) + 1;
			genoperandoperand(LogicalShiftRightCqR, _quickConstant, _exponent);
			/* end LogicalShiftRightCq:R: */
		}
	}
	/* begin CmpCq:R: */
	_quickConstant3 = smallFloatExponentOffset();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant3, _exponent);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant3));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpLessOrEqual: */
	_jumpMinExponent = genConditionalBranchoperand(JumpLessOrEqual, ((sqInt) 0 ));
	/* end JumpLessOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant4 = 0xFF + (smallFloatExponentOffset());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant4, _exponent);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpLessOrEqual: */
	_jumpMaxExponent = genConditionalBranchoperand(JumpLessOrEqual, ((sqInt) 0 ));
	/* end JumpLessOrEqual: */
	/* begin Jump: */
	_jumpFail = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpMinExponent, gTstCqR((1ULL << (smallFloatMantissaBits())) - 1, _reg));
	/* begin JumpZero: */
	_jumpZeroMantissa = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* begin CmpCq:R: */
	_quickConstant5 = smallFloatExponentOffset();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(CmpCqR, _quickConstant5, _exponent);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(_quickConstant5));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin Jump: */
	_jumpTest = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpZeroMantissa, checkQuickConstantforInstruction(0, genoperandoperand(CmpCqR, 0, _exponent)));
	jmpTarget(_jumpTest, genConditionalBranchoperand(JumpNonZero, ((sqInt) _jumpFail )));
	jmpTarget(_jumpMaxExponent, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return _jumpFail;
}
/*	Generate a compare and branch to test if aRegister contains other than a 
	SmallFloat. Answer the jump. */
/* CogObjectRepresentationFor64BitSpur>>#genJumpNotSmallFloat: */
static AbstractInstruction * NoDbgRegParms
genJumpNotSmallFloat(sqInt _reg)
{
	AbstractInstruction *_anInstruction;
	sqInt _quickConstant;

	return (/* begin TstCq:R: */ (_quickConstant = smallFloatTag()), /* begin checkQuickConstant:forInstruction: */ (_anInstruction = genoperandoperand(TstCqR, _quickConstant, _reg)), ((usesOutOfLineLiteral(_anInstruction))
		 ? (_anInstruction->dependent = locateLiteral(_quickConstant))
		 : 0) /* end checkQuickConstant:forInstruction: */ /* end TstCq:R: */, /* begin JumpZero: */ genConditionalBranchoperand(JumpZero, ((sqInt) 0 )) /* end JumpZero: */);
}
/*	Generate a test for aRegister containing an integer value outside the 
	SmallInteger range, and a jump if so, answering the jump. 
	c.f. Spur64BitMemoryManager>>isIntegerValue: */
/* CogObjectRepresentationFor64BitSpur>>#genJumpNotSmallIntegerValue:scratch: */
static AbstractInstruction * NoDbgRegParms
genJumpNotSmallIntegerValuescratch(sqInt _aRegister, sqInt _scratchReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _quickConstant;
	sqInt _quickConstant2;

	return (/* begin MoveR:R: */ genoperandoperand(MoveRR, _aRegister, _scratchReg) /* end MoveR:R: */, /* begin ArithmeticShiftRightCq:R: */ (_quickConstant = 0x3F - (numTagBits())), genoperandoperand(ArithmeticShiftRightCqR, _quickConstant, _scratchReg) /* end ArithmeticShiftRightCq:R: */, /* begin checkQuickConstant:forInstruction: */ (_anInstruction = genoperandoperand(AddCqR, 1, _scratchReg)), ((usesOutOfLineLiteral(_anInstruction))
		 ? (_anInstruction->dependent = locateLiteral(1))
		 : 0) /* end checkQuickConstant:forInstruction: */, /* begin AndCq:R: */ (_quickConstant2 = (1U << ((numTagBits()) + 1)) - 1), /* begin checkQuickConstant:forInstruction: */ (_anInstruction2 = genoperandoperand(AndCqR, _quickConstant2, _scratchReg)), ((usesOutOfLineLiteral(_anInstruction2))
		 ? (_anInstruction2->dependent = locateLiteral(_quickConstant2))
		 : 0) /* end checkQuickConstant:forInstruction: */ /* end AndCq:R: */, /* begin checkQuickConstant:forInstruction: */ (_anInstruction3 = genoperandoperand(CmpCqR, 1, _scratchReg)), ((usesOutOfLineLiteral(_anInstruction3))
		 ? (_anInstruction3->dependent = locateLiteral(1))
		 : 0) /* end checkQuickConstant:forInstruction: */, /* begin JumpGreater: */ genConditionalBranchoperand(JumpGreater, ((sqInt) 0 )) /* end JumpGreater: */);
}
/*	Generate a compare and branch to test if aRegister contains other than a 
	SmallInteger.  */
/* CogObjectRepresentationFor64BitSpur>>#genJumpNotSmallInteger: */
static AbstractInstruction * NoDbgRegParms
genJumpNotSmallInteger(sqInt _reg)
{
	AbstractInstruction *_anInstruction;
	sqInt _quickConstant;

	return (/* begin TstCq:R: */ (_quickConstant = smallIntegerTag()), /* begin checkQuickConstant:forInstruction: */ (_anInstruction = genoperandoperand(TstCqR, _quickConstant, _reg)), ((usesOutOfLineLiteral(_anInstruction))
		 ? (_anInstruction->dependent = locateLiteral(_quickConstant))
		 : 0) /* end checkQuickConstant:forInstruction: */ /* end TstCq:R: */, /* begin JumpZero: */ genConditionalBranchoperand(JumpZero, ((sqInt) 0 )) /* end JumpZero: */);
}
/*	Generate a compare and branch to test if aRegister contains a 
	SmallInteger. Answer the jump, or UnimplementedOperation if this cannot be 
	done with 
	a single register. */
/* CogObjectRepresentationFor64BitSpur>>#genJumpSmallInteger: */
static AbstractInstruction * NoDbgRegParms
genJumpSmallInteger(sqInt _aRegister)
{
	AbstractInstruction *_anInstruction;
	sqInt _quickConstant;

	return (/* begin TstCq:R: */ (_quickConstant = smallIntegerTag()), /* begin checkQuickConstant:forInstruction: */ (_anInstruction = genoperandoperand(TstCqR, _quickConstant, _aRegister)), ((usesOutOfLineLiteral(_anInstruction))
		 ? (_anInstruction->dependent = locateLiteral(_quickConstant))
		 : 0) /* end checkQuickConstant:forInstruction: */ /* end TstCq:R: */, /* begin JumpNonZero: */ genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 )) /* end JumpNonZero: */);
}
/*	Generate the code for primitives 61 & 165, at:put:/basicAt:put: & 
	integerAt:put:. If signedVersion is true 
	then generate signed accesses to the bits classes (a la 164 & 165). If 
	signedVersion is false, 
	generate unsigned accesses (a la 60, 61, 63 & 64).c.f. StackInterpreter>>stSizeOf: SpurMemoryManager>>lengthOf:format: 
	fixedFieldsOf:format:length:  */
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveAtPutSigned: */
static sqInt NoDbgRegParms
genPrimitiveAtPutSigned(sqInt _signedVersion)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction10;
	AbstractInstruction *_anInstruction11;
	AbstractInstruction *_anInstruction12;
	AbstractInstruction *_anInstruction13;
	AbstractInstruction *_anInstruction14;
	AbstractInstruction *_anInstruction15;
	AbstractInstruction *_anInstruction16;
	AbstractInstruction *_anInstruction17;
	AbstractInstruction *_anInstruction18;
	AbstractInstruction *_anInstruction19;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction20;
	AbstractInstruction *_anInstruction21;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction23;
	AbstractInstruction *_anInstruction24;
	AbstractInstruction *_anInstruction25;
	AbstractInstruction *_anInstruction26;
	AbstractInstruction *_anInstruction27;
	AbstractInstruction *_anInstruction28;
	AbstractInstruction *_anInstruction29;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction30;
	AbstractInstruction *_anInstruction31;
	AbstractInstruction *_anInstruction32;
	AbstractInstruction *_anInstruction33;
	AbstractInstruction *_anInstruction34;
	AbstractInstruction *_anInstruction35;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction *_anInstruction7;
	AbstractInstruction *_anInstruction8;
	AbstractInstruction *_anInstruction9;
	sqInt _formatReg;
	AbstractInstruction * _jump64BitArgIsImmediate;
	AbstractInstruction * _jump64BitsOutOfBounds;
	AbstractInstruction * _jumpArrayOutOfBounds;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpBytesOutOfBounds;
	AbstractInstruction * _jumpBytesOutOfRange;
	AbstractInstruction * _jumpDoubleWordsOutOfRange;
	AbstractInstruction * _jumpFixedFieldsOutOfBounds;
	AbstractInstruction * _jumpHasFixedFields;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpImmutable;
	AbstractInstruction * _jumpIsBytes;
	AbstractInstruction * _jumpIsCompiledMethod;
	AbstractInstruction * _jumpIsContext;
	AbstractInstruction * _jumpIsShorts;
	AbstractInstruction * _jumpIsWords;
	AbstractInstruction * _jumpNegative;
	AbstractInstruction * _jumpNonSmallIntegerValue;
	AbstractInstruction * _jumpNot64BitIndexable;
	AbstractInstruction * _jumpNot8ByteInteger;
	AbstractInstruction * _jumpNotIndexableBits;
	AbstractInstruction * _jumpNotIndexablePointers;
	AbstractInstruction * _jumpNotPointers;
	AbstractInstruction * _jumpShortsOutOfBounds;
	AbstractInstruction * _jumpShortsOutOfRange;
	AbstractInstruction * _jumpWordsOutOfBounds;
	AbstractInstruction * _jumpWordsOutOfRange;
	AbstractInstruction * _methodInBounds;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;
	sqInt _quickConstant10;
	sqInt _quickConstant11;
	sqInt _quickConstant12;
	sqInt _quickConstant13;
	sqInt _quickConstant14;
	sqInt _quickConstant15;
	sqInt _quickConstant2;
	sqInt _quickConstant3;
	sqInt _quickConstant4;
	sqInt _quickConstant5;
	sqInt _quickConstant6;
	sqInt _quickConstant7;
	sqInt _quickConstant8;
	sqInt _quickConstant9;
	AbstractInstruction * _rejoin;

	_jumpDoubleWordsOutOfRange = ((AbstractInstruction *) 0 );
	_jumpImmutable = ((AbstractInstruction *) 0 );
	_jumpNegative = ((AbstractInstruction *) 0 );
	_nSlotsOrBytesReg = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction12 = genoperandoperand(SubCqR, 1, Arg0Reg);
	if (usesOutOfLineLiteral(_anInstruction12)) {
		(_anInstruction12->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	
#  if IMMUTABILITY
	{
		genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
		/* begin genJumpBaseHeaderImmutable: */
		/* begin TstCq:R: */
		_quickConstant15 = immutableBitMask();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction35 = genoperandoperand(TstCqR, _quickConstant15, TempReg);
		if (usesOutOfLineLiteral(_anInstruction35)) {
			(_anInstruction35->dependent = locateLiteral(_quickConstant15));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end TstCq:R: */
		/* begin JumpNonZero: */
		_jumpImmutable = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		/* end genJumpBaseHeaderImmutable: */
	}
#  else /* IMMUTABILITY */
	{
		genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), NoReg);
	}
#  endif /* IMMUTABILITY */
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = weakArrayFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction13 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction13)) {
		(_anInstruction13->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAbove: */
	_jumpNotPointers = genConditionalBranchoperand(JumpAbove, ((sqInt) 0 ));
	/* end JumpAbove: */
	genStoreCheckReceiverRegvalueRegscratchReginFrame(ReceiverResultReg, Arg1Reg, TempReg, 0);
	/* begin CmpCq:R: */
	_quickConstant2 = arrayFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction14 = genoperandoperand(CmpCqR, _quickConstant2, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction14)) {
		(_anInstruction14->dependent = locateLiteral(_quickConstant2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpNotIndexablePointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin JumpNonZero: */
	_jumpHasFixedFields = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, Arg0Reg, _nSlotsOrBytesReg);
	/* end CmpR:R: */
	/* begin JumpBelowOrEqual: */
	_jumpArrayOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin AddCq:R: */
	_quickConstant3 = ((usqInt) BaseHeaderSize ) >> (shiftForWord());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction15 = genoperandoperand(AddCqR, _quickConstant3, Arg0Reg);
	if (usesOutOfLineLiteral(_anInstruction15)) {
		(_anInstruction15->dependent = locateLiteral(_quickConstant3));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AddCq:R: */
	/* begin MoveR:Xwr:R: */
	genoperandoperandoperand(MoveRXwrR, Arg1Reg, Arg0Reg, ReceiverResultReg);
	/* end MoveR:Xwr:R: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpHasFixedFields, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	genGetClassIndexOfNonImminto(ReceiverResultReg, _formatReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction16 = genoperandoperand(CmpCqR, ClassMethodContextCompactIndex, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction16)) {
		(_anInstruction16->dependent = locateLiteral(ClassMethodContextCompactIndex));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpZero: */
	_jumpIsContext = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	genGetClassObjectOfClassIndexintoscratchReg(_formatReg, Extra0Reg, TempReg);
	genLoadSlotsourceRegdestReg(InstanceSpecificationIndex, Extra0Reg, _formatReg);
	genConvertSmallIntegerToIntegerInReg(_formatReg);
	/* begin AndCq:R: */
	_quickConstant4 = fixedFieldsOfClassFormatMask();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction17 = genoperandoperand(AndCqR, _quickConstant4, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction17)) {
		(_anInstruction17->dependent = locateLiteral(_quickConstant4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AndCq:R: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, _formatReg, _nSlotsOrBytesReg);
	/* end SubR:R: */
	/* begin AddCq:R: */
	_quickConstant5 = ((usqInt) BaseHeaderSize ) >> (shiftForWord());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction18 = genoperandoperand(AddCqR, _quickConstant5, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction18)) {
		(_anInstruction18->dependent = locateLiteral(_quickConstant5));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AddCq:R: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, Arg0Reg, _nSlotsOrBytesReg);
	/* end CmpR:R: */
	/* begin JumpBelowOrEqual: */
	_jumpFixedFieldsOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, _formatReg, Arg0Reg);
	/* end AddR:R: */
	/* begin MoveR:Xwr:R: */
	genoperandoperandoperand(MoveRXwrR, Arg1Reg, Arg0Reg, ReceiverResultReg);
	/* end MoveR:Xwr:R: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpNotPointers, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpNonSmallIntegerValue = genJumpNotSmallInteger(Arg1Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	/* begin CmpCq:R: */
	_quickConstant6 = firstByteFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction19 = genoperandoperand(CmpCqR, _quickConstant6, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction19)) {
		(_anInstruction19->dependent = locateLiteral(_quickConstant6));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpIsBytes = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant7 = firstShortFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction20 = genoperandoperand(CmpCqR, _quickConstant7, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction20)) {
		(_anInstruction20->dependent = locateLiteral(_quickConstant7));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpIsShorts = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant8 = firstLongFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction21 = genoperandoperand(CmpCqR, _quickConstant8, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction21)) {
		(_anInstruction21->dependent = locateLiteral(_quickConstant8));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpIsWords = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant9 = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction22 = genoperandoperand(CmpCqR, _quickConstant9, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction22)) {
		(_anInstruction22->dependent = locateLiteral(_quickConstant9));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNotIndexableBits = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg1Reg, SendNumArgsReg);
	/* end MoveR:R: */
	genConvertSmallIntegerToIntegerInReg(SendNumArgsReg);
	if (!_signedVersion) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, 0, SendNumArgsReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin JumpLess: */
		_jumpNegative = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
		/* end JumpLess: */
	}
	/* begin CmpR:R: */
	_rejoin = genoperandoperand(CmpRR, Arg0Reg, _nSlotsOrBytesReg);
	/* end CmpR:R: */
	/* begin JumpBelowOrEqual: */
	_jump64BitsOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin AddCq:R: */
	_quickConstant10 = ((usqInt) BaseHeaderSize ) >> (shiftForWord());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction23 = genoperandoperand(AddCqR, _quickConstant10, Arg0Reg);
	if (usesOutOfLineLiteral(_anInstruction23)) {
		(_anInstruction23->dependent = locateLiteral(_quickConstant10));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AddCq:R: */
	/* begin MoveR:Xwr:R: */
	genoperandoperandoperand(MoveRXwrR, SendNumArgsReg, Arg0Reg, ReceiverResultReg);
	/* end MoveR:Xwr:R: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpNonSmallIntegerValue, gCmpCqR(sixtyFourBitIndexableFormat(), _formatReg));
	/* begin JumpNonZero: */
	_jumpNot64BitIndexable = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	_jump64BitArgIsImmediate = genJumpImmediate(Arg1Reg);
	if (_signedVersion) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, Arg1Reg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperand(CmpCqR, 0, TempReg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin JumpLess: */
		_jumpDoubleWordsOutOfRange = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
		/* end JumpLess: */
	}
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction24 = genoperandoperandoperand(MoveMwrR, 0, Arg1Reg, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction24)) {
		(_anInstruction24->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AndCq:R: */
	_quickConstant11 = headerForSlotsformatclassIndex(numSlotsMask(), formatMask(), classIndexMask());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction25 = genoperandoperand(AndCqR, _quickConstant11, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction25)) {
		(_anInstruction25->dependent = locateLiteral(_quickConstant11));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AndCq:R: */
	/* begin CmpCq:R: */
	_quickConstant12 = headerForSlotsformatclassIndex(1, firstByteFormat(), ClassLargePositiveIntegerCompactIndex);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction26 = genoperandoperand(CmpCqR, _quickConstant12, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction26)) {
		(_anInstruction26->dependent = locateLiteral(_quickConstant12));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNot8ByteInteger = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction27 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, Arg1Reg, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction27)) {
		(_anInstruction27->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin Jump: */
	genoperand(Jump, ((sqInt) _rejoin ));
	/* end Jump: */
	if (_signedVersion) {
		jmpTarget(_jumpNot8ByteInteger, gCmpCqR(headerForSlotsformatclassIndex(1, firstByteFormat(), ClassLargeNegativeIntegerCompactIndex), SendNumArgsReg));
		/* begin JumpNonZero: */
		_jumpNot8ByteInteger = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction4 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, Arg1Reg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction4)) {
			(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(MoveCqR, 0, SendNumArgsReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin SubR:R: */
		genoperandoperand(SubRR, TempReg, SendNumArgsReg);
		/* end SubR:R: */
		/* begin Jump: */
		genoperand(Jump, ((sqInt) _rejoin ));
		/* end Jump: */
	}
	if (_signedVersion) {
		jmpTarget(_jumpIsWords, genoperandoperand(MoveRR, SendNumArgsReg, TempReg));
		/* begin ArithmeticShiftRightCq:R: */
		genoperandoperand(ArithmeticShiftRightCqR, 0x1F, TempReg);
		/* end ArithmeticShiftRightCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction6 = genoperandoperand(AddCqR, 1, TempReg);
		if (usesOutOfLineLiteral(_anInstruction6)) {
			(_anInstruction6->dependent = locateLiteral(1));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction7 = genoperandoperand(CmpCqR, 1, TempReg);
		if (usesOutOfLineLiteral(_anInstruction7)) {
			(_anInstruction7->dependent = locateLiteral(1));
		}
		/* end checkQuickConstant:forInstruction: */
	} else {
		jmpTarget(_jumpIsWords, checkQuickConstantforInstruction(((((usqInt) 0xFFFFFFFFU ) << 3) | 1), genoperandoperand(CmpCqR, ((((usqInt) 0xFFFFFFFFU ) << 3) | 1), Arg1Reg)));
	}
	/* begin JumpAbove: */
	_jumpWordsOutOfRange = genConditionalBranchoperand(JumpAbove, ((sqInt) 0 ));
	/* end JumpAbove: */
	/* begin LogicalShiftLeftCq:R: */
	genoperandoperand(LogicalShiftLeftCqR, (shiftForWord()) - 2, _nSlotsOrBytesReg);
	/* end LogicalShiftLeftCq:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction28 = genoperandoperand(AndCqR, (BytesPerWord / 4) - 1, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction28)) {
		(_anInstruction28->dependent = locateLiteral((BytesPerWord / 4) - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, _formatReg, _nSlotsOrBytesReg);
	/* end SubR:R: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, Arg0Reg, _nSlotsOrBytesReg);
	/* end CmpR:R: */
	/* begin JumpBelowOrEqual: */
	_jumpWordsOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg1Reg, TempReg);
	/* end MoveR:R: */
	genConvertSmallIntegerToIntegerInReg(TempReg);
	/* begin AddCq:R: */
	_quickConstant13 = ((usqInt) BaseHeaderSize ) >> ((shiftForWord()) - 1);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction29 = genoperandoperand(AddCqR, _quickConstant13, Arg0Reg);
	if (usesOutOfLineLiteral(_anInstruction29)) {
		(_anInstruction29->dependent = locateLiteral(_quickConstant13));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AddCq:R: */
	/* begin MoveR:X32r:R: */
	genoperandoperandoperand(MoveRX32rR, TempReg, Arg0Reg, ReceiverResultReg);
	/* end MoveR:X32r:R: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	if (_signedVersion) {
		jmpTarget(_jumpIsBytes, genoperandoperand(MoveRR, SendNumArgsReg, TempReg));
		/* begin ArithmeticShiftRightCq:R: */
		genoperandoperand(ArithmeticShiftRightCqR, 7, TempReg);
		/* end ArithmeticShiftRightCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction8 = genoperandoperand(AddCqR, 1, TempReg);
		if (usesOutOfLineLiteral(_anInstruction8)) {
			(_anInstruction8->dependent = locateLiteral(1));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction9 = genoperandoperand(CmpCqR, 1, TempReg);
		if (usesOutOfLineLiteral(_anInstruction9)) {
			(_anInstruction9->dependent = locateLiteral(1));
		}
		/* end checkQuickConstant:forInstruction: */
	} else {
		jmpTarget(_jumpIsBytes, checkQuickConstantforInstruction(((((usqInt) 0xFF ) << 3) | 1), genoperandoperand(CmpCqR, ((((usqInt) 0xFF ) << 3) | 1), Arg1Reg)));
	}
	/* begin JumpAbove: */
	_jumpBytesOutOfRange = genConditionalBranchoperand(JumpAbove, ((sqInt) 0 ));
	/* end JumpAbove: */
	/* begin LogicalShiftLeftCq:R: */
	genoperandoperand(LogicalShiftLeftCqR, shiftForWord(), _nSlotsOrBytesReg);
	/* end LogicalShiftLeftCq:R: */
	gAndCqRR(BytesPerWord - 1, _formatReg, TempReg);
	/* begin SubR:R: */
	genoperandoperand(SubRR, TempReg, _nSlotsOrBytesReg);
	/* end SubR:R: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, Arg0Reg, _nSlotsOrBytesReg);
	/* end CmpR:R: */
	/* begin JumpBelowOrEqual: */
	_jumpBytesOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant14 = firstCompiledMethodFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction30 = genoperandoperand(CmpCqR, _quickConstant14, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction30)) {
		(_anInstruction30->dependent = locateLiteral(_quickConstant14));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpIsCompiledMethod = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	_methodInBounds = genoperandoperand(MoveRR, Arg1Reg, TempReg);
	/* end MoveR:R: */
	genConvertSmallIntegerToIntegerInReg(TempReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction31 = genoperandoperand(AddCqR, BaseHeaderSize, Arg0Reg);
	if (usesOutOfLineLiteral(_anInstruction31)) {
		(_anInstruction31->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin MoveR:Xbr:R: */
	genoperandoperandoperand(MoveRXbrR, TempReg, Arg0Reg, ReceiverResultReg);
	/* end MoveR:Xbr:R: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	if (_signedVersion) {
		jmpTarget(_jumpIsShorts, genoperandoperand(MoveRR, SendNumArgsReg, TempReg));
		/* begin ArithmeticShiftRightCq:R: */
		genoperandoperand(ArithmeticShiftRightCqR, 15, TempReg);
		/* end ArithmeticShiftRightCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction10 = genoperandoperand(AddCqR, 1, TempReg);
		if (usesOutOfLineLiteral(_anInstruction10)) {
			(_anInstruction10->dependent = locateLiteral(1));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction11 = genoperandoperand(CmpCqR, 1, TempReg);
		if (usesOutOfLineLiteral(_anInstruction11)) {
			(_anInstruction11->dependent = locateLiteral(1));
		}
		/* end checkQuickConstant:forInstruction: */
	} else {
		jmpTarget(_jumpIsShorts, checkQuickConstantforInstruction(((((usqInt) 0xFFFF ) << 3) | 1), genoperandoperand(CmpCqR, ((((usqInt) 0xFFFF ) << 3) | 1), Arg1Reg)));
	}
	/* begin JumpAbove: */
	_jumpShortsOutOfRange = genConditionalBranchoperand(JumpAbove, ((sqInt) 0 ));
	/* end JumpAbove: */
	/* begin LogicalShiftLeftCq:R: */
	genoperandoperand(LogicalShiftLeftCqR, (shiftForWord()) - 1, _nSlotsOrBytesReg);
	/* end LogicalShiftLeftCq:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction32 = genoperandoperand(AndCqR, (BytesPerWord / 2) - 1, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction32)) {
		(_anInstruction32->dependent = locateLiteral((BytesPerWord / 2) - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, _formatReg, _nSlotsOrBytesReg);
	/* end SubR:R: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, Arg0Reg, _nSlotsOrBytesReg);
	/* end CmpR:R: */
	/* begin JumpBelowOrEqual: */
	_jumpShortsOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg1Reg, TempReg);
	/* end MoveR:R: */
	genConvertSmallIntegerToIntegerInReg(TempReg);
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, ReceiverResultReg);
	/* end AddR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, ReceiverResultReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction33 = genoperandoperandoperand(MoveRM16r, TempReg, BaseHeaderSize, ReceiverResultReg);
	if (usesOutOfLineLiteral(_anInstruction33)) {
		(_anInstruction33->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpIsCompiledMethod, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	getLiteralCountOfplusOneinBytesintoscratch(ReceiverResultReg, 1, 1, _nSlotsOrBytesReg, TempReg);
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, Arg0Reg, _nSlotsOrBytesReg);
	/* end CmpR:R: */
	/* begin JumpBelow: */
	genConditionalBranchoperand(JumpBelow, ((sqInt) _methodInBounds ));
	/* end JumpBelow: */
	jmpTarget(_jumpNot8ByteInteger, jmpTarget(_jump64BitArgIsImmediate, jmpTarget(_jumpNot64BitIndexable, jmpTarget(_jumpIsContext, jmpTarget(_jumpNotIndexableBits, jmpTarget(_jumpBytesOutOfRange, jmpTarget(_jumpShortsOutOfRange, jmpTarget(_jumpWordsOutOfRange, jmpTarget(_jumpIsCompiledMethod, jmpTarget(_jumpArrayOutOfBounds, jmpTarget(_jumpBytesOutOfBounds, jmpTarget(_jumpShortsOutOfBounds, jmpTarget(_jumpWordsOutOfBounds, jmpTarget(_jump64BitsOutOfBounds, jmpTarget(_jumpNotIndexablePointers, jmpTarget(_jumpFixedFieldsOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC)))))))))))))))));
	if (_signedVersion) {
		jmpTarget(_jumpDoubleWordsOutOfRange, ((AbstractInstruction *) ((_jumpIsContext->operands)[0]) ));
	}
 else {
		jmpTarget(_jumpNegative, ((AbstractInstruction *) ((_jumpIsContext->operands)[0]) ));
	}
	
#  if IMMUTABILITY
	{
		jmpTarget(_jumpImmutable, ((AbstractInstruction *) ((_jumpIsContext->operands)[0]) ));
	}
#  endif /* IMMUTABILITY */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction34 = genoperandoperand(AddCqR, 1, Arg0Reg);
	if (usesOutOfLineLiteral(_anInstruction34)) {
		(_anInstruction34->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return 0;
}
/*	Generate the code for primitives 60 & 164, at:/basicAt: & integerAt:. If 
	signedVersion is true 
	then generate signed accesses to the bits classes (a la 164 & 165). If 
	signedVersion is false, 
	generate unsigned accesses (a la 60, 61, 63 & 64).c.f. StackInterpreter>>stSizeOf: SpurMemoryManager>>lengthOf:format: 
	fixedFieldsOf:format:length:  */
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveAtSigned: */
static sqInt NoDbgRegParms
genPrimitiveAtSigned(sqInt _signedVersion)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction10;
	AbstractInstruction *_anInstruction11;
	AbstractInstruction *_anInstruction12;
	AbstractInstruction *_anInstruction13;
	AbstractInstruction *_anInstruction14;
	AbstractInstruction *_anInstruction15;
	AbstractInstruction *_anInstruction16;
	AbstractInstruction *_anInstruction17;
	AbstractInstruction *_anInstruction18;
	AbstractInstruction *_anInstruction19;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction20;
	AbstractInstruction *_anInstruction21;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction *_anInstruction7;
	AbstractInstruction *_anInstruction8;
	AbstractInstruction *_anInstruction9;
	AbstractInstruction * _convertToIntAndReturn;
	AbstractInstruction * _first;
	AbstractInstruction * _first2;
	AbstractInstruction * _first3;
	sqInt _formatReg;
	AbstractInstruction * _jumpArrayOutOfBounds;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpBytesOutOfBounds;
	AbstractInstruction * _jumpFailAlloc;
	AbstractInstruction * _jumpFixedFieldsOutOfBounds;
	AbstractInstruction * _jumpHasFixedFields;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIs16bitIndexable;
	AbstractInstruction * _jumpIs32bitIndexable;
	AbstractInstruction * _jumpIs64bitIndexable;
	AbstractInstruction * _jumpIsArray;
	AbstractInstruction * _jumpIsBytes;
	AbstractInstruction * _jumpIsContext;
	AbstractInstruction * _jumpIsMethod;
	AbstractInstruction * _jumpLongsOutOfBounds;
	AbstractInstruction * _jumpNotIndexable;
	AbstractInstruction * _jumpNotSmallInteger;
	AbstractInstruction * _jumpShortsOutOfBounds;
	AbstractInstruction * _jumpWordsOutOfBounds;
	AbstractInstruction * _methodInBounds;
	sqInt _nSlotsOrElementsReg;
	sqInt _quickConstant;
	sqInt _quickConstant10;
	sqInt _quickConstant11;
	sqInt _quickConstant12;
	sqInt _quickConstant13;
	sqInt _quickConstant14;
	sqInt _quickConstant2;
	sqInt _quickConstant3;
	sqInt _quickConstant4;
	sqInt _quickConstant5;
	sqInt _quickConstant6;
	sqInt _quickConstant7;
	sqInt _quickConstant8;
	sqInt _quickConstant9;

	_nSlotsOrElementsReg = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction5 = genoperandoperand(SubCqR, 1, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction5)) {
		(_anInstruction5->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrElementsReg);
	/* begin CmpCq:R: */
	_quickConstant4 = firstByteFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction6 = genoperandoperand(CmpCqR, _quickConstant4, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction6)) {
		(_anInstruction6->dependent = locateLiteral(_quickConstant4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpIsBytes = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant5 = arrayFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction7 = genoperandoperand(CmpCqR, _quickConstant5, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction7)) {
		(_anInstruction7->dependent = locateLiteral(_quickConstant5));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpZero: */
	_jumpIsArray = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* begin JumpBelow: */
	_jumpNotIndexable = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin CmpCq:R: */
	_quickConstant6 = weakArrayFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction8 = genoperandoperand(CmpCqR, _quickConstant6, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction8)) {
		(_anInstruction8->dependent = locateLiteral(_quickConstant6));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelowOrEqual: */
	_jumpHasFixedFields = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant7 = firstShortFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction9 = genoperandoperand(CmpCqR, _quickConstant7, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction9)) {
		(_anInstruction9->dependent = locateLiteral(_quickConstant7));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpIs16bitIndexable = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant8 = firstLongFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction10 = genoperandoperand(CmpCqR, _quickConstant8, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction10)) {
		(_anInstruction10->dependent = locateLiteral(_quickConstant8));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpIs32bitIndexable = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant9 = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction11 = genoperandoperand(CmpCqR, _quickConstant9, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction11)) {
		(_anInstruction11->dependent = locateLiteral(_quickConstant9));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpZero: */
	_jumpIs64bitIndexable = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	jmpTarget(_jumpNotIndexable, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	/* begin Jump: */
	_jumpNotIndexable = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpIsArray, genoperandoperand(CmpRR, Arg1Reg, _nSlotsOrElementsReg));
	/* begin JumpBelowOrEqual: */
	_jumpArrayOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin AddCq:R: */
	_quickConstant10 = ((usqInt) BaseHeaderSize ) >> (shiftForWord());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction12 = genoperandoperand(AddCqR, _quickConstant10, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction12)) {
		(_anInstruction12->dependent = locateLiteral(_quickConstant10));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AddCq:R: */
	/* begin MoveXwr:R:R: */
	genoperandoperandoperand(MoveXwrRR, Arg1Reg, ReceiverResultReg, ReceiverResultReg);
	/* end MoveXwr:R:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpIsBytes, gLogicalShiftLeftCqR(shiftForWord(), _nSlotsOrElementsReg));
	gAndCqRR(7, _formatReg, TempReg);
	{
		/* begin SubR:R: */
		genoperandoperand(SubRR, TempReg, _nSlotsOrElementsReg);
		/* end SubR:R: */
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, Arg1Reg, _nSlotsOrElementsReg);
		/* end CmpR:R: */
	}
	/* begin JumpBelowOrEqual: */
	_jumpBytesOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant11 = firstCompiledMethodFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction13 = genoperandoperand(CmpCqR, _quickConstant11, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction13)) {
		(_anInstruction13->dependent = locateLiteral(_quickConstant11));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpIsMethod = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction14 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction14)) {
		(_anInstruction14->dependent = locateLiteral(BaseHeaderSize));
	}
	_methodInBounds = _anInstruction14;
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin MoveXbr:R:R: */
		genoperandoperandoperand(MoveXbrRR, Arg1Reg, ReceiverResultReg, ReceiverResultReg);
		/* end MoveXbr:R:R: */
	}
	if (_signedVersion) {
		/* begin SignExtend8R:R: */
		{
			{
				/* begin LogicalShiftLeftCq:R: */
				_first = genoperandoperand(LogicalShiftLeftCqR, (BytesPerWord * 8) - 8, ReceiverResultReg);
				/* end LogicalShiftLeftCq:R: */
			}
			/* begin ArithmeticShiftRightCq:R: */
			genoperandoperand(ArithmeticShiftRightCqR, (BytesPerWord * 8) - 8, ReceiverResultReg);
			/* end ArithmeticShiftRightCq:R: */
			goto l11;
		}
		l11:
		;
		/* end SignExtend8R:R: */
	}
	/* begin Label */
	_convertToIntAndReturn = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
	/* end Label */
	genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpIs16bitIndexable, gLogicalShiftLeftCqR((shiftForWord()) - 1, _nSlotsOrElementsReg));
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction15 = genoperandoperand(AndCqR, 3, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction15)) {
		(_anInstruction15->dependent = locateLiteral(3));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin SubR:R: */
		genoperandoperand(SubRR, _formatReg, _nSlotsOrElementsReg);
		/* end SubR:R: */
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, Arg1Reg, _nSlotsOrElementsReg);
		/* end CmpR:R: */
	}
	/* begin JumpBelowOrEqual: */
	_jumpShortsOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg1Reg, ReceiverResultReg);
	/* end AddR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg1Reg, ReceiverResultReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction16 = genoperandoperandoperand(MoveM16rR, BaseHeaderSize, ReceiverResultReg, ReceiverResultReg);
	if (usesOutOfLineLiteral(_anInstruction16)) {
		(_anInstruction16->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	if (_signedVersion) {
		/* begin SignExtend16R:R: */
		{
			{
				/* begin LogicalShiftLeftCq:R: */
				_first2 = genoperandoperand(LogicalShiftLeftCqR, (BytesPerWord * 8) - 16, ReceiverResultReg);
				/* end LogicalShiftLeftCq:R: */
			}
			/* begin ArithmeticShiftRightCq:R: */
			genoperandoperand(ArithmeticShiftRightCqR, (BytesPerWord * 8) - 16, ReceiverResultReg);
			/* end ArithmeticShiftRightCq:R: */
			goto l18;
		}
		l18:
		;
		/* end SignExtend16R:R: */
	}
	/* begin Jump: */
	genoperand(Jump, ((sqInt) _convertToIntAndReturn ));
	/* end Jump: */
	jmpTarget(_jumpIs32bitIndexable, gLogicalShiftLeftCqR((shiftForWord()) - 2, _nSlotsOrElementsReg));
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction17 = genoperandoperand(AndCqR, 1, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction17)) {
		(_anInstruction17->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin SubR:R: */
		genoperandoperand(SubRR, _formatReg, _nSlotsOrElementsReg);
		/* end SubR:R: */
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, Arg1Reg, _nSlotsOrElementsReg);
		/* end CmpR:R: */
	}
	/* begin JumpBelowOrEqual: */
	_jumpWordsOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin AddCq:R: */
	_quickConstant12 = ((usqInt) BaseHeaderSize ) >> ((shiftForWord()) - 1);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction18 = genoperandoperand(AddCqR, _quickConstant12, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction18)) {
		(_anInstruction18->dependent = locateLiteral(_quickConstant12));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AddCq:R: */
	/* begin MoveX32r:R:R: */
	genoperandoperandoperand(MoveX32rRR, Arg1Reg, ReceiverResultReg, TempReg);
	/* end MoveX32r:R:R: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, TempReg, ReceiverResultReg);
	/* end MoveR:R: */
	if (_signedVersion) {
		/* begin SignExtend32R:R: */
		{
			{
				/* begin LogicalShiftLeftCq:R: */
				_first3 = genoperandoperand(LogicalShiftLeftCqR, 32, ReceiverResultReg);
				/* end LogicalShiftLeftCq:R: */
			}
			/* begin ArithmeticShiftRightCq:R: */
			genoperandoperand(ArithmeticShiftRightCqR, 32, ReceiverResultReg);
			/* end ArithmeticShiftRightCq:R: */
			goto l25;
		}
		l25:
		;
		/* end SignExtend32R:R: */
	}
	/* begin Jump: */
	genoperand(Jump, ((sqInt) _convertToIntAndReturn ));
	/* end Jump: */
	jmpTarget(_jumpHasFixedFields, gAndCqR(classIndexMask(), TempReg));
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, TempReg, _formatReg);
	/* end MoveR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction19 = genoperandoperand(CmpCqR, ClassMethodContextCompactIndex, TempReg);
	if (usesOutOfLineLiteral(_anInstruction19)) {
		(_anInstruction19->dependent = locateLiteral(ClassMethodContextCompactIndex));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpZero: */
	_jumpIsContext = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	genGetClassObjectOfClassIndexintoscratchReg(_formatReg, Extra0Reg, TempReg);
	genLoadSlotsourceRegdestReg(InstanceSpecificationIndex, Extra0Reg, _formatReg);
	genConvertSmallIntegerToIntegerInReg(_formatReg);
	{
		/* begin AndCq:R: */
		_quickConstant3 = fixedFieldsOfClassFormatMask();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(AndCqR, _quickConstant3, _formatReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_quickConstant3));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end AndCq:R: */
		/* begin SubR:R: */
		genoperandoperand(SubRR, _formatReg, _nSlotsOrElementsReg);
		/* end SubR:R: */
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, Arg1Reg, _nSlotsOrElementsReg);
		/* end CmpR:R: */
	}
	/* begin JumpBelowOrEqual: */
	_jumpFixedFieldsOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, _formatReg, Arg1Reg);
	/* end AddR:R: */
	/* begin AddCq:R: */
	_quickConstant13 = ((usqInt) BaseHeaderSize ) >> (shiftForWord());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction20 = genoperandoperand(AddCqR, _quickConstant13, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction20)) {
		(_anInstruction20->dependent = locateLiteral(_quickConstant13));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AddCq:R: */
	/* begin MoveXwr:R:R: */
	genoperandoperandoperand(MoveXwrRR, Arg1Reg, ReceiverResultReg, ReceiverResultReg);
	/* end MoveXwr:R:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpIs64bitIndexable, genoperandoperand(CmpRR, Arg1Reg, _nSlotsOrElementsReg));
	/* begin JumpBelowOrEqual: */
	_jumpLongsOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin AddCq:R: */
	_quickConstant14 = ((usqInt) BaseHeaderSize ) >> (shiftForWord());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction21 = genoperandoperand(AddCqR, _quickConstant14, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction21)) {
		(_anInstruction21->dependent = locateLiteral(_quickConstant14));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AddCq:R: */
	/* begin MoveXwr:R:R: */
	genoperandoperandoperand(MoveXwrRR, Arg1Reg, ReceiverResultReg, ClassReg);
	/* end MoveXwr:R:R: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, ClassReg, TempReg);
	/* end MoveR:R: */
	if (_signedVersion) {
		/* begin ArithmeticShiftRightCq:R: */
		_quickConstant = numSmallIntegerBits();
		genoperandoperand(ArithmeticShiftRightCqR, _quickConstant, TempReg);
		/* end ArithmeticShiftRightCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(AndCqR, 15, TempReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(15));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperand(CmpCqR, 1, TempReg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(1));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin JumpAbove: */
		_jumpNotSmallInteger = genConditionalBranchoperand(JumpAbove, ((sqInt) 0 ));
		/* end JumpAbove: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, ClassReg, ReceiverResultReg);
		/* end MoveR:R: */
		/* begin Jump: */
		genoperand(Jump, ((sqInt) _convertToIntAndReturn ));
		/* end Jump: */
		jmpTarget(_jumpNotSmallInteger, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
		_jumpFailAlloc = genAlloc64BitSignedIntegerValueintoscratchRegscratchReg(ClassReg, SendNumArgsReg, Extra0Reg, TempReg);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
		/* end MoveR:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
	} else {
		/* begin LogicalShiftRightCq:R: */
		_quickConstant2 = (numSmallIntegerBits()) - 1;
		genoperandoperand(LogicalShiftRightCqR, _quickConstant2, TempReg);
		/* end LogicalShiftRightCq:R: */
		if (!(setsConditionCodesFor(lastOpcode(), JumpZero))) {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction4 = genoperandoperand(CmpCqR, 0, TempReg);
			if (usesOutOfLineLiteral(_anInstruction4)) {
				(_anInstruction4->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		/* begin JumpNonZero: */
		_jumpNotSmallInteger = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, ClassReg, ReceiverResultReg);
		/* end MoveR:R: */
		/* begin Jump: */
		genoperand(Jump, ((sqInt) _convertToIntAndReturn ));
		/* end Jump: */
		jmpTarget(_jumpNotSmallInteger, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
		_jumpFailAlloc = genAlloc64BitPositiveIntegerValueintoscratchRegscratchReg(ClassReg, SendNumArgsReg, Extra0Reg, TempReg);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
		/* end MoveR:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
	}
	jmpTarget(_jumpIsMethod, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	getLiteralCountOfplusOneinBytesintoscratch(ReceiverResultReg, 1, 1, _nSlotsOrElementsReg, TempReg);
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, Arg1Reg, _nSlotsOrElementsReg);
	/* end CmpR:R: */
	/* begin JumpBelow: */
	genConditionalBranchoperand(JumpBelow, ((sqInt) _methodInBounds ));
	/* end JumpBelow: */
	jmpTarget(_jumpFailAlloc, jmpTarget(_jumpLongsOutOfBounds, jmpTarget(_jumpFixedFieldsOutOfBounds, jmpTarget(_jumpArrayOutOfBounds, jmpTarget(_jumpBytesOutOfBounds, jmpTarget(_jumpShortsOutOfBounds, jmpTarget(_jumpWordsOutOfBounds, jmpTarget(_jumpNotIndexable, jmpTarget(_jumpIsContext, jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))))))))));
	return 0;
}
/*	Arguably we should fail for immediates, but so far no one has complained, 
	so...  */
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveIdentityHash */
static sqInt
genPrimitiveIdentityHash(void)
{
	AbstractInstruction *_abstractInstruction;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction * _inst;
	AbstractInstruction *_jumpImm;
	AbstractInstruction *_jumpNotCharacter;
	AbstractInstruction *_jumpNotSet;
	sqInt _quickConstant;
	AbstractInstruction * _returnInstruction;

	_jumpImm = genJumpImmediate(ReceiverResultReg);
	genGetHashFieldNonImmOfasSmallIntegerInto(ReceiverResultReg, TempReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(CmpCqR, ConstZero, TempReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(ConstZero));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpZero: */
	_jumpNotSet = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, TempReg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		_returnInstruction = genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			_returnInstruction = genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpImm, gAndCqRR(tagMask(), ReceiverResultReg, TempReg));
	/* begin CmpCq:R: */
	_quickConstant = characterTag();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNotCharacter = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	genConvertCharacterToSmallIntegerInReg(ReceiverResultReg);
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		_returnInstruction = genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			_returnInstruction = genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpNotCharacter, gCmpCqR(smallFloatTag(), TempReg));
	/* begin JumpNonZero: */
	genConditionalBranchoperand(JumpNonZero, ((sqInt) _returnInstruction ));
	/* end JumpNonZero: */
	genConvertSmallFloatToSmallFloatHashAsIntegerInRegscratch(ReceiverResultReg, TempReg);
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpNotSet, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	if (!(primitiveIndex == 75)) {
		return 0;
	}
	/* begin saveAndRestoreLinkRegAround: */
	_inst = genoperand(PushR, LinkReg);
	{
		/* begin CallRT: */
		/* begin annotateCall: */
		_abstractInstruction = genoperand(Call, ceNewHashTrampoline);
		(_abstractInstruction->annotation = IsRelativeCall);
		/* end annotateCall: */
		/* end CallRT: */
	}
	genoperand(PopR, LinkReg);
	/* end saveAndRestoreLinkRegAround: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	return UnfailingPrimitive;
}
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveImmediateAsInteger */
static sqInt
genPrimitiveImmediateAsInteger(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_jumpNotCharacter;
	sqInt _quickConstant;
	AbstractInstruction * _returnInstruction;

	{
		gAndCqRR(tagMask(), ReceiverResultReg, TempReg);
		/* begin CmpCq:R: */
		_quickConstant = characterTag();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, _quickConstant, TempReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpNonZero: */
		_jumpNotCharacter = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
	}
	genConvertCharacterToSmallIntegerInReg(ReceiverResultReg);
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		_returnInstruction = genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			_returnInstruction = genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpNotCharacter, gCmpCqR(smallFloatTag(), TempReg));
	/* begin JumpNonZero: */
	genConditionalBranchoperand(JumpNonZero, ((sqInt) _returnInstruction ));
	/* end JumpNonZero: */
	genConvertSmallFloatToSmallFloatHashAsIntegerInRegscratch(ReceiverResultReg, TempReg);
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	return UnfailingPrimitive;
}
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveLoadInt32FromBytes */
static sqInt
genPrimitiveLoadInt32FromBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction * _first;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveLoad:fromBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 4, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(SubCqR, 4 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(4 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg1Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, Arg1Reg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin MoveM32:r:R: */
		genMoveM32rR(backEnd, 0, Arg1Reg, ReceiverResultReg);
		/* end MoveM32:r:R: */
		/* begin SignExtend32R:R: */
		{
			{
				/* begin LogicalShiftLeftCq:R: */
				_first = genoperandoperand(LogicalShiftLeftCqR, 32, ReceiverResultReg);
				/* end LogicalShiftLeftCq:R: */
			}
			/* begin ArithmeticShiftRightCq:R: */
			genoperandoperand(ArithmeticShiftRightCqR, 32, ReceiverResultReg);
			/* end ArithmeticShiftRightCq:R: */
			goto l21;
		}
		l21:
		;
		/* end SignExtend32R:R: */
		genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	return CompletePrimitive;
	/* end genPrimitiveLoad:fromBytesWith:needsToTrap: */
}
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveLoadInt32FromExternalAddress */
static sqInt
genPrimitiveLoadInt32FromExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction * _first;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;

	/* begin genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, TempReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, Arg1Reg);
	/* end AddR:R: */
	{
		/* begin MoveM32:r:R: */
		genMoveM32rR(backEnd, 0, Arg1Reg, ReceiverResultReg);
		/* end MoveM32:r:R: */
		/* begin SignExtend32R:R: */
		{
			{
				/* begin LogicalShiftLeftCq:R: */
				_first = genoperandoperand(LogicalShiftLeftCqR, 32, ReceiverResultReg);
				/* end LogicalShiftLeftCq:R: */
			}
			/* begin ArithmeticShiftRightCq:R: */
			genoperandoperand(ArithmeticShiftRightCqR, 32, ReceiverResultReg);
			/* end ArithmeticShiftRightCq:R: */
			goto l16;
		}
		l16:
		;
		/* end SignExtend32R:R: */
		genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpNonExternalAddress, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveLoadInt64FromBytes */
static sqInt
genPrimitiveLoadInt64FromBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpFailAlloc;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveLoad:fromBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 8, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(8));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 8 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(8 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg1Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, Arg1Reg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		{
			assert(BytesPerWord == 8);
			/* begin gen:quickConstant:operand:operand: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperandoperand(MoveMwrR, 0, Arg1Reg, ClassReg);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
			/* end gen:quickConstant:operand:operand: */
		}
		_jumpFailAlloc = genIntegerTo64BitSignedIntegerValueintoscratchRegscratchReg(ClassReg, SendNumArgsReg, Extra0Reg, TempReg);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
		/* end MoveR:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		jmpTarget(_jumpFailAlloc, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	return 0;
	/* end genPrimitiveLoad:fromBytesWith:needsToTrap: */
}
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveLoadInt64FromExternalAddress */
static sqInt
genPrimitiveLoadInt64FromExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpFailAlloc;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;

	/* begin genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, TempReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, Arg1Reg);
	/* end AddR:R: */
	{
		{
			assert(BytesPerWord == 8);
			/* begin gen:quickConstant:operand:operand: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperandoperand(MoveMwrR, 0, Arg1Reg, ClassReg);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
			/* end gen:quickConstant:operand:operand: */
		}
		_jumpFailAlloc = genIntegerTo64BitSignedIntegerValueintoscratchRegscratchReg(ClassReg, SendNumArgsReg, Extra0Reg, TempReg);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
		/* end MoveR:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		jmpTarget(_jumpFailAlloc, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpNonExternalAddress, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return 0;
	/* end genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveLoadUInt32FromBytes */
static sqInt
genPrimitiveLoadUInt32FromBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction * _first;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveLoad:fromBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 4, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(SubCqR, 4 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(4 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg1Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, Arg1Reg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin MoveM32:r:R: */
		genMoveM32rR(backEnd, 0, Arg1Reg, ReceiverResultReg);
		/* end MoveM32:r:R: */
		/* begin ZeroExtend32R:R: */
		{
			{
				/* begin LogicalShiftLeftCq:R: */
				_first = genoperandoperand(LogicalShiftLeftCqR, 32, ReceiverResultReg);
				/* end LogicalShiftLeftCq:R: */
			}
			/* begin LogicalShiftRightCq:R: */
			genoperandoperand(LogicalShiftRightCqR, 32, ReceiverResultReg);
			/* end LogicalShiftRightCq:R: */
			goto l21;
		}
		l21:
		;
		/* end ZeroExtend32R:R: */
		genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	return CompletePrimitive;
	/* end genPrimitiveLoad:fromBytesWith:needsToTrap: */
}
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveLoadUInt32FromExternalAddress */
static sqInt
genPrimitiveLoadUInt32FromExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction * _first;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;

	/* begin genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, TempReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, Arg1Reg);
	/* end AddR:R: */
	{
		/* begin MoveM32:r:R: */
		genMoveM32rR(backEnd, 0, Arg1Reg, ReceiverResultReg);
		/* end MoveM32:r:R: */
		/* begin ZeroExtend32R:R: */
		{
			{
				/* begin LogicalShiftLeftCq:R: */
				_first = genoperandoperand(LogicalShiftLeftCqR, 32, ReceiverResultReg);
				/* end LogicalShiftLeftCq:R: */
			}
			/* begin LogicalShiftRightCq:R: */
			genoperandoperand(LogicalShiftRightCqR, 32, ReceiverResultReg);
			/* end LogicalShiftRightCq:R: */
			goto l16;
		}
		l16:
		;
		/* end ZeroExtend32R:R: */
		genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpNonExternalAddress, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveLoadUInt64FromBytes */
static sqInt
genPrimitiveLoadUInt64FromBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpFailAlloc;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveLoad:fromBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 8, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(8));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 8 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(8 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg1Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, Arg1Reg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		{
			assert(BytesPerWord == 8);
			/* begin gen:quickConstant:operand:operand: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperandoperand(MoveMwrR, 0, Arg1Reg, ClassReg);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
			/* end gen:quickConstant:operand:operand: */
		}
		_jumpFailAlloc = genIntegerTo64BitPositiveIntegerValueintoscratchRegscratchReg(ClassReg, SendNumArgsReg, Extra0Reg, TempReg);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
		/* end MoveR:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		jmpTarget(_jumpFailAlloc, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	return 0;
	/* end genPrimitiveLoad:fromBytesWith:needsToTrap: */
}
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveLoadUInt64FromExternalAddress */
static sqInt
genPrimitiveLoadUInt64FromExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpFailAlloc;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;

	/* begin genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, TempReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, Arg1Reg);
	/* end AddR:R: */
	{
		{
			assert(BytesPerWord == 8);
			/* begin gen:quickConstant:operand:operand: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperandoperand(MoveMwrR, 0, Arg1Reg, ClassReg);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
			/* end gen:quickConstant:operand:operand: */
		}
		_jumpFailAlloc = genIntegerTo64BitPositiveIntegerValueintoscratchRegscratchReg(ClassReg, SendNumArgsReg, Extra0Reg, TempReg);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
		/* end MoveR:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		jmpTarget(_jumpFailAlloc, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpNonExternalAddress, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return 0;
	/* end genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
}
/*	Implement primitiveNew for convenient cases: 
	- the receiver has a hash 
	- the receiver is fixed size (excluding ephemerons to save instructions & 
	miniscule time) 
	- single word header/num slots < numSlotsMask 
	- the result fits in eden (actually below scavengeThreshold) */
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveNew */
static sqInt
genPrimitiveNew(void)
{
	sqInt _address;
	sqInt _address2;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction10;
	AbstractInstruction *_anInstruction11;
	AbstractInstruction *_anInstruction12;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction *_anInstruction7;
	AbstractInstruction *_anInstruction8;
	AbstractInstruction *_anInstruction9;
	sqInt _byteSizeReg;
	AbstractInstruction * _fillLoop;
	AbstractInstruction * _fillLoop2;
	sqInt _fillReg;
	sqInt _headerReg;
	sqInt _instSpecReg;
	AbstractInstruction *_jumpHasSlots;
	AbstractInstruction *_jumpNoSpace;
	AbstractInstruction *_jumpTooBig;
	AbstractInstruction *_jumpUnhashed;
	AbstractInstruction *_jumpVariableOrEphemeron;
	sqInt _quickConstant;
	sqInt _quickConstant2;
	sqInt _quickConstant3;
	sqInt _quickConstant4;
	sqInt _quickConstant5;
	sqInt _quickConstant6;
	sqInt _quickConstant7;
	sqInt _quickConstant8;
	sqInt _quickConstant9;
	AbstractInstruction *_skip;

	if (methodOrBlockNumArgs != 0) {
		return UnimplementedPrimitive;
	}
	_headerReg = (_fillReg = SendNumArgsReg);
	_instSpecReg = (_byteSizeReg = ClassReg);
	/* begin MoveAw:R: */
	_address = freeStartAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, Arg1Reg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	genGetHashFieldNonImmOfinto(ReceiverResultReg, _headerReg);
	/* begin JumpZero: */
	_jumpUnhashed = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	genLoadSlotsourceRegdestReg(InstanceSpecificationIndex, ReceiverResultReg, TempReg);
	genConvertSmallIntegerToIntegerInReg(TempReg);
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, TempReg, _instSpecReg);
	/* end MoveR:R: */
	/* begin LogicalShiftRightCq:R: */
	_quickConstant = fixedFieldsFieldWidth();
	genoperandoperand(LogicalShiftRightCqR, _quickConstant, TempReg);
	/* end LogicalShiftRightCq:R: */
	/* begin AndCq:R: */
	_quickConstant4 = formatMask();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(AndCqR, _quickConstant4, TempReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_quickConstant4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AndCq:R: */
	/* begin AndCq:R: */
	_quickConstant5 = fixedFieldsOfClassFormatMask();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(AndCqR, _quickConstant5, _instSpecReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant5));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AndCq:R: */
	/* begin CmpCq:R: */
	_quickConstant6 = nonIndexablePointerFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant6, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant6));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAbove: */
	_jumpVariableOrEphemeron = genConditionalBranchoperand(JumpAbove, ((sqInt) 0 ));
	/* end JumpAbove: */
	/* begin CmpCq:R: */
	_quickConstant7 = numSlotsMask();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(CmpCqR, _quickConstant7, _instSpecReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(_quickConstant7));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpTooBig = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin LogicalShiftLeftCq:R: */
	_quickConstant2 = formatShift();
	genoperandoperand(LogicalShiftLeftCqR, _quickConstant2, TempReg);
	/* end LogicalShiftLeftCq:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, _headerReg);
	/* end AddR:R: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, _instSpecReg, TempReg);
	/* end MoveR:R: */
	/* begin LogicalShiftLeftCq:R: */
	_quickConstant3 = numSlotsFullShift();
	genoperandoperand(LogicalShiftLeftCqR, _quickConstant3, TempReg);
	/* end LogicalShiftLeftCq:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, _headerReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction5 = genoperandoperand(CmpCqR, 0, _byteSizeReg);
	if (usesOutOfLineLiteral(_anInstruction5)) {
		(_anInstruction5->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpNonZero: */
	_jumpHasSlots = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction6 = genoperandoperand(MoveCqR, BaseHeaderSize * 2, _byteSizeReg);
	if (usesOutOfLineLiteral(_anInstruction6)) {
		(_anInstruction6->dependent = locateLiteral(BaseHeaderSize * 2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin Jump: */
	_skip = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpHasSlots, checkQuickConstantforInstruction(BaseHeaderSize / BytesPerWord, genoperandoperand(AddCqR, BaseHeaderSize / BytesPerWord, _byteSizeReg)));
	/* begin LogicalShiftLeftCq:R: */
	genoperandoperand(LogicalShiftLeftCqR, shiftForWord(), _byteSizeReg);
	/* end LogicalShiftLeftCq:R: */
	jmpTarget(_skip, genoperandoperand(AddRR, Arg1Reg, _byteSizeReg));
	/* begin CmpCq:R: */
	_quickConstant8 = getScavengeThreshold();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction7 = genoperandoperand(CmpCqR, _quickConstant8, _byteSizeReg);
	if (usesOutOfLineLiteral(_anInstruction7)) {
		(_anInstruction7->dependent = locateLiteral(_quickConstant8));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpNoSpace = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:Aw: */
	_address2 = freeStartAddress();
	/* begin gen:operand:literal: */
	checkLiteralforInstruction(_address2, genoperandoperand(MoveRAw, _byteSizeReg, _address2));
	/* end gen:operand:literal: */
	/* end MoveR:Aw: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
	/* end MoveR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction8 = genoperandoperandoperand(MoveRMwr, _headerReg, 0, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction8)) {
		(_anInstruction8->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction9 = genoperandoperandoperand(LoadEffectiveAddressMwrR, BaseHeaderSize, ReceiverResultReg, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction9)) {
		(_anInstruction9->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin MoveCq:R: */
	_quickConstant9 = nilObject();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction10 = genoperandoperand(MoveCqR, _quickConstant9, _fillReg);
	if (usesOutOfLineLiteral(_anInstruction10)) {
		(_anInstruction10->dependent = locateLiteral(_quickConstant9));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end MoveCq:R: */
	/* begin fillFrom:until:with:usingVr: */
	
#  if FEATURE_JIT_SIMD
	{
		gDupSRVr(64, _fillReg, VReg1);
		_fillLoop = gSt1SVrRMw(64, VReg1, Arg1Reg, 16);
		genoperandoperand(CmpRR, Arg1Reg, _byteSizeReg);
		genConditionalBranchoperand(JumpAbove, ((sqInt) _fillLoop ));
	}
#  else /* FEATURE_JIT_SIMD */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction11 = genoperandoperandoperand(MoveRMwr, _fillReg, 0, Arg1Reg);
		if (usesOutOfLineLiteral(_anInstruction11)) {
			(_anInstruction11->dependent = locateLiteral(0));
		}
		_fillLoop2 = _anInstruction11;
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction12 = genoperandoperand(AddCqR, 8, Arg1Reg);
		if (usesOutOfLineLiteral(_anInstruction12)) {
			(_anInstruction12->dependent = locateLiteral(8));
		}
		/* end checkQuickConstant:forInstruction: */
		genoperandoperand(CmpRR, Arg1Reg, _byteSizeReg);
		genConditionalBranchoperand(JumpAbove, ((sqInt) _fillLoop2 ));
	}
#  endif /* FEATURE_JIT_SIMD */
	/* end fillFrom:until:with:usingVr: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpUnhashed, jmpTarget(_jumpVariableOrEphemeron, jmpTarget(_jumpTooBig, jmpTarget(_jumpNoSpace, genoperandoperand(Label, (labelCounter += 1), bytecodePC)))));
	return 0;
}
/*	Implement primitiveNewWithArg for convenient cases: 
	- the receiver has a hash 
	- the receiver is variable and not compiled method 
	- single word header/num slots < numSlotsMask 
	- the result fits in eden 
	See superclass method for dynamic frequencies of formats. 
	For the moment we implement only arrayFormat, firstByteFormat & 
	firstLongFormat  */
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveNewWithArg */
static sqInt
genPrimitiveNewWithArg(void)
{
	sqInt _address;
	sqInt _address2;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction10;
	AbstractInstruction *_anInstruction11;
	AbstractInstruction *_anInstruction12;
	AbstractInstruction *_anInstruction13;
	AbstractInstruction *_anInstruction14;
	AbstractInstruction *_anInstruction15;
	AbstractInstruction *_anInstruction16;
	AbstractInstruction *_anInstruction17;
	AbstractInstruction *_anInstruction18;
	AbstractInstruction *_anInstruction19;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction20;
	AbstractInstruction *_anInstruction21;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction *_anInstruction7;
	AbstractInstruction *_anInstruction8;
	AbstractInstruction *_anInstruction9;
	sqInt _byteSizeReg;
	AbstractInstruction * _fillLoop;
	AbstractInstruction * _fillLoop2;
	sqInt _fillReg;
	sqInt _headerReg;
	sqInt _instSpecReg;
	AbstractInstruction *_jumpArrayFormat;
	AbstractInstruction *_jumpArrayTooBig;
	AbstractInstruction *_jumpByteFormat;
	AbstractInstruction *_jumpBytePrepDone;
	AbstractInstruction *_jumpByteTooBig;
	AbstractInstruction *_jumpFailCuzFixed;
	AbstractInstruction *_jumpHasSlots;
	AbstractInstruction *_jumpLongPrepDone;
	AbstractInstruction *_jumpLongTooBig;
	AbstractInstruction *_jumpNElementsNonInt;
	AbstractInstruction *_jumpNoSpace;
	AbstractInstruction *_jumpUnhashed;
	sqInt _literal;
	sqInt _maxSlots;
	sqInt _quickConstant;
	sqInt _quickConstant10;
	sqInt _quickConstant11;
	sqInt _quickConstant2;
	sqInt _quickConstant3;
	sqInt _quickConstant4;
	sqInt _quickConstant5;
	sqInt _quickConstant6;
	sqInt _quickConstant7;
	sqInt _quickConstant8;
	sqInt _quickConstant9;
	AbstractInstruction *_skip;

	if (methodOrBlockNumArgs != 1) {
		return UnimplementedPrimitive;
	}
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_headerReg = SendNumArgsReg;
	_fillReg = Extra0Reg;
	assert(_fillReg > 0);
	_instSpecReg = (_byteSizeReg = ClassReg);
	_maxSlots = (numSlotsMask()) - 1;
	/* begin MoveAw:R: */
	_address = freeStartAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, Arg1Reg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	genGetHashFieldNonImmOfinto(ReceiverResultReg, _headerReg);
	/* begin JumpZero: */
	_jumpUnhashed = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpNElementsNonInt = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genLoadSlotsourceRegdestReg(InstanceSpecificationIndex, ReceiverResultReg, _instSpecReg);
	/* begin LogicalShiftRightCq:R: */
	_quickConstant = (fixedFieldsFieldWidth()) + (numSmallIntegerTagBits());
	genoperandoperand(LogicalShiftRightCqR, _quickConstant, _instSpecReg);
	/* end LogicalShiftRightCq:R: */
	/* begin AndCq:R: */
	_quickConstant6 = formatMask();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(AndCqR, _quickConstant6, _instSpecReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_quickConstant6));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AndCq:R: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, _instSpecReg, TempReg);
	/* end MoveR:R: */
	/* begin LogicalShiftLeftCq:R: */
	_quickConstant2 = formatShift();
	genoperandoperand(LogicalShiftLeftCqR, _quickConstant2, TempReg);
	/* end LogicalShiftLeftCq:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, _headerReg);
	/* end AddR:R: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, _fillReg);
	/* end MoveR:R: */
	genConvertSmallIntegerToIntegerInReg(_fillReg);
	/* begin CmpCq:R: */
	_quickConstant7 = arrayFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant7, _instSpecReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant7));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpZero: */
	_jumpArrayFormat = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* begin CmpCq:R: */
	_quickConstant8 = firstByteFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant8, _instSpecReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant8));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpZero: */
	_jumpByteFormat = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* begin CmpCq:R: */
	_quickConstant9 = firstLongFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(CmpCqR, _quickConstant9, _instSpecReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(_quickConstant9));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpFailCuzFixed = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin checkQuickConstant:forInstruction: */
	_literal = ((((usqInt) (_maxSlots * 2) ) << 3) | 1);
	_anInstruction5 = genoperandoperand(CmpCqR, ((((usqInt) (_maxSlots * 2) ) << 3) | 1), Arg0Reg);
	if (usesOutOfLineLiteral(_anInstruction5)) {
		(_anInstruction5->dependent = locateLiteral(_literal));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpAbove: */
	_jumpLongTooBig = genConditionalBranchoperand(JumpAbove, ((sqInt) 0 ));
	/* end JumpAbove: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, _fillReg, _instSpecReg);
	/* end MoveR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction6 = genoperandoperand(MoveCqR, BytesPerWord / 4, TempReg);
	if (usesOutOfLineLiteral(_anInstruction6)) {
		(_anInstruction6->dependent = locateLiteral(BytesPerWord / 4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, _instSpecReg, TempReg);
	/* end SubR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction7 = genoperandoperand(AndCqR, (BytesPerWord / 4) - 1, TempReg);
	if (usesOutOfLineLiteral(_anInstruction7)) {
		(_anInstruction7->dependent = locateLiteral((BytesPerWord / 4) - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin LogicalShiftLeftCq:R: */
	_quickConstant3 = formatShift();
	genoperandoperand(LogicalShiftLeftCqR, _quickConstant3, TempReg);
	/* end LogicalShiftLeftCq:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, _headerReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction8 = genoperandoperand(AddCqR, (BytesPerWord / 4) - 1, _instSpecReg);
	if (usesOutOfLineLiteral(_anInstruction8)) {
		(_anInstruction8->dependent = locateLiteral((BytesPerWord / 4) - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin LogicalShiftRightCq:R: */
	genoperandoperand(LogicalShiftRightCqR, (shiftForWord()) - 2, _instSpecReg);
	/* end LogicalShiftRightCq:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction9 = genoperandoperand(MoveCqR, 0, _fillReg);
	if (usesOutOfLineLiteral(_anInstruction9)) {
		(_anInstruction9->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin Jump: */
	_jumpLongPrepDone = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpByteFormat, checkQuickConstantforInstruction(((((usqInt) (_maxSlots * BytesPerWord) ) << 3) | 1), genoperandoperand(CmpCqR, ((((usqInt) (_maxSlots * BytesPerWord) ) << 3) | 1), Arg0Reg)));
	/* begin JumpAbove: */
	_jumpByteTooBig = genConditionalBranchoperand(JumpAbove, ((sqInt) 0 ));
	/* end JumpAbove: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, _fillReg, _instSpecReg);
	/* end MoveR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction10 = genoperandoperand(MoveCqR, BytesPerWord, TempReg);
	if (usesOutOfLineLiteral(_anInstruction10)) {
		(_anInstruction10->dependent = locateLiteral(BytesPerWord));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, _instSpecReg, TempReg);
	/* end SubR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction11 = genoperandoperand(AndCqR, BytesPerWord - 1, TempReg);
	if (usesOutOfLineLiteral(_anInstruction11)) {
		(_anInstruction11->dependent = locateLiteral(BytesPerWord - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin LogicalShiftLeftCq:R: */
	_quickConstant4 = formatShift();
	genoperandoperand(LogicalShiftLeftCqR, _quickConstant4, TempReg);
	/* end LogicalShiftLeftCq:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, _headerReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction12 = genoperandoperand(AddCqR, BytesPerWord - 1, _instSpecReg);
	if (usesOutOfLineLiteral(_anInstruction12)) {
		(_anInstruction12->dependent = locateLiteral(BytesPerWord - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin LogicalShiftRightCq:R: */
	genoperandoperand(LogicalShiftRightCqR, shiftForWord(), _instSpecReg);
	/* end LogicalShiftRightCq:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction13 = genoperandoperand(MoveCqR, 0, _fillReg);
	if (usesOutOfLineLiteral(_anInstruction13)) {
		(_anInstruction13->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin Jump: */
	_jumpBytePrepDone = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpArrayFormat, checkQuickConstantforInstruction(((((usqInt) _maxSlots ) << 3) | 1), genoperandoperand(CmpCqR, ((((usqInt) _maxSlots ) << 3) | 1), Arg0Reg)));
	/* begin JumpAbove: */
	_jumpArrayTooBig = genConditionalBranchoperand(JumpAbove, ((sqInt) 0 ));
	/* end JumpAbove: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, _fillReg, _instSpecReg);
	/* end MoveR:R: */
	/* begin MoveCq:R: */
	_quickConstant10 = nilObject();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction14 = genoperandoperand(MoveCqR, _quickConstant10, _fillReg);
	if (usesOutOfLineLiteral(_anInstruction14)) {
		(_anInstruction14->dependent = locateLiteral(_quickConstant10));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end MoveCq:R: */
	jmpTarget(_jumpBytePrepDone, jmpTarget(_jumpLongPrepDone, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, _instSpecReg, TempReg);
	/* end MoveR:R: */
	/* begin LogicalShiftLeftCq:R: */
	_quickConstant5 = numSlotsFullShift();
	genoperandoperand(LogicalShiftLeftCqR, _quickConstant5, TempReg);
	/* end LogicalShiftLeftCq:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, _headerReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction15 = genoperandoperand(CmpCqR, 0, _byteSizeReg);
	if (usesOutOfLineLiteral(_anInstruction15)) {
		(_anInstruction15->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpNonZero: */
	_jumpHasSlots = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction16 = genoperandoperand(MoveCqR, BaseHeaderSize * 2, _byteSizeReg);
	if (usesOutOfLineLiteral(_anInstruction16)) {
		(_anInstruction16->dependent = locateLiteral(BaseHeaderSize * 2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin Jump: */
	_skip = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpHasSlots, checkQuickConstantforInstruction(BaseHeaderSize / BytesPerWord, genoperandoperand(AddCqR, BaseHeaderSize / BytesPerWord, _byteSizeReg)));
	/* begin LogicalShiftLeftCq:R: */
	genoperandoperand(LogicalShiftLeftCqR, shiftForWord(), _byteSizeReg);
	/* end LogicalShiftLeftCq:R: */
	jmpTarget(_skip, genoperandoperand(AddRR, Arg1Reg, _byteSizeReg));
	/* begin CmpCq:R: */
	_quickConstant11 = getScavengeThreshold();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction17 = genoperandoperand(CmpCqR, _quickConstant11, _byteSizeReg);
	if (usesOutOfLineLiteral(_anInstruction17)) {
		(_anInstruction17->dependent = locateLiteral(_quickConstant11));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpNoSpace = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
	/* end MoveR:R: */
	/* begin MoveR:Aw: */
	_address2 = freeStartAddress();
	/* begin gen:operand:literal: */
	checkLiteralforInstruction(_address2, genoperandoperand(MoveRAw, _byteSizeReg, _address2));
	/* end gen:operand:literal: */
	/* end MoveR:Aw: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction18 = genoperandoperandoperand(MoveRMwr, _headerReg, 0, ReceiverResultReg);
	if (usesOutOfLineLiteral(_anInstruction18)) {
		(_anInstruction18->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction19 = genoperandoperandoperand(LoadEffectiveAddressMwrR, BaseHeaderSize, ReceiverResultReg, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction19)) {
		(_anInstruction19->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin fillFrom:until:with:usingVr: */
	
#  if FEATURE_JIT_SIMD
	{
		gDupSRVr(64, _fillReg, VReg1);
		_fillLoop = gSt1SVrRMw(64, VReg1, Arg1Reg, 16);
		genoperandoperand(CmpRR, Arg1Reg, _byteSizeReg);
		genConditionalBranchoperand(JumpAbove, ((sqInt) _fillLoop ));
	}
#  else /* FEATURE_JIT_SIMD */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction20 = genoperandoperandoperand(MoveRMwr, _fillReg, 0, Arg1Reg);
		if (usesOutOfLineLiteral(_anInstruction20)) {
			(_anInstruction20->dependent = locateLiteral(0));
		}
		_fillLoop2 = _anInstruction20;
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction21 = genoperandoperand(AddCqR, 8, Arg1Reg);
		if (usesOutOfLineLiteral(_anInstruction21)) {
			(_anInstruction21->dependent = locateLiteral(8));
		}
		/* end checkQuickConstant:forInstruction: */
		genoperandoperand(CmpRR, Arg1Reg, _byteSizeReg);
		genConditionalBranchoperand(JumpAbove, ((sqInt) _fillLoop2 ));
	}
#  endif /* FEATURE_JIT_SIMD */
	/* end fillFrom:until:with:usingVr: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpNoSpace, jmpTarget(_jumpUnhashed, jmpTarget(_jumpFailCuzFixed, jmpTarget(_jumpArrayTooBig, jmpTarget(_jumpByteTooBig, jmpTarget(_jumpLongTooBig, jmpTarget(_jumpNElementsNonInt, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))))));
	return 0;
}
/*	Implement primitiveShallowCopy/primitiveClone for convenient cases: 
	- the receiver is not a context 
	- the receiver is not a compiled method 
	- the result fits in eden (actually below scavengeThreshold) */
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveShallowCopy */
static sqInt
genPrimitiveShallowCopy(void)
{
	sqInt _address;
	sqInt _address2;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction10;
	AbstractInstruction *_anInstruction11;
	AbstractInstruction *_anInstruction12;
	AbstractInstruction *_anInstruction13;
	AbstractInstruction *_anInstruction14;
	AbstractInstruction *_anInstruction15;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction *_anInstruction7;
	AbstractInstruction *_anInstruction8;
	AbstractInstruction *_anInstruction9;
	AbstractInstruction *_continuance;
	AbstractInstruction *_copyLoop;
	sqInt _formatReg;
	AbstractInstruction * _jumpEmpty;
	AbstractInstruction *_jumpImmediate;
	AbstractInstruction *_jumpIsMethod;
	AbstractInstruction *_jumpNoSpace;
	AbstractInstruction *_jumpTooBig;
	AbstractInstruction *_jumpVariable;
	sqInt _ptrReg;
	sqInt _quickConstant;
	sqInt _quickConstant2;
	sqInt _quickConstant3;
	sqInt _quickConstant4;
	sqInt _quickConstant5;
	sqInt _resultReg;
	sqInt _slotsReg;

	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	_resultReg = Arg0Reg;
	_slotsReg = Arg1Reg;
	/* begin MoveAw:R: */
	_address2 = freeStartAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address2, genoperandoperand(MoveAwR, _address2, _resultReg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_ptrReg = (_formatReg = SendNumArgsReg)), NoReg);
	/* begin CmpCq:R: */
	_quickConstant3 = firstCompiledMethodFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction12 = genoperandoperand(CmpCqR, _quickConstant3, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction12)) {
		(_anInstruction12->dependent = locateLiteral(_quickConstant3));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpIsMethod = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant4 = indexablePointersFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction13 = genoperandoperand(CmpCqR, _quickConstant4, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction13)) {
		(_anInstruction13->dependent = locateLiteral(_quickConstant4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpZero: */
	_jumpVariable = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* begin Label */
	_continuance = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
	/* end Label */
	genGetRawSlotSizeOfNonImminto(ReceiverResultReg, _slotsReg);
	/* begin CmpCq:R: */
	_quickConstant5 = numSlotsMask();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction14 = genoperandoperand(CmpCqR, _quickConstant5, _slotsReg);
	if (usesOutOfLineLiteral(_anInstruction14)) {
		(_anInstruction14->dependent = locateLiteral(_quickConstant5));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpZero: */
	_jumpTooBig = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction15 = genoperandoperand(CmpCqR, 0, _slotsReg);
	if (usesOutOfLineLiteral(_anInstruction15)) {
		(_anInstruction15->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpZero: */
	_jumpEmpty = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(AddCqR, BaseHeaderSize / BytesPerWord, _slotsReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(BaseHeaderSize / BytesPerWord));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin LogicalShiftLeftCq:R: */
		genoperandoperand(LogicalShiftLeftCqR, shiftForWord(), _slotsReg);
		/* end LogicalShiftLeftCq:R: */
		/* begin AddR:R: */
		genoperandoperand(AddRR, _resultReg, _slotsReg);
		/* end AddR:R: */
		/* begin CmpCq:R: */
		_quickConstant = getScavengeThreshold();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _slotsReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
	}
	/* begin JumpAboveOrEqual: */
	_jumpNoSpace = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, _resultReg, _ptrReg);
		/* end MoveR:R: */
		/* begin MoveR:Aw: */
		_address = freeStartAddress();
		/* begin gen:operand:literal: */
		checkLiteralforInstruction(_address, genoperandoperand(MoveRAw, _slotsReg, _address));
		/* end gen:operand:literal: */
		/* end MoveR:Aw: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperand(SubCqR, BytesPerWord * 2, _slotsReg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(BytesPerWord * 2));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction4 = genoperandoperandoperand(MoveMwrR, 0, ReceiverResultReg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction4)) {
			(_anInstruction4->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin AndCq:R: */
		_quickConstant2 = headerForSlotsformatclassIndex(numSlotsMask(), formatMask(), classIndexMask());
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(AndCqR, _quickConstant2, TempReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(_quickConstant2));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end AndCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction6 = genoperandoperandoperand(MoveRMwr, TempReg, 0, _resultReg);
		if (usesOutOfLineLiteral(_anInstruction6)) {
			(_anInstruction6->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin Label */
	_copyLoop = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
	/* end Label */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction7 = genoperandoperand(AddCqR, BytesPerWord, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction7)) {
			(_anInstruction7->dependent = locateLiteral(BytesPerWord));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction8 = genoperandoperand(AddCqR, BytesPerWord, _ptrReg);
		if (usesOutOfLineLiteral(_anInstruction8)) {
			(_anInstruction8->dependent = locateLiteral(BytesPerWord));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction9 = genoperandoperandoperand(MoveMwrR, 0, ReceiverResultReg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction9)) {
			(_anInstruction9->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction10 = genoperandoperandoperand(MoveRMwr, TempReg, 0, _ptrReg);
		if (usesOutOfLineLiteral(_anInstruction10)) {
			(_anInstruction10->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, _ptrReg, _slotsReg);
		/* end CmpR:R: */
		/* begin JumpAboveOrEqual: */
		genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) _copyLoop ));
		/* end JumpAboveOrEqual: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, _resultReg, ReceiverResultReg);
		/* end MoveR:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
	}
	jmpTarget(_jumpVariable, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	genGetClassIndexOfNonImminto(ReceiverResultReg, ClassReg);
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction11 = genoperandoperand(CmpCqR, ClassMethodContextCompactIndex, ClassReg);
		if (usesOutOfLineLiteral(_anInstruction11)) {
			(_anInstruction11->dependent = locateLiteral(ClassMethodContextCompactIndex));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin JumpNonZero: */
		genConditionalBranchoperand(JumpNonZero, ((sqInt) _continuance ));
		/* end JumpNonZero: */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpNoSpace, jmpTarget(_jumpIsMethod, jmpTarget(_jumpTooBig, jmpTarget(_jumpEmpty, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	return 0;
}
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveStoreInt32IntoBytes */
static sqInt
genPrimitiveStoreInt32IntoBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _destPointerRegister;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpNonSmallInteger;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveStore:intoBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 4, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 4 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(4 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg0Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, _destPointerRegister);
	/* end MoveR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, ClassReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin genJumpNotSmallInteger:scratchReg: */
		_jumpNonSmallInteger = genJumpNotSmallInteger(Arg1Reg);
		/* end genJumpNotSmallInteger:scratchReg: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertSmallIntegerToIntegerInReg(Arg1Reg);
		/* begin MoveR:M32:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveRM32r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M32:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonSmallInteger, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
	/* end genPrimitiveStore:intoBytesWith:needsToTrap: */
}
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveStoreInt32IntoExternalAddress */
static sqInt
genPrimitiveStoreInt32IntoExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _destPointerRegister;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	AbstractInstruction * _jumpNonSmallInteger;
	sqInt _quickConstant;

	/* begin genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, _destPointerRegister);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, _destPointerRegister);
	/* end AddR:R: */
	{
		/* begin genJumpNotSmallInteger:scratchReg: */
		_jumpNonSmallInteger = genJumpNotSmallInteger(Arg1Reg);
		/* end genJumpNotSmallInteger:scratchReg: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertSmallIntegerToIntegerInReg(Arg1Reg);
		/* begin MoveR:M32:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveRM32r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M32:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonSmallInteger, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpNonExternalAddress, jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveStoreInt64IntoBytes */
static sqInt
genPrimitiveStoreInt64IntoBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _destPointerRegister;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpNonSmallInteger;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveStore:intoBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 8, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(8));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 8 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(8 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg0Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, _destPointerRegister);
	/* end MoveR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, ClassReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin genJumpNotSmallInteger:scratchReg: */
		_jumpNonSmallInteger = genJumpNotSmallInteger(Arg1Reg);
		/* end genJumpNotSmallInteger:scratchReg: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertSmallIntegerToIntegerInReg(Arg1Reg);
		{
			assert(BytesPerWord == 8);
			/* begin gen:operand:quickConstant:operand: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperandoperand(MoveRMwr, Arg1Reg, 0, _destPointerRegister);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
			/* end gen:operand:quickConstant:operand: */
		}
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		jmpTarget(_jumpNonSmallInteger, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return 0;
	/* end genPrimitiveStore:intoBytesWith:needsToTrap: */
}
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveStoreInt64IntoExternalAddress */
static sqInt
genPrimitiveStoreInt64IntoExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _destPointerRegister;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	AbstractInstruction * _jumpNonSmallInteger;
	sqInt _quickConstant;

	/* begin genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, _destPointerRegister);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, _destPointerRegister);
	/* end AddR:R: */
	{
		/* begin genJumpNotSmallInteger:scratchReg: */
		_jumpNonSmallInteger = genJumpNotSmallInteger(Arg1Reg);
		/* end genJumpNotSmallInteger:scratchReg: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertSmallIntegerToIntegerInReg(Arg1Reg);
		{
			assert(BytesPerWord == 8);
			/* begin gen:operand:quickConstant:operand: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperandoperand(MoveRMwr, Arg1Reg, 0, _destPointerRegister);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
			/* end gen:operand:quickConstant:operand: */
		}
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		jmpTarget(_jumpNonSmallInteger, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpNonExternalAddress, jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return 0;
	/* end genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveStoreUInt32IntoBytes */
static sqInt
genPrimitiveStoreUInt32IntoBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _destPointerRegister;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpNegative;
	AbstractInstruction * _jumpNonSmallInteger;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveStore:intoBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction22 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction22)) {
		(_anInstruction22->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 4, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 4 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(4 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg0Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, _destPointerRegister);
	/* end MoveR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, ClassReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin genJumpNotSmallInteger:scratchReg: */
		_jumpNonSmallInteger = genJumpNotSmallInteger(Arg1Reg);
		/* end genJumpNotSmallInteger:scratchReg: */
		/* begin CmpCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, 0, Arg1Reg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpLess: */
		_jumpNegative = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
		/* end JumpLess: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertSmallIntegerToIntegerInReg(Arg1Reg);
		/* begin MoveR:M32:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperandoperand(MoveRM32r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M32:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonSmallInteger, jmpTarget(_jumpNegative, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	}
	jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
	/* end genPrimitiveStore:intoBytesWith:needsToTrap: */
}
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveStoreUInt32IntoExternalAddress */
static sqInt
genPrimitiveStoreUInt32IntoExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	sqInt _destPointerRegister;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNegative;
	AbstractInstruction * _jumpNonExternalAddress;
	AbstractInstruction * _jumpNonSmallInteger;
	sqInt _quickConstant;

	/* begin genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction22 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, _destPointerRegister);
	if (usesOutOfLineLiteral(_anInstruction22)) {
		(_anInstruction22->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, _destPointerRegister);
	/* end AddR:R: */
	{
		/* begin genJumpNotSmallInteger:scratchReg: */
		_jumpNonSmallInteger = genJumpNotSmallInteger(Arg1Reg);
		/* end genJumpNotSmallInteger:scratchReg: */
		/* begin CmpCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, 0, Arg1Reg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpLess: */
		_jumpNegative = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
		/* end JumpLess: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertSmallIntegerToIntegerInReg(Arg1Reg);
		/* begin MoveR:M32:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperandoperand(MoveRM32r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M32:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonSmallInteger, jmpTarget(_jumpNegative, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	}
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpNonExternalAddress, jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveStoreUInt64IntoBytes */
static sqInt
genPrimitiveStoreUInt64IntoBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _destPointerRegister;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpNegative;
	AbstractInstruction * _jumpNonSmallInteger;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveStore:intoBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction22 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction22)) {
		(_anInstruction22->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 8, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(8));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 8 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(8 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg0Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, _destPointerRegister);
	/* end MoveR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, ClassReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin genJumpNotSmallInteger:scratchReg: */
		_jumpNonSmallInteger = genJumpNotSmallInteger(Arg1Reg);
		/* end genJumpNotSmallInteger:scratchReg: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(CmpCqR, 0, Arg1Reg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin JumpLess: */
		_jumpNegative = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
		/* end JumpLess: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertSmallIntegerToIntegerInReg(Arg1Reg);
		{
			assert(BytesPerWord == 8);
			/* begin gen:operand:quickConstant:operand: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperandoperand(MoveRMwr, Arg1Reg, 0, _destPointerRegister);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
			/* end gen:operand:quickConstant:operand: */
		}
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		jmpTarget(_jumpNonSmallInteger, jmpTarget(_jumpNegative, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	}
	jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return 0;
	/* end genPrimitiveStore:intoBytesWith:needsToTrap: */
}
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveStoreUInt64IntoExternalAddress */
static sqInt
genPrimitiveStoreUInt64IntoExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	sqInt _destPointerRegister;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNegative;
	AbstractInstruction * _jumpNonExternalAddress;
	AbstractInstruction * _jumpNonSmallInteger;
	sqInt _quickConstant;

	/* begin genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction22 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, _destPointerRegister);
	if (usesOutOfLineLiteral(_anInstruction22)) {
		(_anInstruction22->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, _destPointerRegister);
	/* end AddR:R: */
	{
		/* begin genJumpNotSmallInteger:scratchReg: */
		_jumpNonSmallInteger = genJumpNotSmallInteger(Arg1Reg);
		/* end genJumpNotSmallInteger:scratchReg: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(CmpCqR, 0, Arg1Reg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin JumpLess: */
		_jumpNegative = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
		/* end JumpLess: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertSmallIntegerToIntegerInReg(Arg1Reg);
		{
			assert(BytesPerWord == 8);
			/* begin gen:operand:quickConstant:operand: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperandoperand(MoveRMwr, Arg1Reg, 0, _destPointerRegister);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
			/* end gen:operand:quickConstant:operand: */
		}
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		jmpTarget(_jumpNonSmallInteger, jmpTarget(_jumpNegative, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	}
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpNonExternalAddress, jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return 0;
	/* end genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
}
/*	c.f. StackInterpreter>>stSizeOf: SpurMemoryManager>>lengthOf:format: 
	fixedFieldsOf:format:length:  */
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveStringAt */
static sqInt
genPrimitiveStringAt(void)
{
	AbstractInstruction *_anInstruction10;
	AbstractInstruction *_anInstruction11;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction *_anInstruction7;
	AbstractInstruction *_anInstruction8;
	AbstractInstruction *_anInstruction9;
	AbstractInstruction *_done;
	sqInt _formatReg;
	AbstractInstruction *_jumpBadIndex;
	AbstractInstruction *_jumpBytesOutOfBounds;
	AbstractInstruction *_jumpIsBytes;
	AbstractInstruction *_jumpIsShorts;
	AbstractInstruction *_jumpNotIndexable;
	AbstractInstruction *_jumpShortsOutOfBounds;
	AbstractInstruction *_jumpWordsDone;
	AbstractInstruction *_jumpWordsOutOfBounds;
	AbstractInstruction *_jumpWordTooBig;
	sqInt _quickConstant;
	sqInt _quickConstant2;
	sqInt _quickConstant3;
	sqInt _quickConstant4;

	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(SubCqR, 1, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), NoReg);
	genGetNumSlotsOfinto(ReceiverResultReg, ClassReg);
	/* begin CmpCq:R: */
	_quickConstant = firstByteFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpGreaterOrEqual: */
	_jumpIsBytes = genConditionalBranchoperand(JumpGreaterOrEqual, ((sqInt) 0 ));
	/* end JumpGreaterOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant2 = firstShortFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(CmpCqR, _quickConstant2, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(_quickConstant2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpGreaterOrEqual: */
	_jumpIsShorts = genConditionalBranchoperand(JumpGreaterOrEqual, ((sqInt) 0 ));
	/* end JumpGreaterOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant3 = firstLongFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction5 = genoperandoperand(CmpCqR, _quickConstant3, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction5)) {
		(_anInstruction5->dependent = locateLiteral(_quickConstant3));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpLess: */
	_jumpNotIndexable = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
	/* end JumpLess: */
	/* begin LogicalShiftLeftCq:R: */
	genoperandoperand(LogicalShiftLeftCqR, (shiftForWord()) - 2, ClassReg);
	/* end LogicalShiftLeftCq:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction6 = genoperandoperand(AndCqR, (BytesPerWord / 4) - 1, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction6)) {
		(_anInstruction6->dependent = locateLiteral((BytesPerWord / 4) - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, _formatReg, ClassReg);
	/* end SubR:R: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, Arg1Reg, ClassReg);
	/* end CmpR:R: */
	/* begin JumpBelowOrEqual: */
	_jumpWordsOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin AddCq:R: */
	_quickConstant4 = ((usqInt) BaseHeaderSize ) >> ((shiftForWord()) - 1);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction7 = genoperandoperand(AddCqR, _quickConstant4, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction7)) {
		(_anInstruction7->dependent = locateLiteral(_quickConstant4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AddCq:R: */
	/* begin MoveX32r:R:R: */
	genoperandoperandoperand(MoveX32rRR, Arg1Reg, ReceiverResultReg, TempReg);
	/* end MoveX32r:R:R: */
	_jumpWordTooBig = jumpNotCharacterUnsignedValueInRegister(TempReg);
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, TempReg, ReceiverResultReg);
	/* end MoveR:R: */
	/* begin Jump: */
	_jumpWordsDone = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpIsBytes, gLogicalShiftLeftCqR(shiftForWord(), ClassReg));
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction8 = genoperandoperand(AndCqR, BytesPerWord - 1, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction8)) {
		(_anInstruction8->dependent = locateLiteral(BytesPerWord - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, _formatReg, ClassReg);
	/* end SubR:R: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, Arg1Reg, ClassReg);
	/* end CmpR:R: */
	/* begin JumpBelowOrEqual: */
	_jumpBytesOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction9 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction9)) {
		(_anInstruction9->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin MoveXbr:R:R: */
	genoperandoperandoperand(MoveXbrRR, Arg1Reg, ReceiverResultReg, ReceiverResultReg);
	/* end MoveXbr:R:R: */
	jmpTarget(_jumpWordsDone, (_done = genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	genConvertIntegerToCharacterInReg(ReceiverResultReg);
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpIsShorts, gLogicalShiftLeftCqR((shiftForWord()) - 1, ClassReg));
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction10 = genoperandoperand(AndCqR, (BytesPerWord / 2) - 1, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction10)) {
		(_anInstruction10->dependent = locateLiteral((BytesPerWord / 2) - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, _formatReg, ClassReg);
	/* end SubR:R: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, Arg1Reg, ClassReg);
	/* end CmpR:R: */
	/* begin JumpBelowOrEqual: */
	_jumpShortsOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg1Reg, ReceiverResultReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction11 = genoperandoperandoperand(MoveM16rR, BaseHeaderSize, ReceiverResultReg, ReceiverResultReg);
	if (usesOutOfLineLiteral(_anInstruction11)) {
		(_anInstruction11->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin Jump: */
	genoperand(Jump, ((sqInt) _done ));
	/* end Jump: */
	jmpTarget(_jumpWordTooBig, jmpTarget(_jumpBytesOutOfBounds, jmpTarget(_jumpShortsOutOfBounds, jmpTarget(_jumpWordsOutOfBounds, jmpTarget(_jumpNotIndexable, jmpTarget(_jumpBadIndex, genoperandoperand(Label, (labelCounter += 1), bytecodePC)))))));
	return CompletePrimitive;
}
/*	c.f. StackInterpreter>>stSizeOf: SpurMemoryManager>>lengthOf:format: 
	fixedFieldsOf:format:length:  */
/* CogObjectRepresentationFor64BitSpur>>#genPrimitiveStringAtPut */
static sqInt
genPrimitiveStringAtPut(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction10;
	AbstractInstruction *_anInstruction11;
	AbstractInstruction *_anInstruction12;
	AbstractInstruction *_anInstruction13;
	AbstractInstruction *_anInstruction14;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction *_anInstruction7;
	AbstractInstruction *_anInstruction8;
	AbstractInstruction *_anInstruction9;
	sqInt _formatReg;
	AbstractInstruction *_jumpBadArg;
	AbstractInstruction *_jumpBadIndex;
	AbstractInstruction *_jumpBytesOutOfBounds;
	AbstractInstruction *_jumpBytesOutOfRange;
	AbstractInstruction * _jumpImmutable;
	AbstractInstruction *_jumpIsBytes;
	AbstractInstruction * _jumpIsCompiledMethod;
	AbstractInstruction *_jumpIsShorts;
	AbstractInstruction * _jumpNotString;
	AbstractInstruction *_jumpShortsOutOfBounds;
	AbstractInstruction *_jumpShortsOutOfRange;
	AbstractInstruction *_jumpWordsOutOfBounds;
	AbstractInstruction *_jumpWordsOutOfRange;
	sqInt _quickConstant;
	sqInt _quickConstant2;
	sqInt _quickConstant3;
	sqInt _quickConstant4;
	sqInt _quickConstant5;
	sqInt _quickConstant6;
	sqInt _quickConstant7;

	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	_jumpImmutable = ((AbstractInstruction *) 0 );
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	_jumpBadArg = genJumpNotCharacter(Arg1Reg);
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(SubCqR, 1, Arg0Reg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	
#  if IMMUTABILITY
	{
		genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
		/* begin genJumpBaseHeaderImmutable: */
		/* begin TstCq:R: */
		_quickConstant7 = immutableBitMask();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction14 = genoperandoperand(TstCqR, _quickConstant7, TempReg);
		if (usesOutOfLineLiteral(_anInstruction14)) {
			(_anInstruction14->dependent = locateLiteral(_quickConstant7));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end TstCq:R: */
		/* begin JumpNonZero: */
		_jumpImmutable = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		/* end genJumpBaseHeaderImmutable: */
	}
#  else /* IMMUTABILITY */
	{
		genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), NoReg);
	}
#  endif /* IMMUTABILITY */
	genGetNumSlotsOfinto(ReceiverResultReg, ClassReg);
	/* begin CmpCq:R: */
	_quickConstant = firstLongFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpNotString = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin CmpCq:R: */
	_quickConstant2 = firstCompiledMethodFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant2, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpIsCompiledMethod = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant3 = firstByteFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(CmpCqR, _quickConstant3, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(_quickConstant3));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpIsBytes = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant4 = firstShortFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction5 = genoperandoperand(CmpCqR, _quickConstant4, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction5)) {
		(_anInstruction5->dependent = locateLiteral(_quickConstant4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpIsShorts = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant5 = characterObjectOf((1U << (numCharacterBits())) - 1);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction6 = genoperandoperand(CmpCqR, _quickConstant5, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction6)) {
		(_anInstruction6->dependent = locateLiteral(_quickConstant5));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAbove: */
	_jumpWordsOutOfRange = genConditionalBranchoperand(JumpAbove, ((sqInt) 0 ));
	/* end JumpAbove: */
	/* begin LogicalShiftLeftCq:R: */
	genoperandoperand(LogicalShiftLeftCqR, (shiftForWord()) - 2, ClassReg);
	/* end LogicalShiftLeftCq:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction7 = genoperandoperand(AndCqR, (BytesPerWord / 4) - 1, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction7)) {
		(_anInstruction7->dependent = locateLiteral((BytesPerWord / 4) - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, _formatReg, ClassReg);
	/* end SubR:R: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, Arg0Reg, ClassReg);
	/* end CmpR:R: */
	/* begin JumpBelowOrEqual: */
	_jumpWordsOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg1Reg, TempReg);
	/* end MoveR:R: */
	genConvertCharacterToCodeInReg(TempReg);
	/* begin AddCq:R: */
	_quickConstant6 = ((usqInt) BaseHeaderSize ) >> ((shiftForWord()) - 1);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction8 = genoperandoperand(AddCqR, _quickConstant6, Arg0Reg);
	if (usesOutOfLineLiteral(_anInstruction8)) {
		(_anInstruction8->dependent = locateLiteral(_quickConstant6));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AddCq:R: */
	/* begin MoveR:X32r:R: */
	genoperandoperandoperand(MoveRX32rR, TempReg, Arg0Reg, ReceiverResultReg);
	/* end MoveR:X32r:R: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpIsShorts, gCmpCqR(characterObjectOf(0xFFFF), Arg1Reg));
	/* begin JumpAbove: */
	_jumpShortsOutOfRange = genConditionalBranchoperand(JumpAbove, ((sqInt) 0 ));
	/* end JumpAbove: */
	/* begin LogicalShiftLeftCq:R: */
	genoperandoperand(LogicalShiftLeftCqR, (shiftForWord()) - 1, ClassReg);
	/* end LogicalShiftLeftCq:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction9 = genoperandoperand(AndCqR, (BytesPerWord / 2) - 1, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction9)) {
		(_anInstruction9->dependent = locateLiteral((BytesPerWord / 2) - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, _formatReg, ClassReg);
	/* end SubR:R: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, Arg0Reg, ClassReg);
	/* end CmpR:R: */
	/* begin JumpBelowOrEqual: */
	_jumpShortsOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg1Reg, TempReg);
	/* end MoveR:R: */
	genConvertCharacterToCodeInReg(TempReg);
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, ReceiverResultReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction10 = genoperandoperandoperand(MoveRM16r, TempReg, BaseHeaderSize, ReceiverResultReg);
	if (usesOutOfLineLiteral(_anInstruction10)) {
		(_anInstruction10->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpIsBytes, gCmpCqR(characterObjectOf(0xFF), Arg1Reg));
	/* begin JumpAbove: */
	_jumpBytesOutOfRange = genConditionalBranchoperand(JumpAbove, ((sqInt) 0 ));
	/* end JumpAbove: */
	/* begin LogicalShiftLeftCq:R: */
	genoperandoperand(LogicalShiftLeftCqR, shiftForWord(), ClassReg);
	/* end LogicalShiftLeftCq:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction11 = genoperandoperand(AndCqR, BytesPerWord - 1, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction11)) {
		(_anInstruction11->dependent = locateLiteral(BytesPerWord - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, _formatReg, ClassReg);
	/* end SubR:R: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, Arg0Reg, ClassReg);
	/* end CmpR:R: */
	/* begin JumpBelowOrEqual: */
	_jumpBytesOutOfBounds = genConditionalBranchoperand(JumpBelowOrEqual, ((sqInt) 0 ));
	/* end JumpBelowOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg1Reg, TempReg);
	/* end MoveR:R: */
	genConvertCharacterToCodeInReg(TempReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction12 = genoperandoperand(AddCqR, BaseHeaderSize, Arg0Reg);
	if (usesOutOfLineLiteral(_anInstruction12)) {
		(_anInstruction12->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin MoveR:Xbr:R: */
	genoperandoperandoperand(MoveRXbrR, TempReg, Arg0Reg, ReceiverResultReg);
	/* end MoveR:Xbr:R: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpNotString, jmpTarget(_jumpBytesOutOfRange, jmpTarget(_jumpShortsOutOfRange, jmpTarget(_jumpWordsOutOfRange, jmpTarget(_jumpIsCompiledMethod, jmpTarget(_jumpBytesOutOfBounds, jmpTarget(_jumpShortsOutOfBounds, jmpTarget(_jumpWordsOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC)))))))));
	
#  if IMMUTABILITY
	{
		jmpTarget(_jumpImmutable, ((AbstractInstruction *) ((_jumpNotString->operands)[0]) ));
	}
#  endif /* IMMUTABILITY */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction13 = genoperandoperand(AddCqR, 1, Arg0Reg);
	if (usesOutOfLineLiteral(_anInstruction13)) {
		(_anInstruction13->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpBadArg, jmpTarget(_jumpBadIndex, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
}
/* CogObjectRepresentationFor64BitSpur>>#genRemoveSmallIntegerTagsInScratchReg: */
static sqInt NoDbgRegParms
genRemoveSmallIntegerTagsInScratchReg(sqInt _scratchReg)
{
	AbstractInstruction *_anInstruction;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(SubCqR, 1, _scratchReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	return 0;
}
/*	Get the literal count of a CompiledMethod into headerReg, plus one if 
	requested. If inBytes is true, scale the count by the word size. Deal with 
	the possibility of 
	the method being cogged. */
/* CogObjectRepresentationFor64BitSpur>>#getLiteralCountOf:plusOne:inBytes:into:scratch: */
static sqInt NoDbgRegParms
getLiteralCountOfplusOneinBytesintoscratch(sqInt _methodReg, sqInt _plusOne, sqInt _inBytes, sqInt _litCountReg, sqInt _scratchReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _quickConstant;
	sqInt _quickConstant2;
	sqInt _quickConstant3;
	sqInt _quickConstant4;

	genGetMethodHeaderOfintoscratch(_methodReg, _litCountReg, _scratchReg);
	assert((1U << (numTagBits())) == BytesPerWord);
	if (_inBytes) {
		/* begin AndCq:R: */
		_quickConstant2 = ((sqInt) (((usqInt) (alternateHeaderNumLiteralsMask()) ) << (numTagBits())) );
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(AndCqR, _quickConstant2, _litCountReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_quickConstant2));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end AndCq:R: */
	} else {
		{
			/* begin LogicalShiftRightCq:R: */
			_quickConstant = numTagBits();
			genoperandoperand(LogicalShiftRightCqR, _quickConstant, _litCountReg);
			/* end LogicalShiftRightCq:R: */
			/* begin AndCq:R: */
			_quickConstant3 = alternateHeaderNumLiteralsMask();
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction2 = genoperandoperand(AndCqR, _quickConstant3, _litCountReg);
			if (usesOutOfLineLiteral(_anInstruction2)) {
				(_anInstruction2->dependent = locateLiteral(_quickConstant3));
			}
			/* end checkQuickConstant:forInstruction: */
			/* end AndCq:R: */
		}
	}
	if (_plusOne) {
		/* begin AddCq:R: */
		_quickConstant4 = ((_inBytes)
			 ? LiteralStart * BytesPerWord
			 : LiteralStart);
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperand(AddCqR, _quickConstant4, _litCountReg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(_quickConstant4));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end AddCq:R: */
	}
	return 0;
}
/*	Answer the relevant inline cache tag for an instance. 
	c.f. getInlineCacheClassTagFrom:into: & inlineCacheTagForClass: */
/* CogObjectRepresentationFor64BitSpur>>#inlineCacheTagForInstance: */
static sqInt NoDbgRegParms
inlineCacheTagForInstance(sqInt _oop)
{
	return ((isImmediate(_oop))
		 ? _oop & (tagMask())
		 : classIndexOf(_oop));
}
/* CogObjectRepresentationFor64BitSpur>>#log2BytesPerWord */
static sqInt
log2BytesPerWord(void)
{
	return 3;
}
/*	Generate the routine that converts selector indices into selector objects. 
	It is called from the send trampolines. 
	If the selector index is negative, convert it into a positive index into 
	the special selectors array and index that. Otherwise, index the current 
	method. The routine uses Extra0Reg & Extra1Reg, which are available, since 
	they are not live at point of send. */
/* CogObjectRepresentationFor64BitSpur>>#maybeGenerateSelectorIndexDereferenceRoutine */
static void
maybeGenerateSelectorIndexDereferenceRoutine(void)
{
	sqInt _address;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction *_anInstruction7;
	AbstractInstruction *_jumpNegative;
	sqInt _offset;
	sqInt _quickConstant;

	zeroOpcodeIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction7 = genoperandoperand(CmpCqR, 0, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction7)) {
		(_anInstruction7->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpLess: */
	_jumpNegative = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
	/* end JumpLess: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMwrR, FoxMethod, FPReg, Extra0Reg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(FoxMethod));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(AddCqR, 2, ClassReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(2));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin AndCq:R: */
		_quickConstant = -(zoneAlignment());
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperand(AndCqR, _quickConstant, Extra0Reg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end AndCq:R: */
		/* begin MoveMw:r:R: */
		_offset = offsetof(CogMethod, methodObject);
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction4 = genoperandoperandoperand(MoveMwrR, _offset, Extra0Reg, Extra1Reg);
		if (usesOutOfLineLiteral(_anInstruction4)) {
			(_anInstruction4->dependent = locateLiteral(_offset));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
		/* begin MoveXwr:R:R: */
		genoperandoperandoperand(MoveXwrRR, ClassReg, Extra1Reg, ClassReg);
		/* end MoveXwr:R:R: */
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	}
	jmpTarget(_jumpNegative, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	{
		/* begin NegateR: */
		genoperand(NegateR, ClassReg);
		/* end NegateR: */
		/* begin LogicalShiftLeftCq:R: */
		genoperandoperand(LogicalShiftLeftCqR, 1, ClassReg);
		/* end LogicalShiftLeftCq:R: */
		/* begin MoveAw:R: */
		_address = specialObjectsArrayAddress();
		/* begin gen:literal:operand: */
		checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, Extra0Reg));
		/* end gen:literal:operand: */
		/* end MoveAw:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 1, ClassReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(1));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction6 = genoperandoperandoperand(MoveMwrR, (SpecialSelectors + 1) * BytesPerWord, Extra0Reg, Extra1Reg);
		if (usesOutOfLineLiteral(_anInstruction6)) {
			(_anInstruction6->dependent = locateLiteral((SpecialSelectors + 1) * BytesPerWord));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin MoveXwr:R:R: */
		genoperandoperandoperand(MoveXwrRR, ClassReg, Extra1Reg, ClassReg);
		/* end MoveXwr:R:R: */
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	}
	ceDereferenceSelectorIndex = methodZoneBase();
	{
		outputInstructionsForGeneratedRuntimeAt(ceDereferenceSelectorIndex);
		recordGeneratedRunTimeaddress("ceDereferenceSelectorIndex", ceDereferenceSelectorIndex);
		recordRunTimeObjectReferences();
	}
}
/* CogObjectRepresentationFor64BitSpur>>#numSmallIntegerBits */
static sqInt
numSmallIntegerBits(void)
{
	return 61;
}
/* CogObjectRepresentationFor64BitSpur>>#numSmallIntegerTagBits */
static sqInt
numSmallIntegerTagBits(void)
{
	return 3;
}
/*	The three valid tag patterns are 1 (SmallInteger), 2 (Character) and 3 
	(SmallFloat64).  */
/* CogObjectRepresentationFor64BitSpur>>#validInlineCacheTag: */
static sqInt NoDbgRegParms
validInlineCacheTag(sqInt _classIndexOrTagPattern)
{
	return ((_classIndexOrTagPattern >= 1) && (_classIndexOrTagPattern <= 3)) || ((classAtIndex(_classIndexOrTagPattern)) != null);
}
/*	Answer if the cacheTag is not unmarked, i.e. answer true for compact class 
	indices and immediates; only answer false for unmarked objects. In Spur 
	linked send cache tags are class indices so effectively they're always 
	marked.  */
/* CogObjectRepresentationForSpur>>#cacheTagIsMarked: */
static sqInt NoDbgRegParms
cacheTagIsMarked(sqInt cacheTag)
{
	return 1;
}
/* CogObjectRepresentationForSpur>>#callStoreCheckTrampoline */
static void
callStoreCheckTrampoline(void)
{
	AbstractInstruction *_abstractInstruction;

	/* begin CallRT: */
	/* begin annotateCall: */
	_abstractInstruction = genoperand(Call, ceStoreCheckTrampoline);
	(_abstractInstruction->annotation = IsRelativeCall);
	/* end annotateCall: */
	/* end CallRT: */
}
/* CogObjectRepresentationForSpur>>#checkValidDerivedObjectReference: */
static sqInt NoDbgRegParms
checkValidDerivedObjectReference(sqInt _bodyAddress)
{
	return (heapMapAtWord(pointerForOop(_bodyAddress - BaseHeaderSize))) != 0;
}
/* CogObjectRepresentationForSpur>>#checkValidOopReference: */
static sqInt NoDbgRegParms
checkValidOopReference(sqInt _anOop)
{
	return (isImmediate(_anOop)) || ((heapMapAtWord(pointerForOop(_anOop))) != 0);
}
/* CogObjectRepresentationForSpur>>#couldBeDerivedObject: */
static sqInt NoDbgRegParms
couldBeDerivedObject(sqInt _bodyAddress)
{
	return oopisGreaterThanOrEqualTo(_bodyAddress - BaseHeaderSize, startOfObjectMemory(getMemoryMap()));
}
/* CogObjectRepresentationForSpur>>#couldBeObject: */
static sqInt NoDbgRegParms
couldBeObject(sqInt _literal)
{
	return (isNonImmediate(_literal)) && (oopisGreaterThanOrEqualTo(_literal, startOfObjectMemory(getMemoryMap())));
}
/*	Create a trampoline to answer the active context that will 
	answer it if a frame is already married, and create it otherwise. 
	Assume numArgs is in SendNumArgsReg and ClassReg is free. */
/* CogObjectRepresentationForSpur>>#genActiveContextTrampolineLarge:inBlock:called: */
static sqInt NoDbgRegParms
genActiveContextTrampolineLargeinBlockcalled(sqInt _isLarge, sqInt _isInBlock, char *_aString)
{
	sqInt _startAddress;

	_startAddress = methodZoneBase();
	zeroOpcodeIndex();
	genGetActiveContextLargeinBlock(_isLarge, _isInBlock);
	outputInstructionsForGeneratedRuntimeAt(_startAddress);
	recordGeneratedRunTimeaddress(_aString, _startAddress);
	recordRunTimeObjectReferences();
	return _startAddress;
}
/* CogObjectRepresentationForSpur>>#genAllocExternalAddressValue:into:scratchReg:scratchReg: */
static AbstractInstruction * NoDbgRegParms
genAllocExternalAddressValueintoscratchRegscratchReg(sqInt _valueReg, sqInt _resultReg, sqInt _scratch1, sqInt scratch2)
{
	sqInt _address;
	sqInt _address2;
	sqInt _allocSize;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction * _jumpFail;
	usqLong _newExternalAddressHeader;
	sqInt _quickConstant;

	_allocSize = BaseHeaderSize + BytesPerWord;
	_newExternalAddressHeader = headerForSlotsformatclassIndex(1, firstByteFormat(), classExternalAddressIndex());
	/* begin MoveAw:R: */
	_address = freeStartAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, _resultReg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(LoadEffectiveAddressMwrR, _allocSize, _resultReg, _scratch1);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_allocSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin CmpCq:R: */
	_quickConstant = getScavengeThreshold();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _scratch1);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpFail = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:Aw: */
	_address2 = freeStartAddress();
	/* begin gen:operand:literal: */
	checkLiteralforInstruction(_address2, genoperandoperand(MoveRAw, _scratch1, _address2));
	/* end gen:operand:literal: */
	/* end MoveR:Aw: */
	/* begin genStoreHeader:intoNewInstance:using: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperand(MoveCqR, _newExternalAddressHeader, _scratch1);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(_newExternalAddressHeader));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction22 = genoperandoperandoperand(MoveRMwr, _scratch1, 0, _resultReg);
		if (usesOutOfLineLiteral(_anInstruction22)) {
			(_anInstruction22->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* end genStoreHeader:intoNewInstance:using: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperandoperand(MoveRMwr, _valueReg, BaseHeaderSize, _resultReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	return _jumpFail;
}
/*	Check the remembered bit of the object in objReg; answer the jump taken if 
	the bit is already set. 
	Only need to fetch the byte containing it, which reduces the size of the 
	mask constant. */
/* CogObjectRepresentationForSpur>>#genCheckRememberedBitOf:scratch: */
static AbstractInstruction * NoDbgRegParms
genCheckRememberedBitOfscratch(sqInt _objReg, sqInt _scratchReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	int _mask;
	sqInt _rememberedBitByteOffset;

	_rememberedBitByteOffset = (rememberedBitShift()) / 8;
	_mask = 1ULL << ((rememberedBitShift()) % 8);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveMbrR, _rememberedBitByteOffset, _objReg, _scratchReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_rememberedBitByteOffset));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(TstCqR, _mask, _scratchReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_mask));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpNonZero: */
	return genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
}
/* CogObjectRepresentationForSpur>>#genConvertCharacterToCodeInReg: */
static sqInt NoDbgRegParms
genConvertCharacterToCodeInReg(sqInt _reg)
{
	sqInt _quickConstant;

	/* begin LogicalShiftRightCq:R: */
	_quickConstant = numTagBits();
	genoperandoperand(LogicalShiftRightCqR, _quickConstant, _reg);
	/* end LogicalShiftRightCq:R: */
	return 0;
}
/* CogObjectRepresentationForSpur>>#genConvertIntegerToCharacterInReg: */
static sqInt NoDbgRegParms
genConvertIntegerToCharacterInReg(sqInt _reg)
{
	AbstractInstruction *_anInstruction;
	sqInt _quickConstant;
	sqInt _quickConstant2;

	{
		/* begin LogicalShiftLeftCq:R: */
		_quickConstant = numTagBits();
		genoperandoperand(LogicalShiftLeftCqR, _quickConstant, _reg);
		/* end LogicalShiftLeftCq:R: */
		/* begin AddCq:R: */
		_quickConstant2 = characterTag();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(AddCqR, _quickConstant2, _reg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_quickConstant2));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end AddCq:R: */
	}
	return 0;
}
/*	Create a full closure with the given values. */
/* CogObjectRepresentationForSpur>>#genCreateFullClosure:numArgs:numCopied:ignoreContext:contextNumArgs:large:inBlock: */
static sqInt NoDbgRegParms
genCreateFullClosurenumArgsnumCopiedignoreContextcontextNumArgslargeinBlock(sqInt _compiledBlock, sqInt _numArgs, sqInt _numCopied, sqInt _ignoreContext, sqInt _contextNumArgs, sqInt _contextIsLarge, sqInt _contextIsBlock)
{
	AbstractInstruction *_abstractInstruction;
	sqInt _address;
	sqInt _address2;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction *_anInstruction7;
	AbstractInstruction *_anInstruction8;
	AbstractInstruction *_anInstruction9;
	usqInt _byteSize;
	sqInt _constant;
	usqLong _header;
	sqInt _literal;
	sqInt _numSlots;
	sqInt _quickConstant;
	AbstractInstruction *_skip;

	if (_ignoreContext) {
		/* begin genMoveConstant:R: */
		_constant = nilObject();
		if (shouldAnnotateObjectReference(_constant)) {
			annotateobjRef(gMoveCwR(_constant, ClassReg), _constant);
		} else {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction9 = genoperandoperand(MoveCqR, _constant, ClassReg);
			if (usesOutOfLineLiteral(_anInstruction9)) {
				(_anInstruction9->dependent = locateLiteral(_constant));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		/* end genMoveConstant:R: */
	} else {
		genGetActiveContextNumArgslargeinBlock(_contextNumArgs, _contextIsLarge, _contextIsBlock);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, ReceiverResultReg, ClassReg);
		/* end MoveR:R: */
	}
	_numSlots = FullClosureFirstCopiedValueIndex + _numCopied;
	_byteSize = smallObjectBytesForSlots(_numSlots);
	assert(ClassFullBlockClosureCompactIndex != 0);
	_header = headerForSlotsformatclassIndex(_numSlots, indexablePointersFormat(), ClassFullBlockClosureCompactIndex);
	/* begin MoveAw:R: */
	_address2 = freeStartAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address2, genoperandoperand(MoveAwR, _address2, ReceiverResultReg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	/* begin genStoreHeader:intoNewInstance:using: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction8 = genoperandoperand(MoveCqR, _header, TempReg);
		if (usesOutOfLineLiteral(_anInstruction8)) {
			(_anInstruction8->dependent = locateLiteral(_header));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction22 = genoperandoperandoperand(MoveRMwr, TempReg, 0, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction22)) {
			(_anInstruction22->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* end genStoreHeader:intoNewInstance:using: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(LoadEffectiveAddressMwrR, _byteSize, ReceiverResultReg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_byteSize));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin MoveR:Aw: */
		_address = freeStartAddress();
		/* begin gen:operand:literal: */
		checkLiteralforInstruction(_address, genoperandoperand(MoveRAw, TempReg, _address));
		/* end gen:operand:literal: */
		/* end MoveR:Aw: */
		/* begin CmpCq:R: */
		_quickConstant = getScavengeThreshold();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
	}
	/* begin JumpBelow: */
	_skip = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin CallRT: */
	/* begin annotateCall: */
	_abstractInstruction = genoperand(Call, ceScheduleScavengeTrampoline);
	(_abstractInstruction->annotation = IsRelativeCall);
	/* end annotateCall: */
	/* end CallRT: */
	jmpTarget(_skip, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction4 = genoperandoperandoperand(MoveRMwr, ClassReg, (FullClosureOuterContextIndex * BytesPerOop) + BaseHeaderSize, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction4)) {
			(_anInstruction4->dependent = locateLiteral((FullClosureOuterContextIndex * BytesPerOop) + BaseHeaderSize));
		}
		/* end checkQuickConstant:forInstruction: */
		if (shouldAnnotateObjectReference(_compiledBlock)) {
			annotateobjRef(gMoveCwR(_compiledBlock, TempReg), _compiledBlock);
		} else {
			/* begin MoveCq:R: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction3 = genoperandoperand(MoveCqR, _compiledBlock, TempReg);
			if (usesOutOfLineLiteral(_anInstruction3)) {
				(_anInstruction3->dependent = locateLiteral(_compiledBlock));
			}
			/* end checkQuickConstant:forInstruction: */
			/* end MoveCq:R: */
		}
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperandoperand(MoveRMwr, TempReg, (FullClosureCompiledBlockIndex * BytesPerOop) + BaseHeaderSize, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral((FullClosureCompiledBlockIndex * BytesPerOop) + BaseHeaderSize));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_literal = ((((usqInt) _numArgs ) << 3) | 1);
		_anInstruction6 = genoperandoperand(MoveCqR, ((((usqInt) _numArgs ) << 3) | 1), TempReg);
		if (usesOutOfLineLiteral(_anInstruction6)) {
			(_anInstruction6->dependent = locateLiteral(_literal));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction7 = genoperandoperandoperand(MoveRMwr, TempReg, (FullClosureNumArgsIndex * BytesPerOop) + BaseHeaderSize, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction7)) {
			(_anInstruction7->dependent = locateLiteral((FullClosureNumArgsIndex * BytesPerOop) + BaseHeaderSize));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	return 0;
}
/*	Make sure that the object in reg is not forwarded. This routine assumes 
	the object will 
	never be forwarded to an immediate, as it is used to unforward literal 
	variables (associations).  
	Use the fact that isForwardedObjectClassIndexPun is a power of two to save 
	an instruction. */
/* CogObjectRepresentationForSpur>>#genEnsureObjInRegNotForwarded:scratchReg: */
static sqInt NoDbgRegParms
genEnsureObjInRegNotForwardedscratchReg(sqInt _reg, sqInt _scratch)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_loop;
	AbstractInstruction *_ok;
	sqInt _quickConstant;

	assert(_reg != _scratch);
	/* begin Label */
	_loop = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
	/* end Label */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveMwrR, 0, _reg, _scratch);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AndCq:R: */
	_quickConstant = (classIndexMask()) - (isForwardedObjectClassIndexPun());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(AndCqR, _quickConstant, _scratch);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AndCq:R: */
	/* begin JumpNonZero: */
	_ok = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	genLoadSlotsourceRegdestReg(0, _reg, _reg);
	/* begin Jump: */
	genoperand(Jump, ((sqInt) _loop ));
	/* end Jump: */
	jmpTarget(_ok, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return 0;
}
/* CogObjectRepresentationForSpur>>#genEnsureOopInRegNotForwarded:scratchReg: */
static sqInt NoDbgRegParms
genEnsureOopInRegNotForwardedscratchReg(sqInt _reg, sqInt _scratch)
{
	AbstractInstruction *_instruction;

	/* begin genEnsureOopInRegNotForwarded:scratchReg:jumpBackTo: */
	_instruction = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
	return genEnsureOopInRegNotForwardedscratchRegifForwarderifNotForwarder(_reg, _scratch, _instruction, 0);
	/* end genEnsureOopInRegNotForwarded:scratchReg:jumpBackTo: */
}
/*	Make sure that the oop in reg is not forwarded.  
	Use the fact that isForwardedObjectClassIndexPun is a power of two to save 
	an instruction. */
/* CogObjectRepresentationForSpur>>#genEnsureOopInRegNotForwarded:scratchReg:ifForwarder:ifNotForwarder: */
static sqInt NoDbgRegParms
genEnsureOopInRegNotForwardedscratchRegifForwarderifNotForwarder(sqInt _reg, sqInt _scratch, sqInt _fwdJumpTarget, sqInt _nonFwdJumpTargetOrZero)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction * _finished;
	AbstractInstruction * _imm;
	AbstractInstruction * _ok;
	sqInt _quickConstant;

	assert(_reg != _scratch);
	_imm = genJumpImmediate(_reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveMwrR, 0, _reg, _scratch);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AndCq:R: */
	_quickConstant = (classIndexMask()) - (isForwardedObjectClassIndexPun());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(AndCqR, _quickConstant, _scratch);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AndCq:R: */
	/* begin JumpNonZero: */
	_ok = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	genLoadSlotsourceRegdestReg(0, _reg, _reg);
	/* begin Jump: */
	genoperand(Jump, ((sqInt) ((void *) _fwdJumpTarget ) ));
	/* end Jump: */
	if (((usqInt) _nonFwdJumpTargetOrZero ) == 0) {
		/* begin Label */
		_finished = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
		/* end Label */
	} else {
		_finished = _nonFwdJumpTargetOrZero;
	}
	jmpTarget(_imm, jmpTarget(_ok, _finished));
	return 0;
}
/*	Make sure that the oop in reg is not forwarded, updating the slot in 
	objReg with the value. */
/* CogObjectRepresentationForSpur>>#genEnsureOopInRegNotForwarded:scratchReg:updatingSlot:in: */
static sqInt NoDbgRegParms
genEnsureOopInRegNotForwardedscratchRegupdatingSlotin(sqInt _reg, sqInt _scratch, sqInt _index, sqInt _objReg)
{
	AbstractInstruction *_abstractInstruction;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_imm;
	AbstractInstruction *_loop;
	AbstractInstruction *_ok;
	sqInt _quickConstant;

	assert((_reg != _scratch) && (_objReg != _scratch));
	/* begin Label */
	_loop = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
	/* end Label */
	_imm = genJumpImmediate(_reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveMwrR, 0, _reg, _scratch);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AndCq:R: */
	_quickConstant = (classIndexMask()) - (isForwardedObjectClassIndexPun());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(AndCqR, _quickConstant, _scratch);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AndCq:R: */
	/* begin JumpNonZero: */
	_ok = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	genLoadSlotsourceRegdestReg(0, _reg, _reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperandoperand(MoveRMwr, _reg, (_index * BytesPerWord) + BaseHeaderSize, _objReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral((_index * BytesPerWord) + BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	assert((_reg == Arg0Reg) && ((_scratch == TempReg) && (_objReg == ReceiverResultReg)));
	/* begin CallRT: */
	/* begin annotateCall: */
	_abstractInstruction = genoperand(Call, ceStoreCheckContextReceiverTrampoline);
	(_abstractInstruction->annotation = IsRelativeCall);
	/* end annotateCall: */
	/* end CallRT: */
	/* begin Jump: */
	genoperand(Jump, ((sqInt) _loop ));
	/* end Jump: */
	jmpTarget(_ok, jmpTarget(_imm, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return 0;
}
/*	Do the store check. Answer the argument for the benefit of the code 
	generator; ReceiverResultReg may be caller-saved and hence smashed by this 
	call. Answering 
	it allows the code generator to reload ReceiverResultReg cheaply. 
	In Spur the only thing we leave to the run-time is adding the receiver to 
	the remembered set and setting its isRemembered bit. */
/* CogObjectRepresentationForSpur>>#generateObjectRepresentationTrampolines */
static void
generateObjectRepresentationTrampolines(void)
{
	sqInt _instVarIndex;
	AbstractInstruction *_jumpSC;

	
#  if IMMUTABILITY
	{
		for (_instVarIndex = 0; _instVarIndex < NumStoreTrampolines; _instVarIndex += 1) {
			ceStoreTrampolines[_instVarIndex] = genStoreTrampolineCalledinstVarIndex(trampolineNamenumArgslimit("ceStoreTrampoline", _instVarIndex, NumStoreTrampolines - 2), _instVarIndex);
		}
	}
#  endif /* IMMUTABILITY */
	ceNewHashTrampoline = genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(ceNewHashOf, "ceNewHash", 1, ReceiverResultReg, null, null, null, (/* begin emptyRegisterMask */ 0 /* end emptyRegisterMask */), 1, ReceiverResultReg, 0);
	/* begin genStoreCheckTrampoline */
	if (CheckRememberedInTrampoline) {
		zeroOpcodeIndex();
		_jumpSC = genCheckRememberedBitOfscratch(ReceiverResultReg, R0);
		assert(((_jumpSC->opcode)) == JumpNonZero);
		(_jumpSC->opcode = JumpZero);
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
		jmpTarget(_jumpSC, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	ceStoreCheckTrampoline = genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(rememberObjInCorrectRememberedSet, "ceStoreCheckTrampoline", 1, ReceiverResultReg, null, null, null, (CallerSavedRegisterMask | (1U << ReceiverResultReg)) - (1U << ReceiverResultReg), 1, ((CallerSavedRegisterMask & (1U << ReceiverResultReg))
		 ? ReceiverResultReg
		 : (/* begin cResultRegister */ R0 /* end cResultRegister */)), CheckRememberedInTrampoline);
	/* end genStoreCheckTrampoline */
	ceStoreCheckContextReceiverTrampoline = genStoreCheckContextReceiverTrampoline();
	ceScheduleScavengeTrampoline = genTrampolineForcalledregsToSave(ceScheduleScavenge, "ceScheduleScavengeTrampoline", CallerSavedRegisterMask);
	ceSmallActiveContextInMethodTrampoline = genActiveContextTrampolineLargeinBlockcalled(0, 0, "ceSmallMethodContext");
	ceSmallActiveContextInFullBlockTrampoline = genActiveContextTrampolineLargeinBlockcalled(0, InFullBlock, "ceSmallFullBlockContext");
	ceLargeActiveContextInMethodTrampoline = genActiveContextTrampolineLargeinBlockcalled(1, 0, "ceLargeMethodContext");
	ceLargeActiveContextInFullBlockTrampoline = genActiveContextTrampolineLargeinBlockcalled(1, InFullBlock, "ceLargeFullBlockContext");
}
/*	Create a trampoline to answer the active context that will 
	answer it if a frame is already married, and create it otherwise. 
	Assume numArgs is in SendNumArgsReg and ClassReg is free. */
/* CogObjectRepresentationForSpur>>#genGetActiveContextLarge:inBlock: */
static sqInt NoDbgRegParms
genGetActiveContextLargeinBlock(sqInt _isLarge, sqInt _isInBlock)
{
	sqInt _address;
	sqInt _address2;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction10;
	AbstractInstruction *_anInstruction11;
	AbstractInstruction *_anInstruction12;
	AbstractInstruction *_anInstruction13;
	AbstractInstruction *_anInstruction14;
	AbstractInstruction *_anInstruction15;
	AbstractInstruction *_anInstruction16;
	AbstractInstruction *_anInstruction17;
	AbstractInstruction *_anInstruction18;
	AbstractInstruction *_anInstruction19;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction20;
	AbstractInstruction *_anInstruction21;
	AbstractInstruction *_anInstruction23;
	AbstractInstruction *_anInstruction24;
	AbstractInstruction *_anInstruction25;
	AbstractInstruction *_anInstruction26;
	AbstractInstruction *_anInstruction27;
	AbstractInstruction *_anInstruction28;
	AbstractInstruction *_anInstruction29;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction30;
	AbstractInstruction *_anInstruction31;
	AbstractInstruction *_anInstruction32;
	AbstractInstruction *_anInstruction33;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction *_anInstruction7;
	AbstractInstruction *_anInstruction8;
	AbstractInstruction *_anInstruction9;
	sqInt _constant;
	AbstractInstruction *_continuation;
	AbstractInstruction *_exit;
	usqLong _header;
	AbstractInstruction * _inst;
	AbstractInstruction *_jumpNeedScavenge;
	AbstractInstruction *_jumpSingle;
	AbstractInstruction *_loopHead;
	sqInt _offset;
	sqInt _quickConstant;
	sqInt _quickConstant2;
	sqInt _quickConstant3;
	sqInt _quickConstant4;
	sqInt _quickConstant5;
	sqInt _slotSize;

	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMwrR, FoxMethod, FPReg, ClassReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(FoxMethod));
		}
		/* end checkQuickConstant:forInstruction: */
		gAndCqRR(MFMethodFlagHasContextFlag, ClassReg, TempReg);
	}
	/* begin JumpZero: */
	_jumpSingle = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperandoperand(MoveMwrR, FoxThisContext, FPReg, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(FoxThisContext));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	}
	jmpTarget(_jumpSingle, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperand(OrCqR, MFMethodFlagHasContextFlag, ClassReg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(MFMethodFlagHasContextFlag));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction4 = genoperandoperandoperand(MoveRMwr, ClassReg, FoxMethod, FPReg);
		if (usesOutOfLineLiteral(_anInstruction4)) {
			(_anInstruction4->dependent = locateLiteral(FoxMethod));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	switch (_isInBlock) {
		case InFullBlock:
		{
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction5 = genoperandoperand(SubCqR, 3, ClassReg);
			if (usesOutOfLineLiteral(_anInstruction5)) {
				(_anInstruction5->dependent = locateLiteral(3));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		break;
		case 0:
		{
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction6 = genoperandoperand(SubCqR, 1, ClassReg);
			if (usesOutOfLineLiteral(_anInstruction6)) {
				(_anInstruction6->dependent = locateLiteral(1));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		break;
		default:
		error("Case not found and no otherwise clause");
	}
	_slotSize = ((_isLarge)
		 ? LargeContextSlots
		 : SmallContextSlots);
	_header = headerForSlotsformatclassIndex(_slotSize, indexablePointersFormat(), ClassMethodContextCompactIndex);
	flag("endianness");
	/* begin MoveAw:R: */
	_address2 = freeStartAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address2, genoperandoperand(MoveAwR, _address2, ReceiverResultReg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	/* begin genStoreHeader:intoNewInstance:using: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction25 = genoperandoperand(MoveCqR, _header, TempReg);
		if (usesOutOfLineLiteral(_anInstruction25)) {
			(_anInstruction25->dependent = locateLiteral(_header));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction24 = genoperandoperandoperand(MoveRMwr, TempReg, 0, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction24)) {
			(_anInstruction24->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* end genStoreHeader:intoNewInstance:using: */
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, ReceiverResultReg, TempReg);
		/* end MoveR:R: */
		/* begin AddCq:R: */
		_quickConstant2 = smallObjectBytesForSlots(_slotSize);
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction7 = genoperandoperand(AddCqR, _quickConstant2, TempReg);
		if (usesOutOfLineLiteral(_anInstruction7)) {
			(_anInstruction7->dependent = locateLiteral(_quickConstant2));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end AddCq:R: */
		/* begin MoveR:Aw: */
		_address = freeStartAddress();
		/* begin gen:operand:literal: */
		checkLiteralforInstruction(_address, genoperandoperand(MoveRAw, TempReg, _address));
		/* end gen:operand:literal: */
		/* end MoveR:Aw: */
		/* begin CmpCq:R: */
		_quickConstant3 = getScavengeThreshold();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction8 = genoperandoperand(CmpCqR, _quickConstant3, TempReg);
		if (usesOutOfLineLiteral(_anInstruction8)) {
			(_anInstruction8->dependent = locateLiteral(_quickConstant3));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
	}
	/* begin JumpAboveOrEqual: */
	_jumpNeedScavenge = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	_continuation = genoperandoperand(MoveRR, FPReg, TempReg);
	/* end MoveR:R: */
	genSetSmallIntegerTagsIn(TempReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction26 = genoperandoperandoperand(MoveRMwr, TempReg, BaseHeaderSize + (SenderIndex * BytesPerOop), ReceiverResultReg);
	if (usesOutOfLineLiteral(_anInstruction26)) {
		(_anInstruction26->dependent = locateLiteral(BaseHeaderSize + (SenderIndex * BytesPerOop)));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction27 = genoperandoperandoperand(MoveMwrR, FoxSavedFP, FPReg, TempReg);
	if (usesOutOfLineLiteral(_anInstruction27)) {
		(_anInstruction27->dependent = locateLiteral(FoxSavedFP));
	}
	/* end checkQuickConstant:forInstruction: */
	genSetSmallIntegerTagsIn(TempReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction28 = genoperandoperandoperand(MoveRMwr, TempReg, BaseHeaderSize + (InstructionPointerIndex * BytesPerOop), ReceiverResultReg);
	if (usesOutOfLineLiteral(_anInstruction28)) {
		(_anInstruction28->dependent = locateLiteral(BaseHeaderSize + (InstructionPointerIndex * BytesPerOop)));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin MoveMw:r:R: */
		_offset = offsetof(CogMethod, methodObject);
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction9 = genoperandoperandoperand(MoveMwrR, _offset, ClassReg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction9)) {
			(_anInstruction9->dependent = locateLiteral(_offset));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction10 = genoperandoperandoperand(MoveRMwr, TempReg, BaseHeaderSize + (MethodIndex * BytesPerWord), ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction10)) {
			(_anInstruction10->dependent = locateLiteral(BaseHeaderSize + (MethodIndex * BytesPerWord)));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction11 = genoperandoperandoperand(MoveRMwr, ReceiverResultReg, FoxThisContext, FPReg);
		if (usesOutOfLineLiteral(_anInstruction11)) {
			(_anInstruction11->dependent = locateLiteral(FoxThisContext));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, FPReg, TempReg);
		/* end MoveR:R: */
		/* begin SubR:R: */
		genoperandoperand(SubRR, SPReg, TempReg);
		/* end SubR:R: */
		/* begin LogicalShiftRightCq:R: */
		_quickConstant = log2BytesPerWord();
		genoperandoperand(LogicalShiftRightCqR, _quickConstant, TempReg);
		/* end LogicalShiftRightCq:R: */
		/* begin SubCq:R: */
		_quickConstant4 = 3;
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction12 = genoperandoperand(SubCqR, _quickConstant4, TempReg);
		if (usesOutOfLineLiteral(_anInstruction12)) {
			(_anInstruction12->dependent = locateLiteral(_quickConstant4));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end SubCq:R: */
		/* begin AddR:R: */
		genoperandoperand(AddRR, SendNumArgsReg, TempReg);
		/* end AddR:R: */
	}
	genConvertIntegerToSmallIntegerInReg(TempReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction29 = genoperandoperandoperand(MoveRMwr, TempReg, BaseHeaderSize + (StackPointerIndex * BytesPerOop), ReceiverResultReg);
	if (usesOutOfLineLiteral(_anInstruction29)) {
		(_anInstruction29->dependent = locateLiteral(BaseHeaderSize + (StackPointerIndex * BytesPerOop)));
	}
	/* end checkQuickConstant:forInstruction: */
	if (_isInBlock > 0) {
		{
			/* begin MoveR:R: */
			genoperandoperand(MoveRR, SendNumArgsReg, TempReg);
			/* end MoveR:R: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction13 = genoperandoperand(AddCqR, 2, TempReg);
			if (usesOutOfLineLiteral(_anInstruction13)) {
				(_anInstruction13->dependent = locateLiteral(2));
			}
			/* end checkQuickConstant:forInstruction: */
			/* begin MoveXwr:R:R: */
			genoperandoperandoperand(MoveXwrRR, TempReg, FPReg, TempReg);
			/* end MoveXwr:R:R: */
		}
	} else {
		/* begin genMoveConstant:R: */
		_constant = nilObject();
		if (shouldAnnotateObjectReference(_constant)) {
			annotateobjRef(gMoveCwR(_constant, TempReg), _constant);
		} else {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction33 = genoperandoperand(MoveCqR, _constant, TempReg);
			if (usesOutOfLineLiteral(_anInstruction33)) {
				(_anInstruction33->dependent = locateLiteral(_constant));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		/* end genMoveConstant:R: */
	}
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction30 = genoperandoperandoperand(MoveRMwr, TempReg, BaseHeaderSize + (ClosureIndex * BytesPerOop), ReceiverResultReg);
	if (usesOutOfLineLiteral(_anInstruction30)) {
		(_anInstruction30->dependent = locateLiteral(BaseHeaderSize + (ClosureIndex * BytesPerOop)));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction14 = genoperandoperandoperand(MoveMwrR, FoxMFReceiver, FPReg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction14)) {
			(_anInstruction14->dependent = locateLiteral(FoxMFReceiver));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction15 = genoperandoperandoperand(MoveRMwr, TempReg, BaseHeaderSize + (ReceiverIndex * BytesPerOop), ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction15)) {
			(_anInstruction15->dependent = locateLiteral(BaseHeaderSize + (ReceiverIndex * BytesPerOop)));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction31 = genoperandoperand(MoveCqR, 1, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction31)) {
		(_anInstruction31->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin CmpR:R: */
	_loopHead = genoperandoperand(CmpRR, SendNumArgsReg, ClassReg);
	/* end CmpR:R: */
	/* begin JumpGreater: */
	_exit = genConditionalBranchoperand(JumpGreater, ((sqInt) 0 ));
	/* end JumpGreater: */
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SendNumArgsReg, TempReg);
		/* end MoveR:R: */
		/* begin SubR:R: */
		genoperandoperand(SubRR, ClassReg, TempReg);
		/* end SubR:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction16 = genoperandoperand(AddCqR, 2, TempReg);
		if (usesOutOfLineLiteral(_anInstruction16)) {
			(_anInstruction16->dependent = locateLiteral(2));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin MoveXwr:R:R: */
		genoperandoperandoperand(MoveXwrRR, TempReg, FPReg, TempReg);
		/* end MoveXwr:R:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction17 = genoperandoperand(AddCqR, ReceiverIndex + (BaseHeaderSize / BytesPerWord), ClassReg);
		if (usesOutOfLineLiteral(_anInstruction17)) {
			(_anInstruction17->dependent = locateLiteral(ReceiverIndex + (BaseHeaderSize / BytesPerWord)));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin MoveR:Xwr:R: */
		genoperandoperandoperand(MoveRXwrR, TempReg, ClassReg, ReceiverResultReg);
		/* end MoveR:Xwr:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction18 = genoperandoperand(SubCqR, (ReceiverIndex + (BaseHeaderSize / BytesPerWord)) - 1, ClassReg);
		if (usesOutOfLineLiteral(_anInstruction18)) {
			(_anInstruction18->dependent = locateLiteral((ReceiverIndex + (BaseHeaderSize / BytesPerWord)) - 1));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin Jump: */
		genoperand(Jump, ((sqInt) _loopHead ));
		/* end Jump: */
	}
	jmpTarget(_exit, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	{
		/* begin MoveCq:R: */
		_quickConstant5 = nilObject();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction19 = genoperandoperand(MoveCqR, _quickConstant5, TempReg);
		if (usesOutOfLineLiteral(_anInstruction19)) {
			(_anInstruction19->dependent = locateLiteral(_quickConstant5));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveCq:R: */
	}
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, FPReg, ClassReg);
		/* end MoveR:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction20 = genoperandoperand(AddCqR, FoxMFReceiver, ClassReg);
		if (usesOutOfLineLiteral(_anInstruction20)) {
			(_anInstruction20->dependent = locateLiteral(FoxMFReceiver));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction21 = genoperandoperand(AddCqR, (ReceiverIndex + 1) + (BaseHeaderSize / BytesPerWord), SendNumArgsReg);
		if (usesOutOfLineLiteral(_anInstruction21)) {
			(_anInstruction21->dependent = locateLiteral((ReceiverIndex + 1) + (BaseHeaderSize / BytesPerWord)));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction32 = genoperandoperand(SubCqR, BytesPerWord, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction32)) {
		(_anInstruction32->dependent = locateLiteral(BytesPerWord));
	}
	_loopHead = _anInstruction32;
	/* end checkQuickConstant:forInstruction: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, SPReg, ClassReg);
	/* end CmpR:R: */
	{
		/* begin JumpBelow: */
		_exit = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
		/* end JumpBelow: */
	}
	{
		/* begin MoveR:Xwr:R: */
		genoperandoperandoperand(MoveRXwrR, TempReg, SendNumArgsReg, ReceiverResultReg);
		/* end MoveR:Xwr:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction23 = genoperandoperand(AddCqR, 1, SendNumArgsReg);
		if (usesOutOfLineLiteral(_anInstruction23)) {
			(_anInstruction23->dependent = locateLiteral(1));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin Jump: */
		genoperand(Jump, ((sqInt) _loopHead ));
		/* end Jump: */
	}
	jmpTarget(_exit, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	/* begin RetN: */
	genoperand(RetN, 0);
	/* end RetN: */
	jmpTarget(_jumpNeedScavenge, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	/* begin saveAndRestoreLinkRegAround: */
	_inst = genoperand(PushR, LinkReg);
	{
		CallRTregistersToBeSavedMask(ceScheduleScavengeTrampoline, ((1U << ReceiverResultReg) | (1U << SendNumArgsReg)) | (1U << ClassReg));
	}
	genoperand(PopR, LinkReg);
	/* end saveAndRestoreLinkRegAround: */
	/* begin Jump: */
	genoperand(Jump, ((sqInt) _continuation ));
	/* end Jump: */
	return 0;
}
/*	Get the active context into ReceiverResultReg, creating it if necessary. */
/* CogObjectRepresentationForSpur>>#genGetActiveContextNumArgs:large:inBlock: */
static sqInt NoDbgRegParms
genGetActiveContextNumArgslargeinBlock(sqInt _numArgs, sqInt _isLargeContext, sqInt _isInBlock)
{
	AbstractInstruction *_abstractInstruction;
	AbstractInstruction *_anInstruction;
	sqInt _routine;

	if (_isLargeContext) {
		switch (_isInBlock) {
			case 0:
			{
				_routine = ceLargeActiveContextInMethodTrampoline;
			}
			break;
			case InFullBlock:
			{
				_routine = ceLargeActiveContextInFullBlockTrampoline;
			}
			break;
			default:
			error("Case not found and no otherwise clause");
			_routine = -1;
		}
	}
 else {
		switch (_isInBlock) {
			case 0:
			{
				_routine = ceSmallActiveContextInMethodTrampoline;
			}
			break;
			case InFullBlock:
			{
				_routine = ceSmallActiveContextInFullBlockTrampoline;
			}
			break;
			default:
			error("Case not found and no otherwise clause");
			_routine = -1;
		}
	}
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, _numArgs, SendNumArgsReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_numArgs));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin CallRT: */
		/* begin annotateCall: */
		_abstractInstruction = genoperand(Call, _routine);
		(_abstractInstruction->annotation = IsRelativeCall);
		/* end annotateCall: */
		/* end CallRT: */
	}
	return 0;
}
/* CogObjectRepresentationForSpur>>#genGetBits:ofFormatByteOf:into: */
static sqInt NoDbgRegParms
genGetBitsofFormatByteOfinto(sqInt _mask, sqInt _sourceReg, sqInt _destReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;

	flag("endianness");
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveMbrR, 3, _sourceReg, _destReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(3));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(AndCqR, _mask, _destReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_mask));
	}
	/* end checkQuickConstant:forInstruction: */
	return 0;
}
/*	Fetch the instance's class index into destReg. */
/* CogObjectRepresentationForSpur>>#genGetClassIndexOfNonImm:into: */
static sqInt NoDbgRegParms
genGetClassIndexOfNonImminto(sqInt _sourceReg, sqInt _destReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	sqInt _quickConstant;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveMwrR, 0, _sourceReg, _destReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AndCq:R: */
	_quickConstant = classIndexMask();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(AndCqR, _quickConstant, _destReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AndCq:R: */
	return 0;
}
/*	Fetch the class object whose index is in instReg into destReg. 
	It is non-obvious, but the Cogit assumes loading a class does not involve 
	a runtime call, so do not call classAtIndex: */
/* CogObjectRepresentationForSpur>>#genGetClassObjectOfClassIndex:into:scratchReg: */
static sqInt NoDbgRegParms
genGetClassObjectOfClassIndexintoscratchReg(sqInt _classIndexRegister, sqInt _destReg, sqInt _scratchReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _offset;
	sqInt _quickConstant;
	sqInt _quickConstant3;
	sqInt _quickConstant4;

	assert(_classIndexRegister != _destReg);
	assert(_classIndexRegister != _scratchReg);
	assert(_destReg != _scratchReg);
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, _classIndexRegister, _scratchReg);
		/* end MoveR:R: */
		/* begin LogicalShiftRightCq:R: */
		_quickConstant = classTableMajorIndexShift();
		genoperandoperand(LogicalShiftRightCqR, _quickConstant, _scratchReg);
		/* end LogicalShiftRightCq:R: */
		/* begin LogicalShiftLeftCq:R: */
		genoperandoperand(LogicalShiftLeftCqR, shiftForWord(), _scratchReg);
		/* end LogicalShiftLeftCq:R: */
	}
	assert(!(shouldAnnotateObjectReference(classTableRootObj())));
	{
		/* begin MoveMw:r:R: */
		_offset = (classTableRootObj()) + BaseHeaderSize;
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMwrR, _offset, _scratchReg, _destReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_offset));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
	}
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, _classIndexRegister, _scratchReg);
		/* end MoveR:R: */
		/* begin AndCq:R: */
		_quickConstant3 = classTableMinorIndexMask();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction4 = genoperandoperand(AndCqR, _quickConstant3, _scratchReg);
		if (usesOutOfLineLiteral(_anInstruction4)) {
			(_anInstruction4->dependent = locateLiteral(_quickConstant3));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end AndCq:R: */
		/* begin AddCq:R: */
		_quickConstant4 = ((usqInt) BaseHeaderSize ) >> (shiftForWord());
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(AddCqR, _quickConstant4, _scratchReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(_quickConstant4));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end AddCq:R: */
		/* begin MoveXwr:R:R: */
		genoperandoperandoperand(MoveXwrRR, _scratchReg, _destReg, _destReg);
		/* end MoveXwr:R:R: */
	}
	return 0;
}
/*	Fetch the instance's class into destReg. If the instance is not the 
	receiver and is forwarded, follow forwarding. */
/* CogObjectRepresentationForSpur>>#genGetClassObjectOf:into:scratchReg:instRegIsReceiver: */
static sqInt NoDbgRegParms
genGetClassObjectOfintoscratchReginstRegIsReceiver(sqInt _instReg, sqInt _destReg, sqInt _scratchReg, sqInt _instRegIsReceiver)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_jumpIsImm;
	AbstractInstruction *_jumpNotForwarded;
	AbstractInstruction *_loop;
	sqInt _quickConstant;
	sqInt _quickConstant2;
	sqInt _quickConstant3;

	if ((_instReg == _destReg) || ((_instReg == _scratchReg) || (_destReg == _scratchReg))) {
		return BadRegisterSet;
	}
	/* begin MoveR:R: */
	_loop = genoperandoperand(MoveRR, _instReg, _scratchReg);
	/* end MoveR:R: */
	/* begin AndCq:R: */
	_quickConstant2 = tagMask();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(AndCqR, _quickConstant2, _scratchReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AndCq:R: */
	/* begin JumpNonZero: */
	_jumpIsImm = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	flag("endianness");
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperandoperand(MoveMwrR, 0, _instReg, _scratchReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AndCq:R: */
	_quickConstant3 = classIndexMask();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction5 = genoperandoperand(AndCqR, _quickConstant3, _scratchReg);
	if (usesOutOfLineLiteral(_anInstruction5)) {
		(_anInstruction5->dependent = locateLiteral(_quickConstant3));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AndCq:R: */
	if (!_instRegIsReceiver) {
		/* begin CmpCq:R: */
		_quickConstant = isForwardedObjectClassIndexPun();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, _quickConstant, _scratchReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpNonZero: */
		_jumpNotForwarded = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, _instReg, _instReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin Jump: */
		genoperand(Jump, ((sqInt) _loop ));
		/* end Jump: */
		jmpTarget(_jumpNotForwarded, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpIsImm, genoperandoperand(MoveRR, _scratchReg, _destReg));
	if (_scratchReg == TempReg) {
		/* begin PushR: */
		genoperand(PushR, _instReg);
		/* end PushR: */
		genGetClassObjectOfClassIndexintoscratchReg(_destReg, _instReg, TempReg);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, _instReg, _destReg);
		/* end MoveR:R: */
		/* begin PopR: */
		genoperand(PopR, _instReg);
		/* end PopR: */
	} else {
		genGetClassObjectOfClassIndexintoscratchReg(_destReg, _scratchReg, TempReg);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, _scratchReg, _destReg);
		/* end MoveR:R: */
	}
	return 0;
}
/* CogObjectRepresentationForSpur>>#genGetClassTagOf:into:scratchReg: */
static AbstractInstruction * NoDbgRegParms
genGetClassTagOfintoscratchReg(sqInt _instReg, sqInt _destReg, sqInt scratchReg)
{
	return genGetInlineCacheClassTagFrominto(_instReg, _destReg);
}
/*	Fetch the instance's class index into destReg. */
/* CogObjectRepresentationForSpur>>#genGetCompactClassIndexNonImmOf:into: */
static sqInt NoDbgRegParms
genGetCompactClassIndexNonImmOfinto(sqInt _instReg, sqInt _destReg)
{
	return genGetClassIndexOfNonImminto(_instReg, _destReg);
}
/* CogObjectRepresentationForSpur>>#genGetDoubleValueOf:into: */
static sqInt NoDbgRegParms
genGetDoubleValueOfinto(sqInt _srcReg, sqInt _destFPReg)
{
	AbstractInstruction *_anInstruction;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveM64rRd, BaseHeaderSize, _srcReg, _destFPReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	return 0;
}
/*	Get the format field of the object in srcReg into destReg. 
	srcReg may equal destReg. */
/* CogObjectRepresentationForSpur>>#genGetFormatOf:into: */
static sqInt NoDbgRegParms
genGetFormatOfinto(sqInt _srcReg, sqInt _destReg)
{
	return genGetBitsofFormatByteOfinto(formatMask(), _srcReg, _destReg);
}
/*	Get the format of the object in sourceReg into destReg. If 
	scratchRegOrNone is not NoReg, load at least the least significant 32-bits 
	(64-bits in 64-bits) of the 
	header word, which contains the format, into scratchRegOrNone. */
/* CogObjectRepresentationForSpur>>#genGetFormatOf:into:leastSignificantHalfOfBaseHeaderIntoScratch: */
static sqInt NoDbgRegParms
genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(sqInt _sourceReg, sqInt _destReg, sqInt _scratchRegOrNone)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _quickConstant;
	sqInt _quickConstant2;

	if (_scratchRegOrNone == NoReg) {
		flag("endianness");
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMbrR, 3, _sourceReg, _destReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(3));
		}
		/* end checkQuickConstant:forInstruction: */
	} else {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperandoperand(MoveMwrR, 0, _sourceReg, _destReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, _destReg, _scratchRegOrNone);
		/* end MoveR:R: */
		/* begin LogicalShiftRightCq:R: */
		_quickConstant = formatShift();
		genoperandoperand(LogicalShiftRightCqR, _quickConstant, _destReg);
		/* end LogicalShiftRightCq:R: */
	}
	/* begin AndCq:R: */
	_quickConstant2 = formatMask();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(AndCqR, _quickConstant2, _destReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AndCq:R: */
	return 0;
}
/*	Get the size in word-sized slots of the object in srcReg into destReg. 
	srcReg may equal destReg. */
/* CogObjectRepresentationForSpur>>#genGetNumSlotsOf:into: */
static sqInt NoDbgRegParms
genGetNumSlotsOfinto(sqInt _srcReg, sqInt _destReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_jmp;
	sqInt _quickConstant;

	assert(_srcReg != _destReg);
	genGetRawSlotSizeOfNonImminto(_srcReg, _destReg);
	/* begin CmpCq:R: */
	_quickConstant = numSlotsMask();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(CmpCqR, _quickConstant, _destReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpLess: */
	_jmp = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
	/* end JumpLess: */
	genGetOverflowSlotsOfinto(_srcReg, _destReg);
	jmpTarget(_jmp, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return 0;
}
/*	The raw numSlots field is the most significant byte of the 64-bit header 
	word. MoveMbrR zero-extends. */
/* CogObjectRepresentationForSpur>>#genGetRawSlotSizeOfNonImm:into: */
static sqInt NoDbgRegParms
genGetRawSlotSizeOfNonImminto(sqInt _sourceReg, sqInt _destReg)
{
	AbstractInstruction *_anInstruction2;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMbrR, 7, _sourceReg, _destReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(7));
	}
	/* end checkQuickConstant:forInstruction: */
	return 0;
}
/* CogObjectRepresentationForSpur>>#genJumpImmediate: */
static AbstractInstruction * NoDbgRegParms
genJumpImmediate(sqInt _aRegister)
{
	AbstractInstruction *_anInstruction;
	sqInt _quickConstant;

	/* begin TstCq:R: */
	_quickConstant = tagMask();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(TstCqR, _quickConstant, _aRegister);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end TstCq:R: */
	/* begin JumpNonZero: */
	return genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
}
/* CogObjectRepresentationForSpur>>#genJumpImmutable:scratchReg: */

#if IMMUTABILITY
static AbstractInstruction * NoDbgRegParms
genJumpImmutablescratchReg(sqInt _sourceReg, sqInt _scratchReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	sqInt _quickConstant;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveMwrR, 0, _sourceReg, _scratchReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin genJumpBaseHeaderImmutable: */
	/* begin TstCq:R: */
	_quickConstant = immutableBitMask();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(TstCqR, _quickConstant, _scratchReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end TstCq:R: */
	/* begin JumpNonZero: */
	return genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* end genJumpBaseHeaderImmutable: */
}
#endif /* IMMUTABILITY */
/* CogObjectRepresentationForSpur>>#genJumpMutable:scratchReg: */

#if IMMUTABILITY
static AbstractInstruction * NoDbgRegParms
genJumpMutablescratchReg(sqInt _sourceReg, sqInt _scratchReg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	sqInt _quickConstant;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveMwrR, 0, _sourceReg, _scratchReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin genJumpBaseHeaderMutable: */
	/* begin TstCq:R: */
	_quickConstant = immutableBitMask();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(TstCqR, _quickConstant, _scratchReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end TstCq:R: */
	/* begin JumpZero: */
	return genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* end genJumpBaseHeaderMutable: */
}
#endif /* IMMUTABILITY */
/*	Generate a call to code that allocates a new Array of size. 
	The Array should be initialized with nils iff initialized is true. 
	The size arg is passed in SendNumArgsReg, the result 
	must come back in ReceiverResultReg. */
/* CogObjectRepresentationForSpur>>#genNewArrayOfSize:initialized: */
static sqInt NoDbgRegParms
genNewArrayOfSizeinitialized(sqInt _size, sqInt _initialized)
{
	AbstractInstruction *_abstractInstruction;
	sqInt _address;
	sqInt _address2;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _constant;
	usqLong _header;
	sqInt _i;
	sqInt _offset;
	sqInt _quickConstant;
	AbstractInstruction *_skip;

	assert(_size < (numSlotsMask()));
	_header = headerForSlotsformatclassIndex(_size, arrayFormat(), ClassArrayCompactIndex);
	/* begin MoveAw:R: */
	_address2 = freeStartAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address2, genoperandoperand(MoveAwR, _address2, ReceiverResultReg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	/* begin genStoreHeader:intoNewInstance:using: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction4 = genoperandoperand(MoveCqR, _header, TempReg);
		if (usesOutOfLineLiteral(_anInstruction4)) {
			(_anInstruction4->dependent = locateLiteral(_header));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction22 = genoperandoperandoperand(MoveRMwr, TempReg, 0, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction22)) {
			(_anInstruction22->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* end genStoreHeader:intoNewInstance:using: */
	if (_initialized && (_size > 0)) {
		/* begin genMoveConstant:R: */
		_constant = nilObject();
		if (shouldAnnotateObjectReference(_constant)) {
			annotateobjRef(gMoveCwR(_constant, TempReg), _constant);
		} else {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction5 = genoperandoperand(MoveCqR, _constant, TempReg);
			if (usesOutOfLineLiteral(_anInstruction5)) {
				(_anInstruction5->dependent = locateLiteral(_constant));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		/* end genMoveConstant:R: */
		for (_i = 0; _i < _size; _i += 1) {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperandoperand(MoveRMwr, TempReg, (_i * BytesPerWord) + BaseHeaderSize, ReceiverResultReg);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral((_i * BytesPerWord) + BaseHeaderSize));
			}
			/* end checkQuickConstant:forInstruction: */
		}
	}
	{
		/* begin LoadEffectiveAddressMw:r:R: */
		_offset = smallObjectBytesForSlots(_size);
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperandoperand(LoadEffectiveAddressMwrR, _offset, ReceiverResultReg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(_offset));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end LoadEffectiveAddressMw:r:R: */
		/* begin MoveR:Aw: */
		_address = freeStartAddress();
		/* begin gen:operand:literal: */
		checkLiteralforInstruction(_address, genoperandoperand(MoveRAw, TempReg, _address));
		/* end gen:operand:literal: */
		/* end MoveR:Aw: */
		/* begin CmpCq:R: */
		_quickConstant = getScavengeThreshold();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
	}
	/* begin JumpBelow: */
	_skip = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin CallRT: */
	/* begin annotateCall: */
	_abstractInstruction = genoperand(Call, ceScheduleScavengeTrampoline);
	(_abstractInstruction->annotation = IsRelativeCall);
	/* end annotateCall: */
	/* end CallRT: */
	jmpTarget(_skip, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return 0;
}
/* CogObjectRepresentationForSpur>>#genPrimitiveAsCharacter */
static sqInt
genPrimitiveAsCharacter(void)
{
	AbstractInstruction *_jumpNotInt;
	AbstractInstruction *_jumpOutOfRange;
	sqInt _reg;

	_jumpNotInt = ((AbstractInstruction *) 0 );
	if (methodOrBlockNumArgs == 0) {
		_reg = ReceiverResultReg;
	} else {
		if (methodOrBlockNumArgs > 1) {
			return UnimplementedPrimitive;
		}
		_reg = Arg0Reg;
		/* begin genLoadArgAtDepth:into: */
		assert(0 < (numRegArgs()));
		/* end genLoadArgAtDepth:into: */
		/* begin genJumpNotSmallInteger:scratchReg: */
		_jumpNotInt = genJumpNotSmallInteger(_reg);
		/* end genJumpNotSmallInteger:scratchReg: */
	}
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, _reg, TempReg);
	/* end MoveR:R: */
	genConvertSmallIntegerToIntegerInReg(TempReg);
	_jumpOutOfRange = jumpNotCharacterUnsignedValueInRegister(TempReg);
	genConvertSmallIntegerToCharacterInReg(_reg);
	if (_reg != ReceiverResultReg) {
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, _reg, ReceiverResultReg);
		/* end MoveR:R: */
	}
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpOutOfRange, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	if (_reg != ReceiverResultReg) {
		jmpTarget(_jumpNotInt, ((AbstractInstruction *) ((_jumpOutOfRange->operands)[0]) ));
	}
	return CompletePrimitive;
}
/*	Generate primitive 60, at: with unsigned access for pure bits classes. */
/* CogObjectRepresentationForSpur>>#genPrimitiveAt */
static sqInt
genPrimitiveAt(void)
{
	return genPrimitiveAtSigned(0);
}
/*	Generate primitive 61, at:put: with unsigned access for pure bits classes. */
/* CogObjectRepresentationForSpur>>#genPrimitiveAtPut */
static sqInt
genPrimitiveAtPut(void)
{
	return genPrimitiveAtPutSigned(0);
}
/* CogObjectRepresentationForSpur>>#genPrimitiveIdenticalOrNotIf: */
static sqInt NoDbgRegParms
genPrimitiveIdenticalOrNotIf(sqInt _orNot)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_comp;
	sqInt _constant;
	sqInt _constant2;
	AbstractInstruction *_jumpCmp;

	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin CmpR:R: */
	_comp = genoperandoperand(CmpRR, Arg0Reg, ReceiverResultReg);
	/* end CmpR:R: */
	if (_orNot) {
		/* begin JumpZero: */
		_jumpCmp = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
		/* end JumpZero: */
		/* begin genEnsureOopInRegNotForwarded:scratchReg:jumpBackTo: */
		genEnsureOopInRegNotForwardedscratchRegifForwarderifNotForwarder(Arg0Reg, TempReg, _comp, 0);
		/* end genEnsureOopInRegNotForwarded:scratchReg:jumpBackTo: */
	} else {
		/* begin JumpNonZero: */
		_jumpCmp = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
	}
	/* begin genMoveConstant:R: */
	_constant = trueObject();
	if (shouldAnnotateObjectReference(_constant)) {
		annotateobjRef(gMoveCwR(_constant, ReceiverResultReg), _constant);
	} else {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, _constant, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_constant));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* end genMoveConstant:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpCmp, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	if (!_orNot) {
		/* begin genEnsureOopInRegNotForwarded:scratchReg:jumpBackTo: */
		genEnsureOopInRegNotForwardedscratchRegifForwarderifNotForwarder(Arg0Reg, TempReg, _comp, 0);
		/* end genEnsureOopInRegNotForwarded:scratchReg:jumpBackTo: */
	}
	/* begin genMoveConstant:R: */
	_constant2 = falseObject();
	if (shouldAnnotateObjectReference(_constant2)) {
		annotateobjRef(gMoveCwR(_constant2, ReceiverResultReg), _constant2);
	} else {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(MoveCqR, _constant2, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(_constant2));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* end genMoveConstant:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	return UnfailingPrimitive;
}
/*	Generate primitive 164, at: with signed access for pure bits classes. */
/* CogObjectRepresentationForSpur>>#genPrimitiveIntegerAt */
static sqInt
genPrimitiveIntegerAt(void)
{
	return genPrimitiveAtSigned(1);
}
/*	Generate primitive 165, at:put: with signed access for pure bits classes. */
/* CogObjectRepresentationForSpur>>#genPrimitiveIntegerAtPut */
static sqInt
genPrimitiveIntegerAtPut(void)
{
	return genPrimitiveAtPutSigned(1);
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadBoolean8FromBytes */
static sqInt
genPrimitiveLoadBoolean8FromBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	sqInt _formatReg;
	AbstractInstruction * _inst;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;
	AbstractInstruction * _trueResultJump;
	sqInt _wordConstant;

	/* begin genPrimitiveLoad:fromBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction22 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction22)) {
		(_anInstruction22->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 1, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg1Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, Arg1Reg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin MoveMb:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMbrR, 0, Arg1Reg, ClassReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMb:r:R: */
		/* begin TstCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(TstCqR, 0xFF, ClassReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(0xFF));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end TstCq:R: */
		/* begin JumpNonZero: */
		_trueResultJump = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		/* begin MoveCw:R: */
		_wordConstant = falseObject();
		/* begin gen:literal:operand: */
		_inst = checkLiteralforInstruction(_wordConstant, genoperandoperand(MoveCwR, _wordConstant, ReceiverResultReg));
		/* end gen:literal:operand: */
		/* end MoveCw:R: */
		annotateobjRef(_inst, falseObject());
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		_inst = jmpTarget(_trueResultJump, gMoveCwR(trueObject(), ReceiverResultReg));
		annotateobjRef(_inst, trueObject());
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	return CompletePrimitive;
	/* end genPrimitiveLoad:fromBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadBoolean8FromExternalAddress */
static sqInt
genPrimitiveLoadBoolean8FromExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction * _inst;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;
	AbstractInstruction * _trueResultJump;
	sqInt _wordConstant;

	/* begin genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction22 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, TempReg);
	if (usesOutOfLineLiteral(_anInstruction22)) {
		(_anInstruction22->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, Arg1Reg);
	/* end AddR:R: */
	{
		/* begin MoveMb:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMbrR, 0, Arg1Reg, ClassReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMb:r:R: */
		/* begin TstCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(TstCqR, 0xFF, ClassReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(0xFF));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end TstCq:R: */
		/* begin JumpNonZero: */
		_trueResultJump = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		/* begin MoveCw:R: */
		_wordConstant = falseObject();
		/* begin gen:literal:operand: */
		_inst = checkLiteralforInstruction(_wordConstant, genoperandoperand(MoveCwR, _wordConstant, ReceiverResultReg));
		/* end gen:literal:operand: */
		/* end MoveCw:R: */
		annotateobjRef(_inst, falseObject());
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		_inst = jmpTarget(_trueResultJump, gMoveCwR(trueObject(), ReceiverResultReg));
		annotateobjRef(_inst, trueObject());
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpNonExternalAddress, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadChar16FromBytes */
static sqInt
genPrimitiveLoadChar16FromBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction * _first;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveLoad:fromBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 2, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 2 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(2 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg1Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, Arg1Reg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin MoveM16:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveM16rR, 0, Arg1Reg, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveM16:r:R: */
		/* begin ZeroExtend16R:R: */
		{
			{
				/* begin LogicalShiftLeftCq:R: */
				_first = genoperandoperand(LogicalShiftLeftCqR, (BytesPerWord * 8) - 16, ReceiverResultReg);
				/* end LogicalShiftLeftCq:R: */
			}
			/* begin LogicalShiftRightCq:R: */
			genoperandoperand(LogicalShiftRightCqR, (BytesPerWord * 8) - 16, ReceiverResultReg);
			/* end LogicalShiftRightCq:R: */
			goto l21;
		}
		l21:
		;
		/* end ZeroExtend16R:R: */
		genConvertIntegerToCharacterInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	return CompletePrimitive;
	/* end genPrimitiveLoad:fromBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadChar16FromExternalAddress */
static sqInt
genPrimitiveLoadChar16FromExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction * _first;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;

	/* begin genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, TempReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, Arg1Reg);
	/* end AddR:R: */
	{
		/* begin MoveM16:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveM16rR, 0, Arg1Reg, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveM16:r:R: */
		/* begin ZeroExtend16R:R: */
		{
			{
				/* begin LogicalShiftLeftCq:R: */
				_first = genoperandoperand(LogicalShiftLeftCqR, (BytesPerWord * 8) - 16, ReceiverResultReg);
				/* end LogicalShiftLeftCq:R: */
			}
			/* begin LogicalShiftRightCq:R: */
			genoperandoperand(LogicalShiftRightCqR, (BytesPerWord * 8) - 16, ReceiverResultReg);
			/* end LogicalShiftRightCq:R: */
			goto l16;
		}
		l16:
		;
		/* end ZeroExtend16R:R: */
		genConvertIntegerToCharacterInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpNonExternalAddress, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadChar32FromBytes */
static sqInt
genPrimitiveLoadChar32FromBytes(void)
{
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction * _first;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveLoad:fromBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 4, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 4 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(4 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg1Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, Arg1Reg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		{
			/* begin MoveM32:r:R: */
			genMoveM32rR(backEnd, 0, Arg1Reg, ReceiverResultReg);
			/* end MoveM32:r:R: */
			/* begin ZeroExtend32R:R: */
			{
				{
					/* begin LogicalShiftLeftCq:R: */
					_first = genoperandoperand(LogicalShiftLeftCqR, 32, ReceiverResultReg);
					/* end LogicalShiftLeftCq:R: */
				}
				/* begin LogicalShiftRightCq:R: */
				genoperandoperand(LogicalShiftRightCqR, 32, ReceiverResultReg);
				/* end LogicalShiftRightCq:R: */
				goto l22;
			}
			l22:
			;
			/* end ZeroExtend32R:R: */
		}
		genConvertIntegerToCharacterInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	return CompletePrimitive;
	/* end genPrimitiveLoad:fromBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadChar32FromExternalAddress */
static sqInt
genPrimitiveLoadChar32FromExternalAddress(void)
{
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction * _first;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;

	/* begin genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, TempReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, Arg1Reg);
	/* end AddR:R: */
	{
		{
			/* begin MoveM32:r:R: */
			genMoveM32rR(backEnd, 0, Arg1Reg, ReceiverResultReg);
			/* end MoveM32:r:R: */
			/* begin ZeroExtend32R:R: */
			{
				{
					/* begin LogicalShiftLeftCq:R: */
					_first = genoperandoperand(LogicalShiftLeftCqR, 32, ReceiverResultReg);
					/* end LogicalShiftLeftCq:R: */
				}
				/* begin LogicalShiftRightCq:R: */
				genoperandoperand(LogicalShiftRightCqR, 32, ReceiverResultReg);
				/* end LogicalShiftRightCq:R: */
				goto l17;
			}
			l17:
			;
			/* end ZeroExtend32R:R: */
		}
		genConvertIntegerToCharacterInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpNonExternalAddress, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadChar8FromBytes */
static sqInt
genPrimitiveLoadChar8FromBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveLoad:fromBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 1, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg1Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, Arg1Reg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin MoveMb:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMbrR, 0, Arg1Reg, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMb:r:R: */
		genConvertIntegerToCharacterInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	return CompletePrimitive;
	/* end genPrimitiveLoad:fromBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadChar8FromExternalAddress */
static sqInt
genPrimitiveLoadChar8FromExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;

	/* begin genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, TempReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, Arg1Reg);
	/* end AddR:R: */
	{
		/* begin MoveMb:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMbrR, 0, Arg1Reg, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMb:r:R: */
		genConvertIntegerToCharacterInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpNonExternalAddress, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadFloat32FromBytes */
static sqInt
genPrimitiveLoadFloat32FromBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpFailAlloc;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveLoad:fromBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 4, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 4 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(4 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg1Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, Arg1Reg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveM32rRs, 0, Arg1Reg, DPFPReg0);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin ConvertRs:Rd: */
		genoperandoperand(ConvertRsRd, DPFPReg0, DPFPReg0);
		/* end ConvertRs:Rd: */
		_jumpFailAlloc = genAllocFloatValueintoscratchRegscratchReg(DPFPReg0, SendNumArgsReg, ClassReg, TempReg);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
		/* end MoveR:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		jmpTarget(_jumpFailAlloc, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	return 0;
	/* end genPrimitiveLoad:fromBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadFloat32FromExternalAddress */
static sqInt
genPrimitiveLoadFloat32FromExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpFailAlloc;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;

	/* begin genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, TempReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, Arg1Reg);
	/* end AddR:R: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveM32rRs, 0, Arg1Reg, DPFPReg0);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin ConvertRs:Rd: */
		genoperandoperand(ConvertRsRd, DPFPReg0, DPFPReg0);
		/* end ConvertRs:Rd: */
		_jumpFailAlloc = genAllocFloatValueintoscratchRegscratchReg(DPFPReg0, SendNumArgsReg, ClassReg, TempReg);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
		/* end MoveR:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		jmpTarget(_jumpFailAlloc, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpNonExternalAddress, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return 0;
	/* end genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadFloat64FromBytes */
static sqInt
genPrimitiveLoadFloat64FromBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpFailAlloc;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveLoad:fromBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 8, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(8));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 8 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(8 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg1Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, Arg1Reg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveM64rRd, 0, Arg1Reg, DPFPReg0);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		_jumpFailAlloc = genAllocFloatValueintoscratchRegscratchReg(DPFPReg0, SendNumArgsReg, ClassReg, TempReg);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
		/* end MoveR:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		jmpTarget(_jumpFailAlloc, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	return 0;
	/* end genPrimitiveLoad:fromBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadFloat64FromExternalAddress */
static sqInt
genPrimitiveLoadFloat64FromExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpFailAlloc;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;

	/* begin genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, TempReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, Arg1Reg);
	/* end AddR:R: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveM64rRd, 0, Arg1Reg, DPFPReg0);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		_jumpFailAlloc = genAllocFloatValueintoscratchRegscratchReg(DPFPReg0, SendNumArgsReg, ClassReg, TempReg);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
		/* end MoveR:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		jmpTarget(_jumpFailAlloc, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpNonExternalAddress, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return 0;
	/* end genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadInt16FromBytes */
static sqInt
genPrimitiveLoadInt16FromBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction * _first;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveLoad:fromBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 2, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 2 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(2 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg1Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, Arg1Reg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin MoveM16:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveM16rR, 0, Arg1Reg, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveM16:r:R: */
		/* begin SignExtend16R:R: */
		{
			{
				/* begin LogicalShiftLeftCq:R: */
				_first = genoperandoperand(LogicalShiftLeftCqR, (BytesPerWord * 8) - 16, ReceiverResultReg);
				/* end LogicalShiftLeftCq:R: */
			}
			/* begin ArithmeticShiftRightCq:R: */
			genoperandoperand(ArithmeticShiftRightCqR, (BytesPerWord * 8) - 16, ReceiverResultReg);
			/* end ArithmeticShiftRightCq:R: */
			goto l21;
		}
		l21:
		;
		/* end SignExtend16R:R: */
		genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	return CompletePrimitive;
	/* end genPrimitiveLoad:fromBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadInt16FromExternalAddress */
static sqInt
genPrimitiveLoadInt16FromExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction * _first;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;

	/* begin genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, TempReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, Arg1Reg);
	/* end AddR:R: */
	{
		/* begin MoveM16:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveM16rR, 0, Arg1Reg, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveM16:r:R: */
		/* begin SignExtend16R:R: */
		{
			{
				/* begin LogicalShiftLeftCq:R: */
				_first = genoperandoperand(LogicalShiftLeftCqR, (BytesPerWord * 8) - 16, ReceiverResultReg);
				/* end LogicalShiftLeftCq:R: */
			}
			/* begin ArithmeticShiftRightCq:R: */
			genoperandoperand(ArithmeticShiftRightCqR, (BytesPerWord * 8) - 16, ReceiverResultReg);
			/* end ArithmeticShiftRightCq:R: */
			goto l16;
		}
		l16:
		;
		/* end SignExtend16R:R: */
		genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpNonExternalAddress, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadInt8FromBytes */
static sqInt
genPrimitiveLoadInt8FromBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction * _first;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveLoad:fromBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 1, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg1Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, Arg1Reg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin MoveMb:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMbrR, 0, Arg1Reg, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMb:r:R: */
		/* begin SignExtend8R:R: */
		{
			{
				/* begin LogicalShiftLeftCq:R: */
				_first = genoperandoperand(LogicalShiftLeftCqR, (BytesPerWord * 8) - 8, ReceiverResultReg);
				/* end LogicalShiftLeftCq:R: */
			}
			/* begin ArithmeticShiftRightCq:R: */
			genoperandoperand(ArithmeticShiftRightCqR, (BytesPerWord * 8) - 8, ReceiverResultReg);
			/* end ArithmeticShiftRightCq:R: */
			goto l21;
		}
		l21:
		;
		/* end SignExtend8R:R: */
		genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	return CompletePrimitive;
	/* end genPrimitiveLoad:fromBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadInt8FromExternalAddress */
static sqInt
genPrimitiveLoadInt8FromExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction * _first;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;

	/* begin genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, TempReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, Arg1Reg);
	/* end AddR:R: */
	{
		/* begin MoveMb:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMbrR, 0, Arg1Reg, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMb:r:R: */
		/* begin SignExtend8R:R: */
		{
			{
				/* begin LogicalShiftLeftCq:R: */
				_first = genoperandoperand(LogicalShiftLeftCqR, (BytesPerWord * 8) - 8, ReceiverResultReg);
				/* end LogicalShiftLeftCq:R: */
			}
			/* begin ArithmeticShiftRightCq:R: */
			genoperandoperand(ArithmeticShiftRightCqR, (BytesPerWord * 8) - 8, ReceiverResultReg);
			/* end ArithmeticShiftRightCq:R: */
			goto l16;
		}
		l16:
		;
		/* end SignExtend8R:R: */
		genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpNonExternalAddress, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadPointerFromBytes */
static sqInt
genPrimitiveLoadPointerFromBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpFailAlloc;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveLoad:fromBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, BytesPerWord, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(BytesPerWord));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, BytesPerWord - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(BytesPerWord - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg1Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, Arg1Reg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMwrR, 0, Arg1Reg, ClassReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		_jumpFailAlloc = genAllocExternalAddressValueintoscratchRegscratchReg(ClassReg, SendNumArgsReg, Extra0Reg, TempReg);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
		/* end MoveR:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
		/* end MoveR:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		jmpTarget(_jumpFailAlloc, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	return 0;
	/* end genPrimitiveLoad:fromBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadPointerFromExternalAddress */
static sqInt
genPrimitiveLoadPointerFromExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpFailAlloc;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;

	/* begin genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, TempReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, Arg1Reg);
	/* end AddR:R: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMwrR, 0, Arg1Reg, ClassReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		_jumpFailAlloc = genAllocExternalAddressValueintoscratchRegscratchReg(ClassReg, SendNumArgsReg, Extra0Reg, TempReg);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
		/* end MoveR:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
		/* end MoveR:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
		jmpTarget(_jumpFailAlloc, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpNonExternalAddress, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return 0;
	/* end genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadUInt16FromBytes */
static sqInt
genPrimitiveLoadUInt16FromBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction * _first;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveLoad:fromBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 2, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 2 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(2 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg1Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, Arg1Reg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin MoveM16:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveM16rR, 0, Arg1Reg, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveM16:r:R: */
		/* begin ZeroExtend16R:R: */
		{
			{
				/* begin LogicalShiftLeftCq:R: */
				_first = genoperandoperand(LogicalShiftLeftCqR, (BytesPerWord * 8) - 16, ReceiverResultReg);
				/* end LogicalShiftLeftCq:R: */
			}
			/* begin LogicalShiftRightCq:R: */
			genoperandoperand(LogicalShiftRightCqR, (BytesPerWord * 8) - 16, ReceiverResultReg);
			/* end LogicalShiftRightCq:R: */
			goto l21;
		}
		l21:
		;
		/* end ZeroExtend16R:R: */
		genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	return CompletePrimitive;
	/* end genPrimitiveLoad:fromBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadUInt16FromExternalAddress */
static sqInt
genPrimitiveLoadUInt16FromExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction * _first;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;

	/* begin genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, TempReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, Arg1Reg);
	/* end AddR:R: */
	{
		/* begin MoveM16:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveM16rR, 0, Arg1Reg, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveM16:r:R: */
		/* begin ZeroExtend16R:R: */
		{
			{
				/* begin LogicalShiftLeftCq:R: */
				_first = genoperandoperand(LogicalShiftLeftCqR, (BytesPerWord * 8) - 16, ReceiverResultReg);
				/* end LogicalShiftLeftCq:R: */
			}
			/* begin LogicalShiftRightCq:R: */
			genoperandoperand(LogicalShiftRightCqR, (BytesPerWord * 8) - 16, ReceiverResultReg);
			/* end LogicalShiftRightCq:R: */
			goto l16;
		}
		l16:
		;
		/* end ZeroExtend16R:R: */
		genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpNonExternalAddress, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadUInt8FromBytes */
static sqInt
genPrimitiveLoadUInt8FromBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveLoad:fromBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 1, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg1Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, Arg1Reg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin MoveMb:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMbrR, 0, Arg1Reg, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMb:r:R: */
		genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	return CompletePrimitive;
	/* end genPrimitiveLoad:fromBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveLoadUInt8FromExternalAddress */
static sqInt
genPrimitiveLoadUInt8FromExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;

	/* begin genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
	/* end MoveR:R: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, TempReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, TempReg, Arg1Reg);
	/* end AddR:R: */
	{
		/* begin MoveMb:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMbrR, 0, Arg1Reg, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMb:r:R: */
		genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
	}
	jmpTarget(_jumpImmediate, jmpTarget(_jumpBadIndex, jmpTarget(_jumpNonExternalAddress, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveLoadFromExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveObjectAt */
static sqInt
genPrimitiveObjectAt(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _headerReg;
	AbstractInstruction *_jumpBadIndex;
	AbstractInstruction *_jumpBounds;
	AbstractInstruction *_jumpNotHeaderIndex;
	sqInt _literal;
	sqInt _quickConstant;
	sqInt _quickConstant2;

	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genGetMethodHeaderOfintoscratch(ReceiverResultReg, (_headerReg = Arg1Reg), TempReg);
	/* begin checkQuickConstant:forInstruction: */
	_literal = ((((usqInt) 1 ) << 3) | 1);
	_anInstruction3 = genoperandoperand(CmpCqR, ((((usqInt) 1 ) << 3) | 1), Arg0Reg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_literal));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpNonZero: */
	_jumpNotHeaderIndex = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, _headerReg, ReceiverResultReg);
		/* end MoveR:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
	}
	jmpTarget(_jumpNotHeaderIndex, gAndCqR(((((usqInt) (alternateHeaderNumLiteralsMask()) ) << 3) | 1), _headerReg));
	{
		/* begin SubCq:R: */
		_quickConstant = (((((usqInt) 1 ) << 3) | 1)) - (smallIntegerTag());
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(SubCqR, _quickConstant, Arg0Reg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end SubCq:R: */
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, _headerReg, Arg0Reg);
		/* end CmpR:R: */
	}
	/* begin JumpAbove: */
	_jumpBounds = genConditionalBranchoperand(JumpAbove, ((sqInt) 0 ));
	/* end JumpAbove: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	{
		/* begin AddCq:R: */
		_quickConstant2 = ((usqInt) BaseHeaderSize ) >> (shiftForWord());
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(AddCqR, _quickConstant2, Arg0Reg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(_quickConstant2));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end AddCq:R: */
		/* begin MoveXwr:R:R: */
		genoperandoperandoperand(MoveXwrRR, Arg0Reg, ReceiverResultReg, ReceiverResultReg);
		/* end MoveXwr:R:R: */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		} else {
			{
				/* begin RetN: */
				genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
				/* end RetN: */
			}
		}
	}
	jmpTarget(_jumpBounds, gAddCqR((((((usqInt) 1 ) << 3) | 1)) - (smallIntegerTag()), Arg0Reg));
	jmpTarget(_jumpBadIndex, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return CompletePrimitive;
}
/*	c.f. StackInterpreter>>stSizeOf: lengthOf:baseHeader:format: 
	fixedFieldsOf:format:length:  */
/* CogObjectRepresentationForSpur>>#genPrimitiveSize */
static sqInt
genPrimitiveSize(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction10;
	AbstractInstruction *_anInstruction11;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction *_anInstruction7;
	AbstractInstruction *_anInstruction8;
	AbstractInstruction *_anInstruction9;
	AbstractInstruction * _jump32BitLongsDone;
	AbstractInstruction * _jump64BitLongsDone;
	AbstractInstruction * _jumpArrayDone;
	AbstractInstruction * _jumpBytesDone;
	AbstractInstruction * _jumpHasFixedFields;
	AbstractInstruction *_jumpImm;
	AbstractInstruction * _jumpIs32BitLongs;
	AbstractInstruction * _jumpIsBytes;
	AbstractInstruction *_jumpIsContext;
	AbstractInstruction * _jumpIsContext2;
	AbstractInstruction * _jumpIsShorts;
	AbstractInstruction *_jumpNotIndexable;
	AbstractInstruction * _jumpNotIndexable2;
	AbstractInstruction * _jumpShortsDone;
	sqInt _quickConstant;
	sqInt _quickConstant2;
	sqInt _quickConstant3;
	sqInt _quickConstant4;
	sqInt _quickConstant5;
	sqInt _quickConstant6;
	sqInt _quickConstant7;

	_jumpImm = genJumpImmediate(ReceiverResultReg);
	/* begin genGetSizeOf:into:formatReg:scratchReg:abortJumpsInto: */
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, SendNumArgsReg, TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, ClassReg);
	/* begin CmpCq:R: */
	_quickConstant2 = firstByteFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant2, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpGreaterOrEqual: */
	_jumpIsBytes = genConditionalBranchoperand(JumpGreaterOrEqual, ((sqInt) 0 ));
	/* end JumpGreaterOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant3 = arrayFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant3, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant3));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpZero: */
	_jumpArrayDone = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* begin JumpLess: */
	_jumpNotIndexable2 = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
	/* end JumpLess: */
	/* begin CmpCq:R: */
	_quickConstant4 = weakArrayFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(CmpCqR, _quickConstant4, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(_quickConstant4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpLessOrEqual: */
	_jumpHasFixedFields = genConditionalBranchoperand(JumpLessOrEqual, ((sqInt) 0 ));
	/* end JumpLessOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant5 = firstShortFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction5 = genoperandoperand(CmpCqR, _quickConstant5, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction5)) {
		(_anInstruction5->dependent = locateLiteral(_quickConstant5));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpGreaterOrEqual: */
	_jumpIsShorts = genConditionalBranchoperand(JumpGreaterOrEqual, ((sqInt) 0 ));
	/* end JumpGreaterOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant6 = firstLongFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction6 = genoperandoperand(CmpCqR, _quickConstant6, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction6)) {
		(_anInstruction6->dependent = locateLiteral(_quickConstant6));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpGreaterOrEqual: */
	_jumpIs32BitLongs = genConditionalBranchoperand(JumpGreaterOrEqual, ((sqInt) 0 ));
	/* end JumpGreaterOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant7 = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction7 = genoperandoperand(CmpCqR, _quickConstant7, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction7)) {
		(_anInstruction7->dependent = locateLiteral(_quickConstant7));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpZero: */
	_jump64BitLongsDone = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	jmpTarget(_jumpNotIndexable2, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	/* begin Jump: */
	_jumpNotIndexable2 = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpIsBytes, gLogicalShiftLeftCqR(shiftForWord(), ClassReg));
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction8 = genoperandoperand(AndCqR, BytesPerWord - 1, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction8)) {
		(_anInstruction8->dependent = locateLiteral(BytesPerWord - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, SendNumArgsReg, ClassReg);
	/* end SubR:R: */
	/* begin Jump: */
	_jumpBytesDone = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpIsShorts, gLogicalShiftLeftCqR((shiftForWord()) - 1, ClassReg));
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction9 = genoperandoperand(AndCqR, (((usqInt) BytesPerWord ) >> 1) - 1, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction9)) {
		(_anInstruction9->dependent = locateLiteral((((usqInt) BytesPerWord ) >> 1) - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, SendNumArgsReg, ClassReg);
	/* end SubR:R: */
	/* begin Jump: */
	_jumpShortsDone = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpIs32BitLongs, gLogicalShiftLeftCqR((shiftForWord()) - 2, ClassReg));
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction10 = genoperandoperand(AndCqR, (((usqInt) BytesPerWord ) >> 2) - 1, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction10)) {
		(_anInstruction10->dependent = locateLiteral((((usqInt) BytesPerWord ) >> 2) - 1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, SendNumArgsReg, ClassReg);
	/* end SubR:R: */
	/* begin Jump: */
	_jump32BitLongsDone = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpHasFixedFields, gAndCqR(classIndexMask(), TempReg));
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, TempReg, SendNumArgsReg);
	/* end MoveR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction11 = genoperandoperand(CmpCqR, ClassMethodContextCompactIndex, TempReg);
	if (usesOutOfLineLiteral(_anInstruction11)) {
		(_anInstruction11->dependent = locateLiteral(ClassMethodContextCompactIndex));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpZero: */
	_jumpIsContext2 = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	genGetClassObjectOfClassIndexintoscratchReg(SendNumArgsReg, Extra0Reg, TempReg);
	genLoadSlotsourceRegdestReg(InstanceSpecificationIndex, Extra0Reg, SendNumArgsReg);
	genConvertSmallIntegerToIntegerInReg(SendNumArgsReg);
	{
		/* begin AndCq:R: */
		_quickConstant = fixedFieldsOfClassFormatMask();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(AndCqR, _quickConstant, SendNumArgsReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end AndCq:R: */
		/* begin SubR:R: */
		genoperandoperand(SubRR, SendNumArgsReg, ClassReg);
		/* end SubR:R: */
	}
	jmpTarget(_jumpArrayDone, jmpTarget(_jump64BitLongsDone, jmpTarget(_jump32BitLongsDone, jmpTarget(_jumpShortsDone, jmpTarget(_jumpBytesDone, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	{
		_jumpNotIndexable = _jumpNotIndexable2;
		_jumpIsContext = _jumpIsContext2;
	}
	/* end genGetSizeOf:into:formatReg:scratchReg:abortJumpsInto: */
	genConvertIntegerToSmallIntegerInReg(ClassReg);
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, ClassReg, ReceiverResultReg);
	/* end MoveR:R: */
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpImm, jmpTarget(_jumpNotIndexable, jmpTarget(_jumpIsContext, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreBoolean8IntoBytes */
static sqInt
genPrimitiveStoreBoolean8IntoBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction32;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction42;
	sqInt _destPointerRegister;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpNotBooleanObject;
	AbstractInstruction * _jumpNotTrueObject;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveStore:intoBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction22 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction22)) {
		(_anInstruction22->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction32 = genoperandoperand(CmpCqR, 1, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction32)) {
		(_anInstruction32->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg0Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, _destPointerRegister);
	/* end MoveR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, ClassReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction42 = genoperandoperand(AddCqR, BaseHeaderSize, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction42)) {
		(_anInstruction42->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		annotateobjRef(gCmpCwR(trueObject(), Arg1Reg), trueObject());
		/* begin JumpNonZero: */
		_jumpNotTrueObject = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		/* begin MoveCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, 1, TempReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(1));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveCq:R: */
		/* begin MoveR:M8:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperandoperand(MoveRM8r, TempReg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M8:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNotTrueObject, annotateobjRef(gCmpCwR(falseObject(), Arg1Reg), falseObject()));
		/* begin JumpNonZero: */
		_jumpNotBooleanObject = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		/* begin MoveCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperand(MoveCqR, 0, TempReg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveCq:R: */
		/* begin MoveR:M8:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction4 = genoperandoperandoperand(MoveRM8r, TempReg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction4)) {
			(_anInstruction4->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M8:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNotBooleanObject, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
	/* end genPrimitiveStore:intoBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreBoolean8IntoExternalAddress */
static sqInt
genPrimitiveStoreBoolean8IntoExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _destPointerRegister;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	AbstractInstruction * _jumpNotBooleanObject;
	AbstractInstruction * _jumpNotTrueObject;
	sqInt _quickConstant;

	/* begin genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction5 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction5)) {
		(_anInstruction5->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction22 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, _destPointerRegister);
	if (usesOutOfLineLiteral(_anInstruction22)) {
		(_anInstruction22->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, _destPointerRegister);
	/* end AddR:R: */
	{
		annotateobjRef(gCmpCwR(trueObject(), Arg1Reg), trueObject());
		/* begin JumpNonZero: */
		_jumpNotTrueObject = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		/* begin MoveCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, 1, TempReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(1));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveCq:R: */
		/* begin MoveR:M8:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperandoperand(MoveRM8r, TempReg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M8:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNotTrueObject, annotateobjRef(gCmpCwR(falseObject(), Arg1Reg), falseObject()));
		/* begin JumpNonZero: */
		_jumpNotBooleanObject = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		/* begin MoveCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperand(MoveCqR, 0, TempReg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveCq:R: */
		/* begin MoveR:M8:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction4 = genoperandoperandoperand(MoveRM8r, TempReg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction4)) {
			(_anInstruction4->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M8:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNotBooleanObject, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpNonExternalAddress, jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreChar16IntoBytes */
static sqInt
genPrimitiveStoreChar16IntoBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _destPointerRegister;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpNonCharacter;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveStore:intoBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 2, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 2 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(2 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg0Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, _destPointerRegister);
	/* end MoveR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, ClassReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, TempReg);
		/* end MoveR:R: */
		/* begin genJumpNotCharacterInScratchReg: */
		_jumpNonCharacter = genJumpNotCharacter(TempReg);
		/* end genJumpNotCharacterInScratchReg: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertCharacterToCodeInReg(Arg1Reg);
		/* begin MoveR:M16:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveRM16r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M16:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonCharacter, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
	/* end genPrimitiveStore:intoBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreChar16IntoExternalAddress */
static sqInt
genPrimitiveStoreChar16IntoExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _destPointerRegister;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonCharacter;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;

	/* begin genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, _destPointerRegister);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, _destPointerRegister);
	/* end AddR:R: */
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, TempReg);
		/* end MoveR:R: */
		/* begin genJumpNotCharacterInScratchReg: */
		_jumpNonCharacter = genJumpNotCharacter(TempReg);
		/* end genJumpNotCharacterInScratchReg: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertCharacterToCodeInReg(Arg1Reg);
		/* begin MoveR:M16:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveRM16r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M16:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonCharacter, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpNonExternalAddress, jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreChar32IntoBytes */
static sqInt
genPrimitiveStoreChar32IntoBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _destPointerRegister;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpNonCharacter;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveStore:intoBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 4, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 4 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(4 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg0Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, _destPointerRegister);
	/* end MoveR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, ClassReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, TempReg);
		/* end MoveR:R: */
		/* begin genJumpNotCharacterInScratchReg: */
		_jumpNonCharacter = genJumpNotCharacter(TempReg);
		/* end genJumpNotCharacterInScratchReg: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertCharacterToCodeInReg(Arg1Reg);
		/* begin MoveR:M32:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveRM32r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M32:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonCharacter, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
	/* end genPrimitiveStore:intoBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreChar32IntoExternalAddress */
static sqInt
genPrimitiveStoreChar32IntoExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _destPointerRegister;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonCharacter;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;

	/* begin genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, _destPointerRegister);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, _destPointerRegister);
	/* end AddR:R: */
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, TempReg);
		/* end MoveR:R: */
		/* begin genJumpNotCharacterInScratchReg: */
		_jumpNonCharacter = genJumpNotCharacter(TempReg);
		/* end genJumpNotCharacterInScratchReg: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertCharacterToCodeInReg(Arg1Reg);
		/* begin MoveR:M32:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveRM32r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M32:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonCharacter, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpNonExternalAddress, jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreChar8IntoBytes */
static sqInt
genPrimitiveStoreChar8IntoBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	sqInt _destPointerRegister;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpNonCharacter;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveStore:intoBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 1, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg0Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, _destPointerRegister);
	/* end MoveR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, ClassReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, TempReg);
		/* end MoveR:R: */
		/* begin genJumpNotCharacterInScratchReg: */
		_jumpNonCharacter = genJumpNotCharacter(TempReg);
		/* end genJumpNotCharacterInScratchReg: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertCharacterToCodeInReg(Arg1Reg);
		/* begin MoveR:M8:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveRM8r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M8:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonCharacter, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
	/* end genPrimitiveStore:intoBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreChar8IntoExternalAddress */
static sqInt
genPrimitiveStoreChar8IntoExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _destPointerRegister;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonCharacter;
	AbstractInstruction * _jumpNonExternalAddress;
	sqInt _quickConstant;

	/* begin genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, _destPointerRegister);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, _destPointerRegister);
	/* end AddR:R: */
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, TempReg);
		/* end MoveR:R: */
		/* begin genJumpNotCharacterInScratchReg: */
		_jumpNonCharacter = genJumpNotCharacter(TempReg);
		/* end genJumpNotCharacterInScratchReg: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertCharacterToCodeInReg(Arg1Reg);
		/* begin MoveR:M8:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveRM8r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M8:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonCharacter, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpNonExternalAddress, jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreFloat32IntoBytes */
static sqInt
genPrimitiveStoreFloat32IntoBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _destPointerRegister;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpNonFloat;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveStore:intoBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 4, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 4 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(4 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg0Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, _destPointerRegister);
	/* end MoveR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, ClassReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		_jumpNonFloat = genBoxedOrSmallFloatscratchReginto(Arg1Reg, TempReg, DPFPReg0);
		/* begin ConvertRd:Rs: */
		genoperandoperand(ConvertRdRs, DPFPReg0, DPFPReg0);
		/* end ConvertRd:Rs: */
		/* begin MoveRs:M32:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveRsM32r, DPFPReg0, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveRs:M32:r: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonFloat, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
	/* end genPrimitiveStore:intoBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreFloat32IntoExternalAddress */
static sqInt
genPrimitiveStoreFloat32IntoExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _destPointerRegister;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	AbstractInstruction * _jumpNonFloat;
	sqInt _quickConstant;

	/* begin genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, _destPointerRegister);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, _destPointerRegister);
	/* end AddR:R: */
	{
		_jumpNonFloat = genBoxedOrSmallFloatscratchReginto(Arg1Reg, TempReg, DPFPReg0);
		/* begin ConvertRd:Rs: */
		genoperandoperand(ConvertRdRs, DPFPReg0, DPFPReg0);
		/* end ConvertRd:Rs: */
		/* begin MoveRs:M32:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveRsM32r, DPFPReg0, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveRs:M32:r: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonFloat, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpNonExternalAddress, jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreFloat64IntoBytes */
static sqInt
genPrimitiveStoreFloat64IntoBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _destPointerRegister;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpNonFloat;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveStore:intoBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 8, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(8));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 8 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(8 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg0Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, _destPointerRegister);
	/* end MoveR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, ClassReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		_jumpNonFloat = genBoxedOrSmallFloatscratchReginto(Arg1Reg, TempReg, DPFPReg0);
		/* begin MoveRd:M64:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveRdM64r, DPFPReg0, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveRd:M64:r: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonFloat, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
	/* end genPrimitiveStore:intoBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreFloat64IntoExternalAddress */
static sqInt
genPrimitiveStoreFloat64IntoExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _destPointerRegister;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	AbstractInstruction * _jumpNonFloat;
	sqInt _quickConstant;

	/* begin genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, _destPointerRegister);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, _destPointerRegister);
	/* end AddR:R: */
	{
		_jumpNonFloat = genBoxedOrSmallFloatscratchReginto(Arg1Reg, TempReg, DPFPReg0);
		/* begin MoveRd:M64:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveRdM64r, DPFPReg0, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveRd:M64:r: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonFloat, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpNonExternalAddress, jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreInt16IntoBytes */
static sqInt
genPrimitiveStoreInt16IntoBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _destPointerRegister;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpNonSmallInteger;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveStore:intoBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 2, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 2 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(2 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg0Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, _destPointerRegister);
	/* end MoveR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, ClassReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin genJumpNotSmallInteger:scratchReg: */
		_jumpNonSmallInteger = genJumpNotSmallInteger(Arg1Reg);
		/* end genJumpNotSmallInteger:scratchReg: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertSmallIntegerToIntegerInReg(Arg1Reg);
		/* begin MoveR:M16:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveRM16r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M16:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonSmallInteger, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
	/* end genPrimitiveStore:intoBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreInt16IntoExternalAddress */
static sqInt
genPrimitiveStoreInt16IntoExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _destPointerRegister;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	AbstractInstruction * _jumpNonSmallInteger;
	sqInt _quickConstant;

	/* begin genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, _destPointerRegister);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, _destPointerRegister);
	/* end AddR:R: */
	{
		/* begin genJumpNotSmallInteger:scratchReg: */
		_jumpNonSmallInteger = genJumpNotSmallInteger(Arg1Reg);
		/* end genJumpNotSmallInteger:scratchReg: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertSmallIntegerToIntegerInReg(Arg1Reg);
		/* begin MoveR:M16:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveRM16r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M16:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonSmallInteger, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpNonExternalAddress, jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreInt8IntoBytes */
static sqInt
genPrimitiveStoreInt8IntoBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	sqInt _destPointerRegister;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpNonSmallInteger;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveStore:intoBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 1, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg0Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, _destPointerRegister);
	/* end MoveR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, ClassReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin genJumpNotSmallInteger:scratchReg: */
		_jumpNonSmallInteger = genJumpNotSmallInteger(Arg1Reg);
		/* end genJumpNotSmallInteger:scratchReg: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertSmallIntegerToIntegerInReg(Arg1Reg);
		/* begin MoveR:M8:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveRM8r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M8:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonSmallInteger, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
	/* end genPrimitiveStore:intoBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreInt8IntoExternalAddress */
static sqInt
genPrimitiveStoreInt8IntoExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _destPointerRegister;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNonExternalAddress;
	AbstractInstruction * _jumpNonSmallInteger;
	sqInt _quickConstant;

	/* begin genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, _destPointerRegister);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, _destPointerRegister);
	/* end AddR:R: */
	{
		/* begin genJumpNotSmallInteger:scratchReg: */
		_jumpNonSmallInteger = genJumpNotSmallInteger(Arg1Reg);
		/* end genJumpNotSmallInteger:scratchReg: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertSmallIntegerToIntegerInReg(Arg1Reg);
		/* begin MoveR:M8:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveRM8r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M8:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonSmallInteger, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpNonExternalAddress, jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStorePointerIntoBytes */
static sqInt
genPrimitiveStorePointerIntoBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction32;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _destPointerRegister;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpImmediate2;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpNonExternalAddress;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;
	sqInt _quickConstant2;

	/* begin genPrimitiveStore:intoBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate2 = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant2 = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction22 = genoperandoperand(CmpCqR, _quickConstant2, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction22)) {
		(_anInstruction22->dependent = locateLiteral(_quickConstant2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction32 = genoperandoperand(CmpCqR, BytesPerWord, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction32)) {
		(_anInstruction32->dependent = locateLiteral(BytesPerWord));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, BytesPerWord - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(BytesPerWord - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg0Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, _destPointerRegister);
	/* end MoveR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, ClassReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		_jumpImmediate = genJumpImmediate(Arg1Reg);
		genGetCompactClassIndexNonImmOfinto(Arg1Reg, TempReg);
		/* begin CmpCq:R: */
		_quickConstant = classExternalAddressIndex();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, _quickConstant, TempReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpNonZero: */
		_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		/* begin MoveMw:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, Arg1Reg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
		/* begin MoveR:Mw:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperandoperand(MoveRMwr, TempReg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:Mw:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonExternalAddress, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	}
	jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate2, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
	/* end genPrimitiveStore:intoBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStorePointerIntoExternalAddress */
static sqInt
genPrimitiveStorePointerIntoExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	sqInt _destPointerRegister;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpImmediate2;
	AbstractInstruction * _jumpNonExternalAddress;
	AbstractInstruction * _jumpNonExternalAddress2;
	sqInt _quickConstant;
	sqInt _quickConstant2;

	/* begin genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate2 = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant2 = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(CmpCqR, _quickConstant2, TempReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(_quickConstant2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress2 = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction22 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, _destPointerRegister);
	if (usesOutOfLineLiteral(_anInstruction22)) {
		(_anInstruction22->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, _destPointerRegister);
	/* end AddR:R: */
	{
		_jumpImmediate = genJumpImmediate(Arg1Reg);
		genGetCompactClassIndexNonImmOfinto(Arg1Reg, TempReg);
		/* begin CmpCq:R: */
		_quickConstant = classExternalAddressIndex();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, _quickConstant, TempReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpNonZero: */
		_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		/* begin MoveMw:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, Arg1Reg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(BaseHeaderSize));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
		/* begin MoveR:Mw:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperandoperand(MoveRMwr, TempReg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:Mw:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonExternalAddress, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	}
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpNonExternalAddress2, jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate2, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreUInt16IntoBytes */
static sqInt
genPrimitiveStoreUInt16IntoBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _destPointerRegister;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpNegative;
	AbstractInstruction * _jumpNonSmallInteger;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveStore:intoBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction22 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction22)) {
		(_anInstruction22->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 2, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(SubCqR, 2 - 1, _nSlotsOrBytesReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(2 - 1));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg0Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, _destPointerRegister);
	/* end MoveR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, ClassReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin genJumpNotSmallInteger:scratchReg: */
		_jumpNonSmallInteger = genJumpNotSmallInteger(Arg1Reg);
		/* end genJumpNotSmallInteger:scratchReg: */
		/* begin CmpCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, 0, Arg1Reg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpLess: */
		_jumpNegative = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
		/* end JumpLess: */
		genConvertSmallIntegerToIntegerInReg(Arg1Reg);
		/* begin MoveR:M16:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperandoperand(MoveRM16r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M16:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonSmallInteger, jmpTarget(_jumpNegative, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	}
	jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
	/* end genPrimitiveStore:intoBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreUInt16IntoExternalAddress */
static sqInt
genPrimitiveStoreUInt16IntoExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	sqInt _destPointerRegister;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNegative;
	AbstractInstruction * _jumpNonExternalAddress;
	AbstractInstruction * _jumpNonSmallInteger;
	sqInt _quickConstant;

	/* begin genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction22 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, _destPointerRegister);
	if (usesOutOfLineLiteral(_anInstruction22)) {
		(_anInstruction22->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, _destPointerRegister);
	/* end AddR:R: */
	{
		/* begin genJumpNotSmallInteger:scratchReg: */
		_jumpNonSmallInteger = genJumpNotSmallInteger(Arg1Reg);
		/* end genJumpNotSmallInteger:scratchReg: */
		/* begin CmpCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, 0, Arg1Reg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpLess: */
		_jumpNegative = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
		/* end JumpLess: */
		genConvertSmallIntegerToIntegerInReg(Arg1Reg);
		/* begin MoveR:M16:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperandoperand(MoveRM16r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M16:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonSmallInteger, jmpTarget(_jumpNegative, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	}
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpNonExternalAddress, jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreUInt8IntoBytes */
static sqInt
genPrimitiveStoreUInt8IntoBytes(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	sqInt _destPointerRegister;
	sqInt _formatReg;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpIsPointers;
	AbstractInstruction * _jumpNegative;
	AbstractInstruction * _jumpNonSmallInteger;
	AbstractInstruction * _jumpOutOfBounds;
	AbstractInstruction * _jumpSmaller;
	sqInt _nSlotsOrBytesReg;
	sqInt _quickConstant;

	/* begin genPrimitiveStore:intoBytesWith:needsToTrap: */
	_nSlotsOrBytesReg = ClassReg;
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	genGetFormatOfintoleastSignificantHalfOfBaseHeaderIntoScratch(ReceiverResultReg, (_formatReg = SendNumArgsReg), TempReg);
	genGetNumSlotsOfinto(ReceiverResultReg, _nSlotsOrBytesReg);
	/* begin CmpCq:R: */
	_quickConstant = sixtyFourBitIndexableFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction22 = genoperandoperand(CmpCqR, _quickConstant, _formatReg);
	if (usesOutOfLineLiteral(_anInstruction22)) {
		(_anInstruction22->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_jumpIsPointers = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	genConvertDataFormatnumSlotsintoBytes(_formatReg, _nSlotsOrBytesReg, _nSlotsOrBytesReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, 1, _nSlotsOrBytesReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpBelow: */
	_jumpSmaller = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _nSlotsOrBytesReg, Arg0Reg);
	/* end CmpR:R: */
	/* begin JumpAboveOrEqual: */
	_jumpOutOfBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, Arg0Reg, _destPointerRegister);
	/* end MoveR:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, ReceiverResultReg, ClassReg);
	/* end AddR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(AddCqR, BaseHeaderSize, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	{
		/* begin genJumpNotSmallInteger:scratchReg: */
		_jumpNonSmallInteger = genJumpNotSmallInteger(Arg1Reg);
		/* end genJumpNotSmallInteger:scratchReg: */
		/* begin CmpCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, 0, Arg1Reg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpLess: */
		_jumpNegative = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
		/* end JumpLess: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertSmallIntegerToIntegerInReg(Arg1Reg);
		/* begin MoveR:M8:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperandoperand(MoveRM8r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M8:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonSmallInteger, jmpTarget(_jumpNegative, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	}
	jmpTarget(_jumpIsPointers, jmpTarget(_jumpSmaller, jmpTarget(_jumpOutOfBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return CompletePrimitive;
	/* end genPrimitiveStore:intoBytesWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStoreUInt8IntoExternalAddress */
static sqInt
genPrimitiveStoreUInt8IntoExternalAddress(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction3;
	sqInt _destPointerRegister;
	AbstractInstruction * _jumpBadIndex;
	AbstractInstruction * _jumpImmediate;
	AbstractInstruction * _jumpNegative;
	AbstractInstruction * _jumpNonExternalAddress;
	AbstractInstruction * _jumpNonSmallInteger;
	sqInt _quickConstant;

	/* begin genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
	_destPointerRegister = ClassReg;
	/* begin genLoadArgAtDepth:into: */
	assert(1 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	_jumpImmediate = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = classExternalAddressIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpNonZero: */
	_jumpNonExternalAddress = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpBadIndex = genJumpNotSmallInteger(Arg0Reg);
	/* end genJumpNotSmallInteger:scratchReg: */
	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction22 = genoperandoperandoperand(MoveMwrR, BaseHeaderSize, ReceiverResultReg, _destPointerRegister);
	if (usesOutOfLineLiteral(_anInstruction22)) {
		(_anInstruction22->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, Arg0Reg, _destPointerRegister);
	/* end AddR:R: */
	{
		/* begin genJumpNotSmallInteger:scratchReg: */
		_jumpNonSmallInteger = genJumpNotSmallInteger(Arg1Reg);
		/* end genJumpNotSmallInteger:scratchReg: */
		/* begin CmpCq:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, 0, Arg1Reg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpLess: */
		_jumpNegative = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
		/* end JumpLess: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg1Reg, ReceiverResultReg);
		/* end MoveR:R: */
		genConvertSmallIntegerToIntegerInReg(Arg1Reg);
		/* begin MoveR:M8:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperandoperand(MoveRM8r, Arg1Reg, 0, _destPointerRegister);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:M8:r: */
		/* begin genPrimReturn */
		if (methodOrBlockNumArgs <= 2) {
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
 else {
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
		/* end genPrimReturn */
		jmpTarget(_jumpNonSmallInteger, jmpTarget(_jumpNegative, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	}
	genConvertIntegerToSmallIntegerInReg(Arg0Reg);
	jmpTarget(_jumpNonExternalAddress, jmpTarget(_jumpBadIndex, jmpTarget(_jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
	return CompletePrimitive;
	/* end genPrimitiveStoreIntoExternalAddressWith:needsToTrap: */
}
/* CogObjectRepresentationForSpur>>#genPrimitiveStringCompareWith */
static sqInt
genPrimitiveStringCompareWith(void)
{
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction *_anInstruction7;
	AbstractInstruction *_anInstruction8;
	AbstractInstruction *_anInstruction9;
	AbstractInstruction * _instr;
	AbstractInstruction *_jump;
	AbstractInstruction *_jumpAbove;
	AbstractInstruction *_jumpIncorrectFormat1;
	AbstractInstruction *_jumpIncorrectFormat2;
	AbstractInstruction *_jumpIncorrectFormat3;
	AbstractInstruction *_jumpIncorrectFormat4;
	AbstractInstruction *_jumpMidFailure;
	AbstractInstruction *_jumpSuccess;
	sqInt _minSizeReg;
	sqInt _quickConstant;
	sqInt _quickConstant2;
	sqInt _quickConstant3;
	sqInt _quickConstant4;
	sqInt _string1CharOrByteSizeReg;
	sqInt _string1Reg;
	sqInt _string2CharOrByteSizeReg;
	sqInt _string2Reg;

	_string1Reg = ReceiverResultReg;
	_string2Reg = Arg0Reg;
	_string1CharOrByteSizeReg = Arg1Reg;
	_string2CharOrByteSizeReg = ClassReg;
	_minSizeReg = SendNumArgsReg;
	/* begin genLoadArgAtDepth:into: */
	assert(0 < (numRegArgs()));
	/* end genLoadArgAtDepth:into: */
	genGetFormatOfinto(_string1Reg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant = firstByteFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpLess: */
	_jumpIncorrectFormat1 = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
	/* end JumpLess: */
	/* begin CmpCq:R: */
	_quickConstant2 = firstCompiledMethodFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(CmpCqR, _quickConstant2, TempReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(_quickConstant2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpIncorrectFormat2 = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	genGetNumSlotsOfinto(_string1Reg, _string1CharOrByteSizeReg);
	/* begin LogicalShiftLeftCq:R: */
	genoperandoperand(LogicalShiftLeftCqR, shiftForWord(), _string1CharOrByteSizeReg);
	/* end LogicalShiftLeftCq:R: */
	gAndCqRR(BytesPerWord - 1, TempReg, TempReg);
	/* begin SubR:R: */
	genoperandoperand(SubRR, TempReg, _string1CharOrByteSizeReg);
	/* end SubR:R: */
	genGetFormatOfinto(_string2Reg, TempReg);
	/* begin CmpCq:R: */
	_quickConstant3 = firstByteFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction5 = genoperandoperand(CmpCqR, _quickConstant3, TempReg);
	if (usesOutOfLineLiteral(_anInstruction5)) {
		(_anInstruction5->dependent = locateLiteral(_quickConstant3));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpLess: */
	_jumpIncorrectFormat3 = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
	/* end JumpLess: */
	/* begin CmpCq:R: */
	_quickConstant4 = firstCompiledMethodFormat();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction6 = genoperandoperand(CmpCqR, _quickConstant4, TempReg);
	if (usesOutOfLineLiteral(_anInstruction6)) {
		(_anInstruction6->dependent = locateLiteral(_quickConstant4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_jumpIncorrectFormat4 = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	genGetNumSlotsOfinto(_string2Reg, _string2CharOrByteSizeReg);
	/* begin LogicalShiftLeftCq:R: */
	genoperandoperand(LogicalShiftLeftCqR, shiftForWord(), _string2CharOrByteSizeReg);
	/* end LogicalShiftLeftCq:R: */
	gAndCqRR(BytesPerWord - 1, TempReg, TempReg);
	/* begin SubR:R: */
	genoperandoperand(SubRR, TempReg, _string2CharOrByteSizeReg);
	/* end SubR:R: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _string1CharOrByteSizeReg, _string2CharOrByteSizeReg);
	/* end CmpR:R: */
	/* begin JumpBelow: */
	_jumpAbove = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, _string1CharOrByteSizeReg, _minSizeReg);
	/* end MoveR:R: */
	/* begin Jump: */
	_jump = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpAbove, genoperandoperand(MoveRR, _string2CharOrByteSizeReg, _minSizeReg));
	jmpTarget(_jump, checkQuickConstantforInstruction(0, genoperandoperand(CmpCqR, 0, _minSizeReg)));
	/* begin JumpZero: */
	_jumpSuccess = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction7 = genoperandoperand(MoveCqR, BaseHeaderSize, TempReg);
	if (usesOutOfLineLiteral(_anInstruction7)) {
		(_anInstruction7->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction8 = genoperandoperand(AddCqR, BaseHeaderSize, _minSizeReg);
	if (usesOutOfLineLiteral(_anInstruction8)) {
		(_anInstruction8->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin MoveXbr:R:R: */
	_instr = genoperandoperandoperand(MoveXbrRR, TempReg, _string1Reg, _string1CharOrByteSizeReg);
	/* end MoveXbr:R:R: */
	/* begin MoveXbr:R:R: */
	genoperandoperandoperand(MoveXbrRR, TempReg, _string2Reg, _string2CharOrByteSizeReg);
	/* end MoveXbr:R:R: */
	/* begin SubR:R: */
	genoperandoperand(SubRR, _string2CharOrByteSizeReg, _string1CharOrByteSizeReg);
	/* end SubR:R: */
	/* begin JumpNonZero: */
	_jumpMidFailure = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction9 = genoperandoperand(AddCqR, 1, TempReg);
	if (usesOutOfLineLiteral(_anInstruction9)) {
		(_anInstruction9->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, TempReg, _minSizeReg);
	/* end CmpR:R: */
	/* begin JumpNonZero: */
	genConditionalBranchoperand(JumpNonZero, ((sqInt) _instr ));
	/* end JumpNonZero: */
	genGetNumBytesOfinto(_string1Reg, _string1CharOrByteSizeReg);
	genGetNumBytesOfinto(_string2Reg, _string2CharOrByteSizeReg);
	jmpTarget(_jumpSuccess, genoperandoperand(SubRR, _string2CharOrByteSizeReg, _string1CharOrByteSizeReg));
	jmpTarget(_jumpMidFailure, genoperandoperand(MoveRR, _string1CharOrByteSizeReg, ReceiverResultReg));
	genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
	if (methodOrBlockNumArgs <= 2) {
		/* begin RetN: */
		genoperand(RetN, 0);
		/* end RetN: */
	} else {
		{
			/* begin RetN: */
			genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jumpIncorrectFormat4, jmpTarget(_jumpIncorrectFormat3, jmpTarget(_jumpIncorrectFormat2, jmpTarget(_jumpIncorrectFormat1, genoperandoperand(Label, (labelCounter += 1), bytecodePC)))));
	return CompletePrimitive;
}
/*	replaceFrom: start to: stop with: replacement startingAt: repStart.  
	 
	The primitive in the JIT tries to deal with two pathological cases, copy 
	of arrays and byteStrings, 
	which often copies only a dozen of fields and where switching to the C 
	runtime cost a lot. 
	 
	Based on heuristics on the method class, I generate a quick array path 
	(typically for Array), 
	a quick byteString path (typically for ByteString, ByteArray and 
	LargeInteger) or no quick  
	path at all (Typically for Bitmap). 
	 
	The many tests to ensure that the primitive won't fail are not super 
	optimised (multiple reloading 
	or stack arguments in registers) but this is still good enough and worth 
	it since we're avoiding  
	the Smalltalk to C stack switch. The tight copying loops are optimised.  
	 
	It is possible to build a bigger version with the 2 different paths but I 
	(Clement) believe this  
	is too big machine code wise to be worth it. */
/* CogObjectRepresentationForSpur>>#genPrimitiveStringReplace */
static sqInt
genPrimitiveStringReplace(void)
{
	sqInt _adjust;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction10;
	AbstractInstruction *_anInstruction11;
	AbstractInstruction *_anInstruction12;
	AbstractInstruction *_anInstruction13;
	AbstractInstruction *_anInstruction14;
	AbstractInstruction *_anInstruction15;
	AbstractInstruction *_anInstruction16;
	AbstractInstruction *_anInstruction17;
	AbstractInstruction *_anInstruction18;
	AbstractInstruction *_anInstruction19;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction20;
	AbstractInstruction *_anInstruction21;
	AbstractInstruction *_anInstruction22;
	AbstractInstruction *_anInstruction23;
	AbstractInstruction *_anInstruction24;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction *_anInstruction7;
	AbstractInstruction *_anInstruction8;
	AbstractInstruction *_anInstruction9;
	sqInt _arrayReg;
	AbstractInstruction * _inst;
	AbstractInstruction * _instr;
	AbstractInstruction *_jmpAlreadyRemembered;
	AbstractInstruction *_jmpDestYoung;
	AbstractInstruction *_jumpEmpty;
	AbstractInstruction *_jumpImm;
	AbstractInstruction *_jumpImmutable;
	AbstractInstruction *_jumpIncorrectFormat1;
	AbstractInstruction *_jumpIncorrectFormat2;
	AbstractInstruction *_jumpIncorrectFormat3;
	AbstractInstruction *_jumpIncorrectFormat4;
	AbstractInstruction *_jumpNotSmi1;
	AbstractInstruction *_jumpNotSmi2;
	AbstractInstruction *_jumpNotSmi3;
	AbstractInstruction *_jumpOutOfBounds1;
	AbstractInstruction *_jumpOutOfBounds2;
	AbstractInstruction *_jumpOutOfBounds3;
	AbstractInstruction *_jumpOutOfBounds4;
	sqInt _literal;
	sqInt _literal2;
	sqInt _offset;
	sqInt _offset10;
	sqInt _offset2;
	sqInt _offset3;
	sqInt _offset4;
	sqInt _offset5;
	sqInt _offset6;
	sqInt _offset7;
	sqInt _offset8;
	sqInt _offset9;
	sqInt _quickConstant;
	sqInt _quickConstant2;
	sqInt _quickConstant3;
	sqInt _quickConstant4;
	sqInt _quickConstant5;
	sqInt _quickConstant6;
	sqInt _replReg;
	sqInt _repStartReg;
	sqInt _result;
	sqInt _startReg;
	sqInt _stopReg;
	sqInt _wordConstant;

	_jmpAlreadyRemembered = ((AbstractInstruction *) 0 );
	_jumpImmutable = ((AbstractInstruction *) 0 );
	_jumpOutOfBounds3 = ((AbstractInstruction *) 0 );
	_jumpOutOfBounds4 = ((AbstractInstruction *) 0 );
	if (!((seemsToBeInstantiating(arrayFormat())) || (seemsToBeInstantiating(firstByteFormat())))) {
		return UnimplementedPrimitive;
	}
	_arrayReg = ReceiverResultReg;
	_startReg = Arg0Reg;
	_stopReg = Arg1Reg;
	_replReg = ClassReg;
	_repStartReg = SendNumArgsReg;
	/* begin genStackArgAt:into: */
	/* begin MoveMw:r:R: */
	_offset7 = 0 * BytesPerWord;
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction21 = genoperandoperandoperand(MoveMwrR, _offset7, SPReg, _repStartReg);
	if (usesOutOfLineLiteral(_anInstruction21)) {
		(_anInstruction21->dependent = locateLiteral(_offset7));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end MoveMw:r:R: */
	/* end genStackArgAt:into: */
	/* begin genStackArgAt:into: */
	/* begin MoveMw:r:R: */
	_offset8 = 1 * BytesPerWord;
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction22 = genoperandoperandoperand(MoveMwrR, _offset8, SPReg, _replReg);
	if (usesOutOfLineLiteral(_anInstruction22)) {
		(_anInstruction22->dependent = locateLiteral(_offset8));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end MoveMw:r:R: */
	/* end genStackArgAt:into: */
	/* begin genStackArgAt:into: */
	/* begin MoveMw:r:R: */
	_offset9 = 2 * BytesPerWord;
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction23 = genoperandoperandoperand(MoveMwrR, _offset9, SPReg, _stopReg);
	if (usesOutOfLineLiteral(_anInstruction23)) {
		(_anInstruction23->dependent = locateLiteral(_offset9));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end MoveMw:r:R: */
	/* end genStackArgAt:into: */
	/* begin genStackArgAt:into: */
	/* begin MoveMw:r:R: */
	_offset10 = 3 * BytesPerWord;
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction24 = genoperandoperandoperand(MoveMwrR, _offset10, SPReg, _startReg);
	if (usesOutOfLineLiteral(_anInstruction24)) {
		(_anInstruction24->dependent = locateLiteral(_offset10));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end MoveMw:r:R: */
	/* end genStackArgAt:into: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpNotSmi1 = genJumpNotSmallInteger(_repStartReg);
	/* end genJumpNotSmallInteger:scratchReg: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpNotSmi2 = genJumpNotSmallInteger(_stopReg);
	/* end genJumpNotSmallInteger:scratchReg: */
	/* begin genJumpNotSmallInteger:scratchReg: */
	_jumpNotSmi3 = genJumpNotSmallInteger(_startReg);
	/* end genJumpNotSmallInteger:scratchReg: */
	_jumpImm = genJumpImmediate(_replReg);
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _startReg, _stopReg);
	/* end CmpR:R: */
	/* begin JumpLess: */
	_jumpEmpty = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
	/* end JumpLess: */
	
#  if IMMUTABILITY
	{
		_jumpImmutable = genJumpImmutablescratchReg(ReceiverResultReg, TempReg);
	}
#  endif /* IMMUTABILITY */
	/* begin checkQuickConstant:forInstruction: */
	_literal = ((((usqInt) 0 ) << 3) | 1);
	_anInstruction13 = genoperandoperand(CmpCqR, ((((usqInt) 0 ) << 3) | 1), _startReg);
	if (usesOutOfLineLiteral(_anInstruction13)) {
		(_anInstruction13->dependent = locateLiteral(_literal));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpLessOrEqual: */
	_jumpOutOfBounds1 = genConditionalBranchoperand(JumpLessOrEqual, ((sqInt) 0 ));
	/* end JumpLessOrEqual: */
	/* begin checkQuickConstant:forInstruction: */
	_literal2 = ((((usqInt) 0 ) << 3) | 1);
	_anInstruction14 = genoperandoperand(CmpCqR, ((((usqInt) 0 ) << 3) | 1), _repStartReg);
	if (usesOutOfLineLiteral(_anInstruction14)) {
		(_anInstruction14->dependent = locateLiteral(_literal2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpLessOrEqual: */
	_jumpOutOfBounds2 = genConditionalBranchoperand(JumpLessOrEqual, ((sqInt) 0 ));
	/* end JumpLessOrEqual: */
	if (seemsToBeInstantiating(arrayFormat())) {
		genGetFormatOfinto(_arrayReg, TempReg);
		genGetFormatOfinto(_replReg, _startReg);
		/* begin CmpCq:R: */
		_quickConstant = arrayFormat();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant, _startReg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpNonZero: */
		_jumpIncorrectFormat1 = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		/* begin CmpCq:R: */
		_quickConstant2 = arrayFormat();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction4 = genoperandoperand(CmpCqR, _quickConstant2, TempReg);
		if (usesOutOfLineLiteral(_anInstruction4)) {
			(_anInstruction4->dependent = locateLiteral(_quickConstant2));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpNonZero: */
		_jumpIncorrectFormat2 = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		genGetNumSlotsOfinto(_arrayReg, TempReg);
		genConvertSmallIntegerToIntegerInReg(_stopReg);
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, TempReg, _stopReg);
		/* end CmpR:R: */
		/* begin JumpGreater: */
		_jumpOutOfBounds3 = genConditionalBranchoperand(JumpGreater, ((sqInt) 0 ));
		/* end JumpGreater: */
		genGetNumSlotsOfinto(_replReg, TempReg);
		/* begin genStackArgAt:into: */
		/* begin MoveMw:r:R: */
		_offset = 3 * BytesPerWord;
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction15 = genoperandoperandoperand(MoveMwrR, _offset, SPReg, _startReg);
		if (usesOutOfLineLiteral(_anInstruction15)) {
			(_anInstruction15->dependent = locateLiteral(_offset));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
		/* end genStackArgAt:into: */
		genConvertSmallIntegerToIntegerInReg(_startReg);
		genConvertSmallIntegerToIntegerInReg(_repStartReg);
		/* begin SubR:R: */
		genoperandoperand(SubRR, _startReg, _stopReg);
		/* end SubR:R: */
		/* begin AddR:R: */
		genoperandoperand(AddRR, _repStartReg, _stopReg);
		/* end AddR:R: */
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, TempReg, _stopReg);
		/* end CmpR:R: */
		/* begin JumpGreater: */
		_jumpOutOfBounds4 = genConditionalBranchoperand(JumpGreater, ((sqInt) 0 ));
		/* end JumpGreater: */
		/* begin MoveCw:R: */
		_wordConstant = storeCheckBoundary();
		/* begin gen:literal:operand: */
		checkLiteralforInstruction(_wordConstant, genoperandoperand(MoveCwR, _wordConstant, TempReg));
		/* end gen:literal:operand: */
		/* end MoveCw:R: */
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, TempReg, _arrayReg);
		/* end CmpR:R: */
		/* begin JumpBelow: */
		_jmpDestYoung = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
		/* end JumpBelow: */
		if (!CheckRememberedInTrampoline) {
			_jmpAlreadyRemembered = genCheckRememberedBitOfscratch(_arrayReg, TempReg);
		}
		/* begin saveAndRestoreLinkRegAround: */
		_inst = genoperand(PushR, LinkReg);
		{
			callStoreCheckTrampoline();
		}
		genoperand(PopR, LinkReg);
		/* end saveAndRestoreLinkRegAround: */
		jmpTarget(_jmpDestYoung, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
		if (!CheckRememberedInTrampoline) {
			jmpTarget(_jmpAlreadyRemembered, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
		}
		/* begin genStackArgAt:into: */
		/* begin MoveMw:r:R: */
		_offset2 = 2 * BytesPerWord;
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction16 = genoperandoperandoperand(MoveMwrR, _offset2, SPReg, _stopReg);
		if (usesOutOfLineLiteral(_anInstruction16)) {
			(_anInstruction16->dependent = locateLiteral(_offset2));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
		/* end genStackArgAt:into: */
		genConvertSmallIntegerToIntegerInReg(_stopReg);
		/* begin SubR:R: */
		genoperandoperand(SubRR, _startReg, _repStartReg);
		/* end SubR:R: */
		/* begin LogicalShiftLeftCq:R: */
		genoperandoperand(LogicalShiftLeftCqR, shiftForWord(), _repStartReg);
		/* end LogicalShiftLeftCq:R: */
		/* begin AddR:R: */
		genoperandoperand(AddRR, _repStartReg, _replReg);
		/* end AddR:R: */
		_adjust = (((usqInt) BaseHeaderSize ) >> (shiftForWord())) - 1;
		if (_adjust != 0) {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperand(AddCqR, _adjust, _startReg);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(_adjust));
			}
			/* end checkQuickConstant:forInstruction: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction2 = genoperandoperand(AddCqR, _adjust, _stopReg);
			if (usesOutOfLineLiteral(_anInstruction2)) {
				(_anInstruction2->dependent = locateLiteral(_adjust));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		/* begin MoveXwr:R:R: */
		_instr = genoperandoperandoperand(MoveXwrRR, _startReg, _replReg, TempReg);
		/* end MoveXwr:R:R: */
		/* begin MoveR:Xwr:R: */
		genoperandoperandoperand(MoveRXwrR, TempReg, _startReg, _arrayReg);
		/* end MoveR:Xwr:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction5 = genoperandoperand(AddCqR, 1, _startReg);
		if (usesOutOfLineLiteral(_anInstruction5)) {
			(_anInstruction5->dependent = locateLiteral(1));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, _startReg, _stopReg);
		/* end CmpR:R: */
		/* begin JumpAboveOrEqual: */
		genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) _instr ));
		/* end JumpAboveOrEqual: */
		jmpTarget(_jumpEmpty, ((methodOrBlockNumArgs <= 2)
			 ? (/* begin RetN: */ genoperand(RetN, 0) /* end RetN: */)
			 : (/* begin RetN: */ genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord) /* end RetN: */)));
		jmpTarget(_jumpIncorrectFormat1, jmpTarget(_jumpIncorrectFormat2, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	}
	if (seemsToBeInstantiating(firstByteFormat())) {
		genGetFormatOfinto(_arrayReg, TempReg);
		genGetFormatOfinto(_replReg, _repStartReg);
		/* begin CmpCq:R: */
		_quickConstant3 = firstByteFormat();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction8 = genoperandoperand(CmpCqR, _quickConstant3, _repStartReg);
		if (usesOutOfLineLiteral(_anInstruction8)) {
			(_anInstruction8->dependent = locateLiteral(_quickConstant3));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpLess: */
		_jumpIncorrectFormat1 = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
		/* end JumpLess: */
		/* begin CmpCq:R: */
		_quickConstant4 = firstCompiledMethodFormat();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction9 = genoperandoperand(CmpCqR, _quickConstant4, _repStartReg);
		if (usesOutOfLineLiteral(_anInstruction9)) {
			(_anInstruction9->dependent = locateLiteral(_quickConstant4));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpGreaterOrEqual: */
		_jumpIncorrectFormat2 = genConditionalBranchoperand(JumpGreaterOrEqual, ((sqInt) 0 ));
		/* end JumpGreaterOrEqual: */
		/* begin CmpCq:R: */
		_quickConstant5 = firstByteFormat();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction10 = genoperandoperand(CmpCqR, _quickConstant5, TempReg);
		if (usesOutOfLineLiteral(_anInstruction10)) {
			(_anInstruction10->dependent = locateLiteral(_quickConstant5));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpLess: */
		_jumpIncorrectFormat3 = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
		/* end JumpLess: */
		/* begin CmpCq:R: */
		_quickConstant6 = firstCompiledMethodFormat();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction11 = genoperandoperand(CmpCqR, _quickConstant6, TempReg);
		if (usesOutOfLineLiteral(_anInstruction11)) {
			(_anInstruction11->dependent = locateLiteral(_quickConstant6));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpGreaterOrEqual: */
		_jumpIncorrectFormat4 = genConditionalBranchoperand(JumpGreaterOrEqual, ((sqInt) 0 ));
		/* end JumpGreaterOrEqual: */
		genGetNumSlotsOfinto(_arrayReg, _startReg);
		/* begin LogicalShiftLeftCq:R: */
		genoperandoperand(LogicalShiftLeftCqR, shiftForWord(), _startReg);
		/* end LogicalShiftLeftCq:R: */
		gAndCqRR(BytesPerWord - 1, TempReg, TempReg);
		/* begin SubR:R: */
		genoperandoperand(SubRR, TempReg, _startReg);
		/* end SubR:R: */
		genConvertSmallIntegerToIntegerInReg(_stopReg);
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, _startReg, _stopReg);
		/* end CmpR:R: */
		/* begin JumpGreater: */
		_jumpOutOfBounds3 = genConditionalBranchoperand(JumpGreater, ((sqInt) 0 ));
		/* end JumpGreater: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, _repStartReg, TempReg);
		/* end MoveR:R: */
		/* begin genStackArgAt:into: */
		/* begin MoveMw:r:R: */
		_offset3 = 0 * BytesPerWord;
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction17 = genoperandoperandoperand(MoveMwrR, _offset3, SPReg, _repStartReg);
		if (usesOutOfLineLiteral(_anInstruction17)) {
			(_anInstruction17->dependent = locateLiteral(_offset3));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
		/* end genStackArgAt:into: */
		/* begin genStackArgAt:into: */
		/* begin MoveMw:r:R: */
		_offset4 = 3 * BytesPerWord;
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction18 = genoperandoperandoperand(MoveMwrR, _offset4, SPReg, _startReg);
		if (usesOutOfLineLiteral(_anInstruction18)) {
			(_anInstruction18->dependent = locateLiteral(_offset4));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
		/* end genStackArgAt:into: */
		genConvertSmallIntegerToIntegerInReg(_startReg);
		genConvertSmallIntegerToIntegerInReg(_repStartReg);
		/* begin SubR:R: */
		genoperandoperand(SubRR, _startReg, _stopReg);
		/* end SubR:R: */
		/* begin AddR:R: */
		genoperandoperand(AddRR, _repStartReg, _stopReg);
		/* end AddR:R: */
		genGetNumSlotsOfinto(_replReg, _startReg);
		/* begin LogicalShiftLeftCq:R: */
		genoperandoperand(LogicalShiftLeftCqR, shiftForWord(), _startReg);
		/* end LogicalShiftLeftCq:R: */
		gAndCqRR(BytesPerWord - 1, TempReg, TempReg);
		/* begin SubR:R: */
		genoperandoperand(SubRR, TempReg, _startReg);
		/* end SubR:R: */
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, _startReg, _stopReg);
		/* end CmpR:R: */
		/* begin JumpGreater: */
		_jumpOutOfBounds4 = genConditionalBranchoperand(JumpGreater, ((sqInt) 0 ));
		/* end JumpGreater: */
		/* begin genStackArgAt:into: */
		/* begin MoveMw:r:R: */
		_offset5 = 3 * BytesPerWord;
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction19 = genoperandoperandoperand(MoveMwrR, _offset5, SPReg, _startReg);
		if (usesOutOfLineLiteral(_anInstruction19)) {
			(_anInstruction19->dependent = locateLiteral(_offset5));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
		/* end genStackArgAt:into: */
		genConvertSmallIntegerToIntegerInReg(_startReg);
		/* begin genStackArgAt:into: */
		/* begin MoveMw:r:R: */
		_offset6 = 2 * BytesPerWord;
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction20 = genoperandoperandoperand(MoveMwrR, _offset6, SPReg, _stopReg);
		if (usesOutOfLineLiteral(_anInstruction20)) {
			(_anInstruction20->dependent = locateLiteral(_offset6));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
		/* end genStackArgAt:into: */
		genConvertSmallIntegerToIntegerInReg(_stopReg);
		/* begin SubR:R: */
		genoperandoperand(SubRR, _startReg, _repStartReg);
		/* end SubR:R: */
		/* begin AddR:R: */
		genoperandoperand(AddRR, _repStartReg, _replReg);
		/* end AddR:R: */
		_adjust = BaseHeaderSize - 1;
		if (_adjust != 0) {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction6 = genoperandoperand(AddCqR, _adjust, _startReg);
			if (usesOutOfLineLiteral(_anInstruction6)) {
				(_anInstruction6->dependent = locateLiteral(_adjust));
			}
			/* end checkQuickConstant:forInstruction: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction7 = genoperandoperand(AddCqR, _adjust, _stopReg);
			if (usesOutOfLineLiteral(_anInstruction7)) {
				(_anInstruction7->dependent = locateLiteral(_adjust));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		/* begin MoveXbr:R:R: */
		_instr = genoperandoperandoperand(MoveXbrRR, _startReg, _replReg, TempReg);
		/* end MoveXbr:R:R: */
		/* begin MoveR:Xbr:R: */
		genoperandoperandoperand(MoveRXbrR, TempReg, _startReg, _arrayReg);
		/* end MoveR:Xbr:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction12 = genoperandoperand(AddCqR, 1, _startReg);
		if (usesOutOfLineLiteral(_anInstruction12)) {
			(_anInstruction12->dependent = locateLiteral(1));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, _startReg, _stopReg);
		/* end CmpR:R: */
		/* begin JumpAboveOrEqual: */
		genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) _instr ));
		/* end JumpAboveOrEqual: */
		jmpTarget(_jumpEmpty, ((methodOrBlockNumArgs <= 2)
			 ? (/* begin RetN: */ genoperand(RetN, 0) /* end RetN: */)
			 : (/* begin RetN: */ genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord) /* end RetN: */)));
		jmpTarget(_jumpIncorrectFormat4, jmpTarget(_jumpIncorrectFormat3, jmpTarget(_jumpIncorrectFormat2, jmpTarget(_jumpIncorrectFormat1, genoperandoperand(Label, (labelCounter += 1), bytecodePC)))));
	}
	if (((_result = compileInterpreterPrimitive())) < 0) {
		return _result;
	}
	jmpTarget(_jumpImm, jmpTarget(_jumpNotSmi1, jmpTarget(_jumpNotSmi2, jmpTarget(_jumpNotSmi3, genoperandoperand(Label, (labelCounter += 1), bytecodePC)))));
	jmpTarget(_jumpOutOfBounds1, jmpTarget(_jumpOutOfBounds2, jmpTarget(_jumpOutOfBounds3, jmpTarget(_jumpOutOfBounds4, ((AbstractInstruction *) ((_jumpImm->operands)[0]) )))));
	
#  if IMMUTABILITY
	{
		jmpTarget(_jumpImmutable, ((AbstractInstruction *) ((_jumpImm->operands)[0]) ));
	}
#  endif /* IMMUTABILITY */
	return CompletePrimitive;
}
/* CogObjectRepresentationForSpur>>#genSetSmallIntegerTagsIn: */
static sqInt NoDbgRegParms
genSetSmallIntegerTagsIn(sqInt _scratchReg)
{
	AbstractInstruction *_anInstruction;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(OrCqR, 1, _scratchReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	return 0;
}
/*	Create a trampoline to store-check the update of the receiver in a 
	closure's outerContext in compileBlockFrameBuild:. */
/* CogObjectRepresentationForSpur>>#genStoreCheckContextReceiverTrampoline */
static sqInt
genStoreCheckContextReceiverTrampoline(void)
{
	sqInt _startAddress;

	_startAddress = methodZoneBase();
	zeroOpcodeIndex();
	genStoreCheckReceiverRegvalueRegscratchReginFrame(ReceiverResultReg, Arg0Reg, TempReg, 0);
	/* begin RetN: */
	genoperand(RetN, 0);
	/* end RetN: */
	outputInstructionsForGeneratedRuntimeAt(_startAddress);
	recordGeneratedRunTimeaddress("ceStoreCheckContextReceiver", _startAddress);
	recordRunTimeObjectReferences();
	return _startAddress;
}
/*	Generate the code for a store check of valueReg into destReg. */
/* CogObjectRepresentationForSpur>>#genStoreCheckReceiverReg:valueReg:scratchReg:inFrame: */
static sqInt NoDbgRegParms
genStoreCheckReceiverRegvalueRegscratchReginFrame(sqInt _destReg, sqInt _valueReg, sqInt _scratchReg, sqInt _inFrame)
{
	AbstractInstruction *_abstractInstruction;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_exit;
	AbstractInstruction * _inst;
	AbstractInstruction * _isDestYoung2;
	AbstractInstruction * _isOldAndOld2;
	AbstractInstruction * _isPermAndPerm2;
	AbstractInstruction *_jmpAlreadyRemembered;
	AbstractInstruction *_jmpDestYoung;
	AbstractInstruction *_jmpImmediate;
	AbstractInstruction *_jmpIsMachineCode;
	AbstractInstruction *_jmpOldAndOld;
	AbstractInstruction *_jmpPermAndPerm;
	sqInt _quickConstant;
	sqInt _quickConstant2;
	sqInt _quickConstant3;
	sqInt _quickConstant4;
	sqInt _quickConstant5;
	AbstractInstruction *_recvIsPerm;
	AbstractInstruction * _valueIsMachineCode2;

	_jmpAlreadyRemembered = ((AbstractInstruction *) 0 );
	_jmpImmediate = genJumpImmediate(_valueReg);
	/* begin genCheckObjectPosition:scratchReg:valueReg:results: */
	/* begin CmpCq:R: */
	_quickConstant = getNewSpaceStart(getMemoryMap());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(CmpCqR, _quickConstant, _valueReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_valueIsMachineCode2 = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin CmpCq:R: */
	_quickConstant2 = fixedPermSpaceStart(getMemoryMap());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant2, _destReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_recvIsPerm = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant3 = getOldSpaceStart(getMemoryMap());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant3, _destReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant3));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_isDestYoung2 = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin CmpCq:R: */
	_quickConstant4 = getOldSpaceStart(getMemoryMap());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(CmpCqR, _quickConstant4, _valueReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(_quickConstant4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_isOldAndOld2 = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin Jump: */
	_exit = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_recvIsPerm, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	/* begin CmpCq:R: */
	_quickConstant5 = fixedPermSpaceStart(getMemoryMap());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction5 = genoperandoperand(CmpCqR, _quickConstant5, _valueReg);
	if (usesOutOfLineLiteral(_anInstruction5)) {
		(_anInstruction5->dependent = locateLiteral(_quickConstant5));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAbove: */
	_isPermAndPerm2 = genConditionalBranchoperand(JumpAbove, ((sqInt) 0 ));
	/* end JumpAbove: */
	jmpTarget(_exit, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	{
		_jmpDestYoung = _isDestYoung2;
		_jmpOldAndOld = _isOldAndOld2;
		_jmpIsMachineCode = _valueIsMachineCode2;
		_jmpPermAndPerm = _isPermAndPerm2;
	}
	/* end genCheckObjectPosition:scratchReg:valueReg:results: */
	if (!CheckRememberedInTrampoline) {
		_jmpAlreadyRemembered = genCheckRememberedBitOfscratch(_destReg, _scratchReg);
	}
	assert(_destReg == ReceiverResultReg);
	/* begin evaluateTrampolineCallBlock:protectLinkRegIfNot: */
	if (_inFrame) {
		{
			/* begin CallRT: */
			/* begin annotateCall: */
			_abstractInstruction = genoperand(Call, ceStoreCheckTrampoline);
			(_abstractInstruction->annotation = IsRelativeCall);
			/* end annotateCall: */
			/* end CallRT: */
		}
	} else {
		/* begin saveAndRestoreLinkRegAround: */
		_inst = genoperand(PushR, LinkReg);
		{
			{
				/* begin CallRT: */
				/* begin annotateCall: */
				_abstractInstruction = genoperand(Call, ceStoreCheckTrampoline);
				(_abstractInstruction->annotation = IsRelativeCall);
				/* end annotateCall: */
				/* end CallRT: */
			}
		}
		genoperand(PopR, LinkReg);
		/* end saveAndRestoreLinkRegAround: */
	}
	/* end evaluateTrampolineCallBlock:protectLinkRegIfNot: */
	jmpTarget(_jmpImmediate, jmpTarget(_jmpDestYoung, jmpTarget(_jmpIsMachineCode, jmpTarget(_jmpOldAndOld, jmpTarget(_jmpPermAndPerm, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	if (!CheckRememberedInTrampoline) {
		jmpTarget(_jmpAlreadyRemembered, ((AbstractInstruction *) ((_jmpOldAndOld->operands)[0]) ));
	}
	return 0;
}
/* CogObjectRepresentationForSpur>>#genStoreSourceReg:slotIndex:destReg:scratchReg:inFrame:needsStoreCheck: */
static sqInt NoDbgRegParms
genStoreSourceRegslotIndexdestRegscratchReginFrameneedsStoreCheck(sqInt _sourceReg, sqInt _index, sqInt _destReg, sqInt _scratchReg, sqInt _inFrame, sqInt _needsStoreCheck)
{
	AbstractInstruction *_abstractInstruction;
	AbstractInstruction *_anInstruction;

	/* begin genTraceStores */
	if (traceStores > 0) {
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, ClassReg, TempReg);
		/* end MoveR:R: */
		/* begin CallRT: */
		/* begin annotateCall: */
		_abstractInstruction = genoperand(Call, ceTraceStoreTrampoline);
		(_abstractInstruction->annotation = IsRelativeCall);
		/* end annotateCall: */
		/* end CallRT: */
	}
	/* end genTraceStores */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveRMwr, _sourceReg, (_index * BytesPerWord) + BaseHeaderSize, _destReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral((_index * BytesPerWord) + BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	if (_needsStoreCheck) {
		return genStoreCheckReceiverRegvalueRegscratchReginFrame(_destReg, _sourceReg, _scratchReg, _inFrame);
	}
	return 0;
}
/*	This method is used for unchecked stores in objects after their creation 
	(typically, inlined creation of Array, closures and some temp vectors).  
	Currently there is no need to do the immutability check here */
/* CogObjectRepresentationForSpur>>#genStoreSourceReg:slotIndex:intoNewObjectInDestReg: */
static sqInt NoDbgRegParms
genStoreSourceRegslotIndexintoNewObjectInDestReg(sqInt _sourceReg, sqInt _index, sqInt _destReg)
{
	AbstractInstruction *_anInstruction;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveRMwr, _sourceReg, (_index * BytesPerWord) + BaseHeaderSize, _destReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral((_index * BytesPerWord) + BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	return 0;
}
/*	Convention: 
	- RcvrResultReg holds the object mutated. 
	If immutability failure: 
	- TempReg holds the instance variable index mutated  
	if instVarIndex > numDedicatedStoreTrampoline 
	- ClassReg holds the value to store 
	Registers are not lived across this trampoline as the  
	immutability failure may need new stack frames. */
/* CogObjectRepresentationForSpur>>#genStoreTrampolineCalled:instVarIndex: */

#if IMMUTABILITY
static sqInt NoDbgRegParms
genStoreTrampolineCalledinstVarIndex(char *_trampolineName, sqInt _instVarIndex)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_jumpRC;
	AbstractInstruction *_jumpSC;
	sqInt _quickConstant;

	zeroOpcodeIndex();
	_jumpSC = genJumpMutablescratchReg(ReceiverResultReg, SendNumArgsReg);
	compileTrampolineFornumArgsargargargargregsToSavepushLinkRegresultReg(ceCannotAssignTowithIndexvalueToAssign, 3, ReceiverResultReg, ((_instVarIndex < (NumStoreTrampolines - 1))
		 ? (/* begin trampolineArgConstant: */ assert(_instVarIndex >= 0), -2 - _instVarIndex /* end trampolineArgConstant: */)
		 : TempReg), ClassReg, null, 0, 1, NoReg);
	jmpTarget(_jumpSC, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	if (CheckRememberedInTrampoline) {
		{
			/* begin TstCq:R: */
			_quickConstant = 1U << (rememberedBitShift());
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperand(TstCqR, _quickConstant, SendNumArgsReg);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(_quickConstant));
			}
			/* end checkQuickConstant:forInstruction: */
			/* end TstCq:R: */
			/* begin JumpZero: */
			_jumpRC = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
			/* end JumpZero: */
			/* begin RetN: */
			genoperand(RetN, 0);
			/* end RetN: */
		}
		jmpTarget(_jumpRC, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(rememberObjInCorrectRememberedSet, _trampolineName, 1, ReceiverResultReg, null, null, null, 0, 1, NoReg, 1);
}
#endif /* IMMUTABILITY */
/*	Store check code is duplicated to use a single trampoline */
/* CogObjectRepresentationForSpur>>#genStoreWithImmutabilityAndStoreCheckSourceReg:slotIndex:destReg:scratchReg:needRestoreRcvr: */

#if IMMUTABILITY
static sqInt NoDbgRegParms
genStoreWithImmutabilityAndStoreCheckSourceRegslotIndexdestRegscratchRegneedRestoreRcvr(sqInt _sourceReg, sqInt _index, sqInt _destReg, sqInt _scratchReg, sqInt _needRestoreRcvr)
{
	AbstractInstruction *_abstractInstruction;
	AbstractInstruction *_abstractInstruction2;
	AbstractInstruction *_abstractInstruction3;
	AbstractInstruction *_abstractInstruction4;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction *_anInstruction7;
	AbstractInstruction *_exit;
	AbstractInstruction *_immutableJump;
	AbstractInstruction * _isDestYoung2;
	AbstractInstruction * _isOldAndOld2;
	AbstractInstruction * _isPermAndPerm2;
	AbstractInstruction *_jmpAlreadyRemembered;
	AbstractInstruction *_jmpDestYoung;
	AbstractInstruction *_jmpImmediate;
	AbstractInstruction *_jmpIsMachineCode;
	AbstractInstruction *_jmpOldAndOld;
	AbstractInstruction *_jmpPermAndPerm;
	sqInt _quickConstant;
	sqInt _quickConstant2;
	sqInt _quickConstant3;
	sqInt _quickConstant4;
	sqInt _quickConstant5;
	AbstractInstruction *_recvIsPerm;
	AbstractInstruction * _valueIsMachineCode2;

	_jmpAlreadyRemembered = ((AbstractInstruction *) 0 );
	_immutableJump = genJumpImmutablescratchReg(_destReg, _scratchReg);
	/* begin genTraceStores */
	if (traceStores > 0) {
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, ClassReg, TempReg);
		/* end MoveR:R: */
		/* begin CallRT: */
		/* begin annotateCall: */
		_abstractInstruction = genoperand(Call, ceTraceStoreTrampoline);
		(_abstractInstruction->annotation = IsRelativeCall);
		/* end annotateCall: */
		/* end CallRT: */
	}
	/* end genTraceStores */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveRMwr, _sourceReg, (_index * BytesPerWord) + BaseHeaderSize, _destReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral((_index * BytesPerWord) + BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	_jmpImmediate = genJumpImmediate(_sourceReg);
	/* begin genCheckObjectPosition:scratchReg:valueReg:results: */
	/* begin CmpCq:R: */
	_quickConstant = getNewSpaceStart(getMemoryMap());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction6 = genoperandoperand(CmpCqR, _quickConstant, _sourceReg);
	if (usesOutOfLineLiteral(_anInstruction6)) {
		(_anInstruction6->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_valueIsMachineCode2 = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin CmpCq:R: */
	_quickConstant2 = fixedPermSpaceStart(getMemoryMap());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant2, _destReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_recvIsPerm = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin CmpCq:R: */
	_quickConstant3 = getOldSpaceStart(getMemoryMap());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, _quickConstant3, _destReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_quickConstant3));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpBelow: */
	_isDestYoung2 = genConditionalBranchoperand(JumpBelow, ((sqInt) 0 ));
	/* end JumpBelow: */
	/* begin CmpCq:R: */
	_quickConstant4 = getOldSpaceStart(getMemoryMap());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction4 = genoperandoperand(CmpCqR, _quickConstant4, _sourceReg);
	if (usesOutOfLineLiteral(_anInstruction4)) {
		(_anInstruction4->dependent = locateLiteral(_quickConstant4));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAboveOrEqual: */
	_isOldAndOld2 = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
	/* end JumpAboveOrEqual: */
	/* begin Jump: */
	_exit = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_recvIsPerm, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	/* begin CmpCq:R: */
	_quickConstant5 = fixedPermSpaceStart(getMemoryMap());
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction5 = genoperandoperand(CmpCqR, _quickConstant5, _sourceReg);
	if (usesOutOfLineLiteral(_anInstruction5)) {
		(_anInstruction5->dependent = locateLiteral(_quickConstant5));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAbove: */
	_isPermAndPerm2 = genConditionalBranchoperand(JumpAbove, ((sqInt) 0 ));
	/* end JumpAbove: */
	jmpTarget(_exit, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	{
		_jmpDestYoung = _isDestYoung2;
		_jmpOldAndOld = _isOldAndOld2;
		_jmpIsMachineCode = _valueIsMachineCode2;
		_jmpPermAndPerm = _isPermAndPerm2;
	}
	/* end genCheckObjectPosition:scratchReg:valueReg:results: */
	if (!CheckRememberedInTrampoline) {
		_jmpAlreadyRemembered = genCheckRememberedBitOfscratch(_destReg, _scratchReg);
	}
	jmpTarget(_immutableJump, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	/* begin genStoreTrampolineCall: */
	assert(IMMUTABILITY);
	if (_index >= (NumStoreTrampolines - 1)) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction7 = genoperandoperand(MoveCqR, _index, TempReg);
		if (usesOutOfLineLiteral(_anInstruction7)) {
			(_anInstruction7->dependent = locateLiteral(_index));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin CallRT: */
		/* begin annotateCall: */
		_abstractInstruction4 = genoperand(Call, ceStoreTrampolines[NumStoreTrampolines - 1]);
		(_abstractInstruction4->annotation = IsRelativeCall);
		/* end annotateCall: */
		/* end CallRT: */
	} else {
		/* begin CallRT: */
		/* begin annotateCall: */
		_abstractInstruction2 = genoperand(Call, ceStoreTrampolines[_index]);
		(_abstractInstruction2->annotation = IsRelativeCall);
		/* end annotateCall: */
		/* end CallRT: */
	}
	/* begin annotateBytecode: */
	_abstractInstruction3 = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
	(_abstractInstruction3->annotation = HasBytecodePC);
	/* end annotateBytecode: */
	/* end genStoreTrampolineCall: */
	/* begin voidReceiverOptStatus */
	((simSelf())->liveRegister = NoReg);
	/* end voidReceiverOptStatus */
	if (_needRestoreRcvr) {
		/* begin putSelfInReceiverResultReg */
		copyToReg(simSelf(), ReceiverResultReg);
		/* end putSelfInReceiverResultReg */
	}
	jmpTarget(_jmpImmediate, jmpTarget(_jmpDestYoung, jmpTarget(_jmpOldAndOld, jmpTarget(_jmpIsMachineCode, jmpTarget(_jmpPermAndPerm, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
	if (!CheckRememberedInTrampoline) {
		jmpTarget(_jmpAlreadyRemembered, ((AbstractInstruction *) ((_jmpOldAndOld->operands)[0]) ));
	}
	return 0;
}
#endif /* IMMUTABILITY */
/*	Gen an immutability check with no store check (e.g. assigning an immediate 
	literal) imm check has its own trampoline */
/* CogObjectRepresentationForSpur>>#genStoreWithImmutabilityButNoStoreCheckSourceReg:slotIndex:destReg:scratchReg:needRestoreRcvr: */

#if IMMUTABILITY
static sqInt NoDbgRegParms
genStoreWithImmutabilityButNoStoreCheckSourceRegslotIndexdestRegscratchRegneedRestoreRcvr(sqInt _sourceReg, sqInt _index, sqInt _destReg, sqInt _scratchReg, sqInt _needRestoreRcvr)
{
	AbstractInstruction *_abstractInstruction;
	AbstractInstruction *_abstractInstruction2;
	AbstractInstruction *_abstractInstruction3;
	AbstractInstruction *_abstractInstruction4;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_immutabilityFailure;
	AbstractInstruction *_mutableJump;

	_mutableJump = genJumpMutablescratchReg(_destReg, _scratchReg);
	/* begin genStoreTrampolineCall: */
	assert(IMMUTABILITY);
	if (_index >= (NumStoreTrampolines - 1)) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, _index, TempReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_index));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin CallRT: */
		/* begin annotateCall: */
		_abstractInstruction = genoperand(Call, ceStoreTrampolines[NumStoreTrampolines - 1]);
		(_abstractInstruction->annotation = IsRelativeCall);
		/* end annotateCall: */
		/* end CallRT: */
	} else {
		/* begin CallRT: */
		/* begin annotateCall: */
		_abstractInstruction2 = genoperand(Call, ceStoreTrampolines[_index]);
		(_abstractInstruction2->annotation = IsRelativeCall);
		/* end annotateCall: */
		/* end CallRT: */
	}
	/* begin annotateBytecode: */
	_abstractInstruction3 = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
	(_abstractInstruction3->annotation = HasBytecodePC);
	/* end annotateBytecode: */
	/* end genStoreTrampolineCall: */
	/* begin voidReceiverOptStatus */
	((simSelf())->liveRegister = NoReg);
	/* end voidReceiverOptStatus */
	if (_needRestoreRcvr) {
		/* begin putSelfInReceiverResultReg */
		copyToReg(simSelf(), ReceiverResultReg);
		/* end putSelfInReceiverResultReg */
	}
	/* begin Jump: */
	_immutabilityFailure = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_mutableJump, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	/* begin genTraceStores */
	if (traceStores > 0) {
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, ClassReg, TempReg);
		/* end MoveR:R: */
		/* begin CallRT: */
		/* begin annotateCall: */
		_abstractInstruction4 = genoperand(Call, ceTraceStoreTrampoline);
		(_abstractInstruction4->annotation = IsRelativeCall);
		/* end annotateCall: */
		/* end CallRT: */
	}
	/* end genTraceStores */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveRMwr, _sourceReg, (_index * BytesPerWord) + BaseHeaderSize, _destReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral((_index * BytesPerWord) + BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	jmpTarget(_immutabilityFailure, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return 0;
}
#endif /* IMMUTABILITY */
/*	We know there is a frame as immutability check requires a frameneedRestoreRcvr has to be true to keep RcvrResultReg live with the 
	receiver in it across the trampolineTrampoline convention... */
/* CogObjectRepresentationForSpur>>#genStoreWithImmutabilityCheckSourceReg:slotIndex:destReg:scratchReg:needsStoreCheck:needRestoreRcvr: */

#if IMMUTABILITY
static sqInt NoDbgRegParms
genStoreWithImmutabilityCheckSourceRegslotIndexdestRegscratchRegneedsStoreCheckneedRestoreRcvr(sqInt _sourceReg, sqInt _index, sqInt _destReg, sqInt _scratchReg, sqInt _needsStoreCheck, sqInt _needRestoreRcvr)
{
	assert(_destReg == ReceiverResultReg);
	assert(_scratchReg == TempReg);
	assert(_sourceReg == ClassReg);
	if (_needsStoreCheck) {
		genStoreWithImmutabilityAndStoreCheckSourceRegslotIndexdestRegscratchRegneedRestoreRcvr(_sourceReg, _index, _destReg, _scratchReg, _needRestoreRcvr);
	}
 else {
		genStoreWithImmutabilityButNoStoreCheckSourceRegslotIndexdestRegscratchRegneedRestoreRcvr(_sourceReg, _index, _destReg, _scratchReg, _needRestoreRcvr);
	}
	return 0;
}
#endif /* IMMUTABILITY */
/* CogObjectRepresentationForSpur>>#jumpNotCharacterUnsignedValueInRegister: */
static AbstractInstruction * NoDbgRegParms
jumpNotCharacterUnsignedValueInRegister(sqInt _reg)
{
	AbstractInstruction *_anInstruction;
	sqInt _quickConstant;

	/* begin CmpCq:R: */
	_quickConstant = (1U << (numCharacterBits())) - 1;
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(CmpCqR, _quickConstant, _reg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpAbove: */
	return genConditionalBranchoperand(JumpAbove, ((sqInt) 0 ));
	/* end JumpAbove: */
}
/*	Mark and trace a literal in a machine code instruction preceding address 
	in cogMethodOrNil. 
	Answer if code was modified. */
/* CogObjectRepresentationForSpur>>#markAndTraceLiteral:in:atpc: */
static sqInt NoDbgRegParms
markAndTraceLiteralinatpc(sqInt _literal, CogMethod *_cogMethodOrNil, usqInt _address)
{
	sqInt _objOop;

	if (!(couldBeObject(_literal))) {
		return 0;
	}
	assert(addressCouldBeObj(_literal));
	if (!(isForwarded(_literal))) {
		markAndTrace(_literal);
		return 0;
	}
	_objOop = followForwarded(_literal);
	/* begin storeLiteral:atAnnotatedAddress: */
	/* begin storeLiteral:atAnnotatedAddress:using: */
	unsignedLongAtput(_address, _objOop);
	/* end storeLiteral:atAnnotatedAddress:using: */
	/* end storeLiteral:atAnnotatedAddress: */
	markAndTraceUpdatedLiteralin(_objOop, _cogMethodOrNil);
	return 1;
}
/*	Mark and trace a literal in a sqInt variable of cogMethod. */
/* CogObjectRepresentationForSpur>>#markAndTraceLiteral:in:at: */
static void NoDbgRegParms
markAndTraceLiteralinat(sqInt _literal, CogMethod *_cogMethod, sqInt *_address)
{
	sqInt _objOop;

	if (!(couldBeObject(_literal))) {
		return;
	}
	assert(addressCouldBeObj(_literal));
	if (!(isForwarded(_literal))) {
		markAndTrace(_literal);
		return;
	}
	_objOop = followForwarded(_literal);
	_address[0] = _objOop;
	markAndTraceUpdatedLiteralin(_objOop, _cogMethod);
}
/*	Common code to mark a literal in cogMethod and add 
	the cogMethod to youngReferrers if the literal is young. */
/* CogObjectRepresentationForSpur>>#markAndTraceUpdatedLiteral:in: */
static void NoDbgRegParms
markAndTraceUpdatedLiteralin(sqInt _objOop, CogMethod *_cogMethodOrNil)
{
	if (isNonImmediate(_objOop)) {
		if ((_cogMethodOrNil != null) && (isYoungObject(getMemoryMap(), _objOop))) {
			ensureInYoungReferrers(_cogMethodOrNil);
		}
		markAndTrace(_objOop);
	}
}
/*	If primIndex has an accessorDepth and fails, or it is external and fails 
	with PrimErrNoMemory, 
	call ceCheckAndMaybeRetryPrimitive if so If ceCheck.... answers true, 
	retry the primitive. */
/* CogObjectRepresentationForSpur>>#maybeCompileRetryOnPrimitiveFail: */
static sqInt NoDbgRegParms
maybeCompileRetryOnPrimitiveFail(sqInt _primIndex)
{
	sqInt _address;
	sqInt _address2;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_jmp;

	if ((accessorDepthForPrimitiveIndex(_primIndex)) >= 0) {
		{
			/* begin MoveAw:R: */
			_address = primFailCodeAddress();
			/* begin gen:literal:operand: */
			checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, TempReg));
			/* end gen:literal:operand: */
			/* end MoveAw:R: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperand(CmpCqR, 0, TempReg);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
			/* begin JumpZero: */
			_jmp = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
			/* end JumpZero: */
		}
	} else {
		if ((primNumberExternalCall()) != _primIndex) {
			return 0;
		}
		{
			/* begin MoveAw:R: */
			_address2 = primFailCodeAddress();
			/* begin gen:literal:operand: */
			checkLiteralforInstruction(_address2, genoperandoperand(MoveAwR, _address2, TempReg));
			/* end gen:literal:operand: */
			/* end MoveAw:R: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction2 = genoperandoperand(CmpCqR, PrimErrNoMemory, TempReg);
			if (usesOutOfLineLiteral(_anInstruction2)) {
				(_anInstruction2->dependent = locateLiteral(PrimErrNoMemory));
			}
			/* end checkQuickConstant:forInstruction: */
			/* begin JumpNonZero: */
			_jmp = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
			/* end JumpNonZero: */
		}
	}
	compileCallFornumArgsargargargargresultRegregsToSave(ceCheckAndMaybeRetryPrimitive, 1, trampolineArgConstant(_primIndex), null, null, null, TempReg, 0);
	jmpTarget(_jmp, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return 0;
}
/*	Generate a shift of the register containing the class tag in a method 
	cache probe. 
	c.f. SpurMemoryManager>>methodCacheHashOf:with: */
/* CogObjectRepresentationForSpur>>#maybeShiftClassTagRegisterForMethodCacheProbe: */
static sqInt NoDbgRegParms
maybeShiftClassTagRegisterForMethodCacheProbe(sqInt _classTagReg)
{
	/* begin LogicalShiftLeftCq:R: */
	genoperandoperand(LogicalShiftLeftCqR, 2, _classTagReg);
	/* end LogicalShiftLeftCq:R: */
	return 0;
}
/* CogObjectRepresentationForSpur>>#numCharacterBits */
static sqInt
numCharacterBits(void)
{
	return 30;
}
/*	Define how many register arguments a StackToRegisterMappingCogit can 
	and should use with the receiver. The value must be 0, 1 or 2. Note that a 
	SimpleStackBasedCogit always has 0 register args (although the receiver is 
	passed in a register). The Spur object representation is simple enough 
	that implementing at:put: is straight-forward and hence 2 register args 
	are worth 
	while. The method must be inlined in CoInterpreter, and dead code 
	eliminated so that the register-popping enilopmarts such as 
	enterRegisterArgCogMethod:- at:receiver: do not have to be implemented in 
	SimpleStackBasedCogit.  */
/* CogObjectRepresentationForSpur>>#numRegArgs */
sqInt
numRegArgs(void)
{
	return 2;
}
/* CogObjectRepresentationForSpur>>#remapObject: */
static sqInt NoDbgRegParms
remapObject(sqInt _objOop)
{
	assert(addressCouldBeObj(_objOop));
	return ((shouldRemapObj(_objOop))
		 ? remapObj(_objOop)
		 : _objOop);
}
/* CogObjectRepresentationForSpur>>#remapOop: */
static sqInt NoDbgRegParms
remapOop(sqInt _objOop)
{
	return ((shouldRemapOop(_objOop))
		 ? remapObj(_objOop)
		 : _objOop);
}
/*	Objects in newSpace or oldSpace except nil, true, false & 
	classTableRootObj need to be annotated. */
/* CogObjectRepresentationForSpur>>#shouldAnnotateObjectReference: */
static sqInt NoDbgRegParms
shouldAnnotateObjectReference(sqInt _anOop)
{
	return (isNonImmediate(_anOop)) && ((oopisGreaterThan(_anOop, classTableRootObj())) || (oopisLessThan(_anOop, nilObject())));
}
/* CogObjectRepresentationForSpur>>#slotOffsetOfInstVarIndex: */
static sqInt NoDbgRegParms
slotOffsetOfInstVarIndex(sqInt _index)
{
	return (_index * BytesPerWord) + BaseHeaderSize;
}
/* CogObjectRepresentationForSpur>>#valueOfAssociation: */
static sqInt NoDbgRegParms
valueOfAssociation(sqInt _associationOop)
{
	sqInt _association;

	_association = _associationOop;
	if (isForwarded(_association)) {
		_association = followForwarded(_association);
	}
	return fetchPointerofObject(ValueIndex, _association);
}
/* CogOutOfLineLiteralsARMv8Compiler>>#cmpC32RTempByteSize */
static sqInt NoDbgRegParms
cmpC32RTempByteSize(AbstractInstruction * self_in_cmpC32RTempByteSize)
{
	return 8;
}
/*	Generate an out-of-line literal. Copy the value and any annotation from 
	the stand-in in the literals manager. */
/* CogOutOfLineLiteralsARMv8Compiler>>#concretizeLiteral */
static AbstractInstruction * NoDbgRegParms
concretizeLiteral(AbstractInstruction * self_in_concretizeLiteral)
{
	sqInt _literal;
	AbstractInstruction * _literalAsInstruction;
	sqInt _twoComplement;

	_literalAsInstruction = ((AbstractInstruction *) ((self_in_concretizeLiteral->operands)[0]) );
	_literal = (((addressIsInInstructions(_literalAsInstruction)) || (_literalAsInstruction == (methodLabel())))
		 ? (_literalAsInstruction->address)
		 : ((usqInt) _literalAsInstruction ));
	assert((((self_in_concretizeLiteral->dependent)) != null) && (((((self_in_concretizeLiteral->dependent))->opcode)) == Literal));
	if ((((self_in_concretizeLiteral->dependent))->annotation)) {
		assert(((self_in_concretizeLiteral->annotation)) == null);
		(self_in_concretizeLiteral->annotation) = (((self_in_concretizeLiteral->dependent))->annotation);
	}
	if ((((self_in_concretizeLiteral->dependent))->address)) {
		assert(((((self_in_concretizeLiteral->dependent))->address)) == ((self_in_concretizeLiteral->address)));
	}
	(((self_in_concretizeLiteral->dependent))->address = (self_in_concretizeLiteral->address));
	_twoComplement = ((_literal < 0)
		 ? (0xFFFFFFFFFFFFFFFFULL - (SQABS(_literal))) + 1
		 : _literal);
	/* begin machineCodeAt:put: */
	(self_in_concretizeLiteral->machineCode)[0 / 4] = _twoComplement & 0xFFFFFFFFU;
	/* end machineCodeAt:put: */
	/* begin machineCodeAt:put: */
	(self_in_concretizeLiteral->machineCode)[4 / 4] = ((usqInt) _twoComplement ) >> 32;
	/* end machineCodeAt:put: */
	(self_in_concretizeLiteral->machineCodeSize) = 8;
	return self_in_concretizeLiteral;
}
/* CogOutOfLineLiteralsARMv8Compiler>>#concretizeMovePatcheableC32R */
static usqInt NoDbgRegParms
concretizeMovePatcheableC32R(AbstractInstruction * self_in_concretizeMovePatcheableC32R)
{
	sqInt _aWord;
	sqInt _destReg;

	/* begin loadRelativeLiteralIn: */
	_destReg = (self_in_concretizeMovePatcheableC32R->operands)[1];
	assert(((((self_in_concretizeMovePatcheableC32R->dependent))->opcode)) == Literal);
	assert(addressIsInCurrentCompilation((((self_in_concretizeMovePatcheableC32R->dependent))->address)));
	assert((SQABS(((((self_in_concretizeMovePatcheableC32R->dependent))->address)) - (((self_in_concretizeMovePatcheableC32R->address)) + 8))) < (1U << 12));
	/* begin machineCodeAt:put: */
	_aWord = ldrSizeprogramCounterRelativeOffsetdestinationRegister(self_in_concretizeMovePatcheableC32R, 1, ((((self_in_concretizeMovePatcheableC32R->dependent))->address)) - ((self_in_concretizeMovePatcheableC32R->address)), _destReg);
	(self_in_concretizeMovePatcheableC32R->machineCode)[0 / 4] = _aWord;
	/* end machineCodeAt:put: */
	/* end loadRelativeLiteralIn: */
	return ((self_in_concretizeMovePatcheableC32R->machineCodeSize) = 4);
}
/* CogOutOfLineLiteralsARMv8Compiler>>#inlineCacheTagAt: */
static usqInt NoDbgRegParms
inlineCacheTagAt(AbstractInstruction * self_in_inlineCacheTagAt, sqInt _callSiteReturnAddress)
{
	return (unsignedLongAt(pcRelativeAddressAt(self_in_inlineCacheTagAt, ((usqInt) (_callSiteReturnAddress - 8) )))) & ((1U << (classIndexFieldWidth())) - 1);
}
/*	Answer if the receiver is a pc-dependent instruction. With out-of-line 
	literals any instruction 
	that refers to a literal depends on the address of the literal, so add 
	them in addition to the jumps. */
/* CogOutOfLineLiteralsARMv8Compiler>>#isPCDependent */
static sqInt NoDbgRegParms
isPCDependent(AbstractInstruction * self_in_isPCDependent)
{
	return (isJump(self_in_isPCDependent)) || ((((self_in_isPCDependent->opcode)) == AlignmentNops) || ((((self_in_isPCDependent->opcode)) != Literal) && ((((self_in_isPCDependent->dependent)) != null) && (((((self_in_isPCDependent->dependent))->opcode)) == Literal))));
}
/*	Return the literal referenced by the instruction immediately preceding 
	followingAddress.  */
/* CogOutOfLineLiteralsARMv8Compiler>>#literalBeforeFollowingAddress: */
static sqInt NoDbgRegParms
literalBeforeFollowingAddress(AbstractInstruction * self_in_literalBeforeFollowingAddress, sqInt _followingAddress)
{
	sqInt _anInteger;

	/* begin unsignedLong64At: */
	_anInteger = pcRelativeAddressAt(self_in_literalBeforeFollowingAddress, ((instructionIsLDR(self_in_literalBeforeFollowingAddress, instructionBeforeAddress(self_in_literalBeforeFollowingAddress, _followingAddress)))
		 ? (/* begin instructionAddressBefore: */ _followingAddress - 4 /* end instructionAddressBefore: */)
		 : (/* begin instructionAddressBefore: */ (_followingAddress - 4) - 4 /* end instructionAddressBefore: */)));
	return uint64AtPointer(_anInteger);
	/* end unsignedLong64At: */
}
/*	Answer the size of a literal load instruction (which does not include the 
	size of the literal). 
	With out-of-line literals this is always a single LDR instruction that 
	refers to the literal. */
/* CogOutOfLineLiteralsARMv8Compiler>>#literalLoadInstructionBytes */
static sqInt NoDbgRegParms
literalLoadInstructionBytes(AbstractInstruction * self_in_literalLoadInstructionBytes)
{
	return 4;
}
/*	Answer the byte size of a MoveCwR opcode's corresponding machine code. On 
	ARM this is a single instruction pc-relative register load - unless we 
	have made a mistake and not turned on the out of line literals manager */
/* CogOutOfLineLiteralsARMv8Compiler>>#loadLiteralByteSize */
static sqInt NoDbgRegParms
loadLiteralByteSize(AbstractInstruction * self_in_loadLiteralByteSize)
{
	return 4;
}
/*	The maximum offset in a LDR is (1<<12)-1, or (1<<10)-1 instructions. 
	Be conservative. The issue is that one abstract instruction can emit 
	multiple hardware instructions so we assume a 2 to 1 worst case of 
	hardware instructions to abstract opcodes.. */
/* CogOutOfLineLiteralsARMv8Compiler>>#outOfLineLiteralOpcodeLimit */
static sqInt NoDbgRegParms
outOfLineLiteralOpcodeLimit(AbstractInstruction * self_in_outOfLineLiteralOpcodeLimit)
{
	return (1U << ((12 - 3) - 1)) - 1;
}
/*	Extract the address of the LDR (literal) instruction at address 
	 
	c.f. C6.2.132 
	 */
/* CogOutOfLineLiteralsARMv8Compiler>>#pcRelativeAddressAt: */
static sqInt NoDbgRegParms
pcRelativeAddressAt(AbstractInstruction * self_in_pcRelativeAddressAt, sqInt _instrAddress)
{
	sqInt _inst;
	sqInt _offset;

	_inst = uint32AtPointer(_instrAddress);
	_offset = (((usqInt) _inst ) >> 5) & 0x7FFFF;
	return _instrAddress + (((((_offset & (1U << 18)) == (1U << 18))
		 ? -_offset
		 : _offset)) * 4);
}
/*	If possible we generate the method address using pc-relative addressing. 
	If so we don't need to relocate it in code. So check if pc-relative code 
	was generated, and if not, adjust a load literal. There are two cases, a 
	push or a register load. If a push, then there is a register load, but in 
	the instruction 
	before. */
/* CogOutOfLineLiteralsARMv8Compiler>>#relocateMethodReferenceBeforeAddress:by: */
static AbstractInstruction * NoDbgRegParms
relocateMethodReferenceBeforeAddressby(AbstractInstruction * self_in_relocateMethodReferenceBeforeAddressby, sqInt _pc, sqInt _delta)
{
	sqInt _litAddr;
	sqInt _pcPrecedingLoad;
	sqLong _reference;

	_pcPrecedingLoad = ((instructionIsPush(self_in_relocateMethodReferenceBeforeAddressby, instructionBeforeAddress(self_in_relocateMethodReferenceBeforeAddressby, _pc)))
		 ? _pc - 4
		 : _pc);
	if (!(isPCRelativeValueLoad(self_in_relocateMethodReferenceBeforeAddressby, instructionBeforeAddress(self_in_relocateMethodReferenceBeforeAddressby, _pcPrecedingLoad)))) {
		_litAddr = pcRelativeAddressAt(self_in_relocateMethodReferenceBeforeAddressby, _pcPrecedingLoad);
		_reference = long64At(_litAddr);
		long64Atput(_litAddr, (_reference + _delta) - 4);
	}
	return self_in_relocateMethodReferenceBeforeAddressby;
}
/*	Rewrite a CallFull or JumpFull instruction to transfer to a different 
	target. This variant is used to rewrite cached primitive calls where we 
	load the target address into ip 
	and use the 'bx ip' or 'blx ip' instruction for the actual jump or call. 
	Answer the extent 
	of the code change which is used to compute the range of the icache to 
	flush.  */
/* CogOutOfLineLiteralsARMv8Compiler>>#rewriteFullTransferAt:target:expectedInstruction: */
static sqInt NoDbgRegParms
rewriteFullTransferAttargetexpectedInstruction(AbstractInstruction * self_in_rewriteFullTransferAttargetexpectedInstruction, usqInt _callSiteReturnAddress, usqInt _callTargetAddress, sqInt _expectedInstruction)
{
	assert((instructionBeforeAddress(self_in_rewriteFullTransferAttargetexpectedInstruction, _callSiteReturnAddress)) == _expectedInstruction);
	longAtput(pcRelativeAddressAt(self_in_rewriteFullTransferAttargetexpectedInstruction, _callSiteReturnAddress - 8), _callTargetAddress);
	return 0;
}
/*	Rewrite an inline cache to call a different target for a new tag. This 
	variant is used 
	to link unlinked sends in ceSend:to:numArgs: et al. Answer the extent of 
	the code 
	change which is used to compute the range of the icache to flush. */
/* CogOutOfLineLiteralsARMv8Compiler>>#rewriteInlineCacheAt:tag:target: */
static sqInt NoDbgRegParms
rewriteInlineCacheAttagtarget(AbstractInstruction * self_in_rewriteInlineCacheAttagtarget, usqInt _callSiteReturnAddress, sqInt _cacheTag, usqInt _callTargetAddress)
{
	sqInt _anInteger;
	sqInt _aValue;
	sqInt _call;
	sqInt _callDistance;

	if (!(_callTargetAddress >= (minCallAddress()))) {
		error("linking callsite to invalid address");
	}
	_callDistance = _callTargetAddress - (_callSiteReturnAddress - 4);
	assert(isInImmediateJumpRange(self_in_rewriteInlineCacheAttagtarget, _callDistance));
	_call = bl(self_in_rewriteInlineCacheAttagtarget, _callDistance);
	{
		uint32AtPointerput(_callSiteReturnAddress - 4, _call);
		/* begin unsignedLong64At:put: */
		_anInteger = pcRelativeAddressAt(self_in_rewriteInlineCacheAttagtarget, _callSiteReturnAddress - 8);
		_aValue = ((usqInt) _cacheTag );
		uint64AtPointerput(_anInteger, _aValue);
		/* end unsignedLong64At:put: */
	}
	assert((inlineCacheTagAt(self_in_rewriteInlineCacheAttagtarget, _callSiteReturnAddress)) == (((usqInt) _cacheTag ) & ((1U << (classIndexFieldWidth())) - 1)));
	return 4;
}
/*	Size a jump and set its address. The target may be another instruction 
	or an absolute address. On entry the address inst var holds our virtual 
	address. On exit address is set to eventualAbsoluteAddress, which is 
	where this instruction will be output. The span of a jump to a following 
	instruction is therefore between that instruction's address and this 
	instruction's address ((which are both still their virtual addresses), but 
	the span of a jump to a preceding instruction or to an absolute address is 
	between that instruction's address (which by now is its eventual absolute 
	address) or absolute address and eventualAbsoluteAddress. 
	 
	ARM is simple; the 26-bit call/jump range means no short jumps. This 
	routine only has to determine the targets of jumps, not determine sizes. 
	 
	This version also deals with out-of-line literals. If this is the real 
	literal, update the stand-in in literalsManager with the address (because 
	instructions referring to the literal are referring to the stand-in). If 
	this is annotated with 
	IsObjectReference transfer the annotation to the stand-in, whence it will 
	be transferred to the real literal, simplifying update of literals. */
/* CogOutOfLineLiteralsARMv8Compiler>>#sizePCDependentInstructionAt: */
static usqInt NoDbgRegParms
sizePCDependentInstructionAt(AbstractInstruction * self_in_sizePCDependentInstructionAt, sqInt _eventualAbsoluteAddress)
{
	usqInt _alignment;

	if (((self_in_sizePCDependentInstructionAt->opcode)) == AlignmentNops) {
		(self_in_sizePCDependentInstructionAt->address) = _eventualAbsoluteAddress;
		_alignment = (self_in_sizePCDependentInstructionAt->operands)[0];
		return ((self_in_sizePCDependentInstructionAt->machineCodeSize) = ((_eventualAbsoluteAddress + (_alignment - 1)) & -_alignment) - _eventualAbsoluteAddress);
	}
	assert((isJump(self_in_sizePCDependentInstructionAt)) || ((((self_in_sizePCDependentInstructionAt->opcode)) == Call) || ((((self_in_sizePCDependentInstructionAt->opcode)) == CallFull) || ((((self_in_sizePCDependentInstructionAt->dependent)) != null) && (((((self_in_sizePCDependentInstructionAt->dependent))->opcode)) == Literal)))));
	if (isJump(self_in_sizePCDependentInstructionAt)) {
		resolveJumpTarget(self_in_sizePCDependentInstructionAt);
	}
	(self_in_sizePCDependentInstructionAt->address) = _eventualAbsoluteAddress;
	if ((((self_in_sizePCDependentInstructionAt->dependent)) != null) && (((((self_in_sizePCDependentInstructionAt->dependent))->opcode)) == Literal)) {
		if (((self_in_sizePCDependentInstructionAt->opcode)) == Literal) {
			(((self_in_sizePCDependentInstructionAt->dependent))->address = (self_in_sizePCDependentInstructionAt->address));
		}
		if (((self_in_sizePCDependentInstructionAt->annotation)) == (getIsObjectReference())) {
			(((self_in_sizePCDependentInstructionAt->dependent))->annotation = (self_in_sizePCDependentInstructionAt->annotation));
			(self_in_sizePCDependentInstructionAt->annotation) = null;
		}
	}
	return ((self_in_sizePCDependentInstructionAt->machineCodeSize) = (self_in_sizePCDependentInstructionAt->maxSize));
}
/*	Rewrite the literal in the instruction immediately preceding 
	followingAddress.  */
/* CogOutOfLineLiteralsARMv8Compiler>>#storeLiteral:beforeFollowingAddress: */
static AbstractInstruction * NoDbgRegParms
storeLiteralbeforeFollowingAddress(AbstractInstruction * self_in_storeLiteralbeforeFollowingAddress, sqInt _literal, sqInt _followingAddress)
{
	unsignedLongAtput(pcRelativeAddressAt(self_in_storeLiteralbeforeFollowingAddress, ((instructionIsLDR(self_in_storeLiteralbeforeFollowingAddress, instructionBeforeAddress(self_in_storeLiteralbeforeFollowingAddress, _followingAddress)))
		 ? (/* begin instructionAddressBefore: */ _followingAddress - 4 /* end instructionAddressBefore: */)
		 : (/* begin instructionAddressBefore: */ (_followingAddress - 4) - 4 /* end instructionAddressBefore: */))), _literal);
	return self_in_storeLiteralbeforeFollowingAddress;
}
/*	Answer if the receiver uses an out-of-line literal. Needs only 
	to work for the opcodes created with gen:literal:operand: et al. */
/* CogOutOfLineLiteralsARMv8Compiler>>#usesOutOfLineLiteral */
static sqInt NoDbgRegParms
usesOutOfLineLiteral(AbstractInstruction * self_in_usesOutOfLineLiteral)
{
	usqInt _constant;
	sqInt _constant10;
	sqInt _constant11;
	sqInt _constant2;
	sqInt _constant3;
	sqInt _constant4;
	sqInt _constant5;
	sqInt _constant6;
	sqInt _constant7;
	sqInt _constant8;
	sqInt _constant9;
	sqInt _i;
	sqInt _i2;
	sqInt _i3;
	sqInt _i4;
	sqInt _i5;
	uint64_t _immediate;
	uint64_t _immediate2;
	uint32_t _immr;
	uint32_t _immr2;
	uint32_t _leadingOnes;
	uint32_t _leadingOnes2;
	uint64_t _mask;
	uint64_t _mask2;
	uint64_t _maskedImmediate;
	uint64_t _maskedImmediate2;
	uint32_t _n;
	uint32_t _n2;
	uint64_t _nimms;
	uint64_t _nimms2;
	sqInt _offset;
	sqInt _originalConstant;
	sqInt _originalConstant2;
	sqInt _quickConstant;
	sqInt _shiftedValue;
	sqInt _shiftedValue2;
	int _shiftMagnitude;
	int _shiftMagnitude2;
	sqInt _signedConstant;
	sqInt _signedConstant2;
	uint64_t _size;
	uint64_t _size2;
	uint32_t _trailingOnes;
	uint32_t _trailingOnes2;
	uint32_t _trailingZeros;
	uint32_t _trailingZeros2;
	sqInt _twoComplement;
	sqInt _twoComplement2;
	sqInt _twoComplement3;
	sqInt _twoComplement4;
	sqInt _twoComplement5;
	sqInt _value;
	sqInt _value2;

	switch ((self_in_usesOutOfLineLiteral->opcode)) {
		case CallFull:
		case JumpFull:
		case AddCwR:
		case AndCwR:
		case CmpCwR:
		case OrCwR:
		case SubCwR:
		case XorCwR:
		case MovePatcheableC32R:
		{
			return 1;
		}
		case AddCqR:
		{
			_constant = (self_in_usesOutOfLineLiteral->operands)[0];
			return ((SQABS(((sqLong) _constant ))) & 0xFFF) != (SQABS(_constant));
		}
		case AndCqR:
		case AndCqRR:
		{
			/* begin encodeLogicalImmediate:registerSize:ifPossible:ifNotPossible: */
			_immediate = ((uint64_t) ((self_in_usesOutOfLineLiteral->operands)[0]) );
			if ((_immediate == 0) || ((_immediate == (~((usqIntptr_t) 0 ))) || 0)) {
				return 1;
			}
			_size = sizeOfregisterSize(self_in_usesOutOfLineLiteral, _immediate, 64);
			_mask = ((usqInt) 0xFFFFFFFFFFFFFFFFULL ) >> (64 - _size);
			_maskedImmediate = _immediate & _mask;
			if (isShiftedMask(self_in_usesOutOfLineLiteral, _maskedImmediate)) {
				_trailingZeros = trailingZerosOf(self_in_usesOutOfLineLiteral, _maskedImmediate);
				_trailingOnes = trailingOnesOf(self_in_usesOutOfLineLiteral, ((usqInt) _maskedImmediate ) >> _trailingZeros);
			} else {
				_maskedImmediate = _maskedImmediate | (~((usqIntptr_t) _mask ));
				if (!(isShiftedMask(self_in_usesOutOfLineLiteral, ~((usqIntptr_t) _maskedImmediate )))) {
					return 1;
				}
				_leadingOnes = leadingOnesOf(self_in_usesOutOfLineLiteral, _maskedImmediate);
				_trailingZeros = 64 - _leadingOnes;
				_trailingOnes = (_leadingOnes + (trailingOnesOf(self_in_usesOutOfLineLiteral, _maskedImmediate))) - (64 - _size);
			}
			_immr = (_size - _trailingZeros) & (_size - 1);
			_nimms = ((~((usqIntptr_t) (_size - 1) )) << 1) & 0xFFFFFFFFFFFFFFFFULL;
			_nimms = _nimms | (_trailingOnes - 1);
			_n = ((((usqInt) _nimms ) >> 6) & 1) ^ 1;
			return 0;
			/* end encodeLogicalImmediate:registerSize:ifPossible:ifNotPossible: */
		}
		case CmpCqR:
		{
			if (((SQABS(((sqLong) ((self_in_usesOutOfLineLiteral->operands)[0]) ))) & 0xFFF) == (SQABS(((sqLong) ((self_in_usesOutOfLineLiteral->operands)[0]) )))) {
				return 0;
			}
			if (((((usqInt) ((sqInt) (((usqInt) (SQABS(((sqLong) ((self_in_usesOutOfLineLiteral->operands)[0]) ))) ) << 12) ) ) >> 12) & 0xFFF) == (SQABS(((sqLong) ((self_in_usesOutOfLineLiteral->operands)[0]) )))) {
				return 0;
			}
			return 1;
		}
		case CmpC32R:
		{
			/* begin rotateable8bitSignedImmediate:ifTrue:ifFalse: */
			_constant2 = (self_in_usesOutOfLineLiteral->operands)[0];
			_value = _constant2;
			while (1) {
				if ((_value & 0xFF) == _value) {
					return 0;
				}
				for (_i = 2; _i <= 30; _i += 2) {
					if ((_value & (((0xFFULL << _i) & 0xFFFFFFFFU) | (((usqInt) 0xFF ) >> (32 - _i)))) == _value) {
						return 0;
					}
				}
				if (!((_value == _constant2) && (_constant2 != 0))) 
					break;
				_value = -_constant2;
			}
			return 1;
			/* end rotateable8bitSignedImmediate:ifTrue:ifFalse: */
		}
		case OrCqR:
		case TstCqR:
		{
			/* begin encodeLogicalImmediate:registerSize:ifPossible:ifNotPossible: */
			_immediate2 = ((uint64_t) ((self_in_usesOutOfLineLiteral->operands)[0]) );
			if ((_immediate2 == 0) || ((_immediate2 == (~((usqIntptr_t) 0 ))) || 0)) {
				return 1;
			}
			_size2 = sizeOfregisterSize(self_in_usesOutOfLineLiteral, _immediate2, 64);
			_mask2 = ((usqInt) 0xFFFFFFFFFFFFFFFFULL ) >> (64 - _size2);
			_maskedImmediate2 = _immediate2 & _mask2;
			if (isShiftedMask(self_in_usesOutOfLineLiteral, _maskedImmediate2)) {
				_trailingZeros2 = trailingZerosOf(self_in_usesOutOfLineLiteral, _maskedImmediate2);
				_trailingOnes2 = trailingOnesOf(self_in_usesOutOfLineLiteral, ((usqInt) _maskedImmediate2 ) >> _trailingZeros2);
			} else {
				_maskedImmediate2 = _maskedImmediate2 | (~((usqIntptr_t) _mask2 ));
				if (!(isShiftedMask(self_in_usesOutOfLineLiteral, ~((usqIntptr_t) _maskedImmediate2 )))) {
					return 1;
				}
				_leadingOnes2 = leadingOnesOf(self_in_usesOutOfLineLiteral, _maskedImmediate2);
				_trailingZeros2 = 64 - _leadingOnes2;
				_trailingOnes2 = (_leadingOnes2 + (trailingOnesOf(self_in_usesOutOfLineLiteral, _maskedImmediate2))) - (64 - _size2);
			}
			_immr2 = (_size2 - _trailingZeros2) & (_size2 - 1);
			_nimms2 = ((~((usqIntptr_t) (_size2 - 1) )) << 1) & 0xFFFFFFFFFFFFFFFFULL;
			_nimms2 = _nimms2 | (_trailingOnes2 - 1);
			_n2 = ((((usqInt) _nimms2 ) >> 6) & 1) ^ 1;
			return 0;
			/* end encodeLogicalImmediate:registerSize:ifPossible:ifNotPossible: */
		}
		case SubCqR:
		{
			_constant = (self_in_usesOutOfLineLiteral->operands)[0];
			return (_constant & 0xFFF) != _constant;
		}
		case XorCqR:
		{
			/* begin rotateable8bitBitwiseImmediate:ifTrue:ifFalse: */
			_constant3 = (self_in_usesOutOfLineLiteral->operands)[0];
			_value2 = _constant3;
			while (1) {
				if ((_value2 & 0xFF) == _value2) {
					return 0;
				}
				for (_i2 = 2; _i2 <= 30; _i2 += 2) {
					if ((_value2 & (((0xFFULL << _i2) & 0xFFFFFFFFU) | (((usqInt) 0xFF ) >> (32 - _i2)))) == _value2) {
						return 0;
					}
				}
				if (!(_value2 == _constant3)) 
					break;
				_value2 = ((_constant3 < 0)
					 ? -1 - _constant3
					 : ((unsigned int) (~_constant3) ));
			}
			return 1;
			/* end rotateable8bitBitwiseImmediate:ifTrue:ifFalse: */
		}
		case LoadEffectiveAddressMwrR:
		case MoveM16rR:
		{
			/* begin rotateable8bitImmediate:ifTrue:ifFalse: */
			_constant4 = (self_in_usesOutOfLineLiteral->operands)[0];
			if ((_constant4 & 0xFF) == _constant4) {
				return 0;
			}
			for (_i3 = 2; _i3 <= 30; _i3 += 2) {
				if ((_constant4 & (((0xFFULL << _i3) & 0xFFFFFFFFU) | (((usqInt) 0xFF ) >> (32 - _i3)))) == _constant4) {
					return 0;
				}
			}
			return 1;
			/* end rotateable8bitImmediate:ifTrue:ifFalse: */
		}
		case MoveCqR:
		case MoveC32R:
		{
			_quickConstant = (self_in_usesOutOfLineLiteral->operands)[0];
			return ((_quickConstant < 0) && (!(isShiftable16bitImmediate(self_in_usesOutOfLineLiteral, -_quickConstant - 1)))) || (!(isShiftable16bitImmediate(self_in_usesOutOfLineLiteral, _quickConstant)));
		}
		case MoveCwR:
		case PushCw:
		{
			return !(((addressIsInInstructions(((AbstractInstruction *) ((self_in_usesOutOfLineLiteral->operands)[0]) ))) || (((AbstractInstruction *) ((self_in_usesOutOfLineLiteral->operands)[0]) ) == (methodLabel()))) || ((((usqInt) ((self_in_usesOutOfLineLiteral->operands)[0]) ) >= ((methodLabel->address))) && (((usqInt) ((self_in_usesOutOfLineLiteral->operands)[0]) ) < (youngReferrers()))));
		}
		case MoveAwR:
		case MoveAbR:
		case PrefetchAw:
		{
			return (((((self_in_usesOutOfLineLiteral->operands)[0]) != null) && ((((self_in_usesOutOfLineLiteral->operands)[0]) >= (varBaseAddress())) && ((((self_in_usesOutOfLineLiteral->operands)[0]) - (varBaseAddress())) < (1U << 12))))
				 ? 0
				 : 1);
		}
		case MoveRAw:
		case MoveRAb:
		{
			return (((((self_in_usesOutOfLineLiteral->operands)[1]) != null) && ((((self_in_usesOutOfLineLiteral->operands)[1]) >= (varBaseAddress())) && ((((self_in_usesOutOfLineLiteral->operands)[1]) - (varBaseAddress())) < (1U << 12))))
				 ? 0
				 : 1);
		}
		case MoveRM32r:
		case MoveRMwr:
		{
			/* begin is9BitValue:ifTrue:ifFalse: */
			_originalConstant = (self_in_usesOutOfLineLiteral->operands)[1];
			_constant6 = ((sqInt) _originalConstant );
			if (((SQABS(_constant6)) <= 0xFF) || (_constant6 == -256)) {
				_twoComplement = ((_constant6 >= 0)
					 ? _constant6
					 : (0x1FF - (SQABS(_constant6))) + 1);
				{
					return 0;
				}
			} else {
				{
					/* begin shiftable16bitImmediate:ifTrue:ifFalse: */
					_constant5 = (self_in_usesOutOfLineLiteral->operands)[1];
					if ((_constant5 & 0xFFFF) == _constant5) {
						{
							return 0;
						}
						goto l5;
					}
					for (_i4 = 0; _i4 <= 1; _i4 += 1) {
						_shiftMagnitude = (1ULL << _i4) * 16;
						_shiftedValue = ((usqInt) _constant5 ) >> _shiftMagnitude;
						if ((((sqInt) (((usqInt) _shiftedValue ) << _shiftMagnitude) ) == _constant5) && ((_shiftedValue & 0xFFFF) == _shiftedValue)) {
							{
								return 0;
							}
							goto l5;
						}
					}
					{
						return 1;
					}
					l5:
					;
					/* end shiftable16bitImmediate:ifTrue:ifFalse: */
				}
			}
			/* end is9BitValue:ifTrue:ifFalse: */
		}
		break;
		case MoveRsM32r:
		case MoveRdM64r:
		case MoveRMbr:
		case MoveRM8r:
		case MoveRM16r:
		{
			/* begin is12BitValue:ifTrue:ifFalse: */
			_constant7 = (self_in_usesOutOfLineLiteral->operands)[1];
			_signedConstant = ((sqInt) _constant7 );
			return (((SQABS(_signedConstant)) <= 0x7FF)
				 ? ((_twoComplement2 = ((_signedConstant >= 0)
					 ? _signedConstant
					 : (0xFFF - (SQABS(_signedConstant))) + 1)), 0)
				 : 1);
			/* end is12BitValue:ifTrue:ifFalse: */
		}
		case MoveMbrR:
		{
			/* begin is9BitValue:ifTrue:ifFalse: */
			_originalConstant2 = (self_in_usesOutOfLineLiteral->operands)[0];
			_constant8 = ((sqInt) _originalConstant2 );
			return ((((SQABS(_constant8)) <= 0xFF) || (_constant8 == -256))
				 ? ((_twoComplement3 = ((_constant8 >= 0)
					 ? _constant8
					 : (0x1FF - (SQABS(_constant8))) + 1)), 0)
				 : 1);
			/* end is9BitValue:ifTrue:ifFalse: */
		}
		case MoveM32rRs:
		case MoveM64rRd:
		{
			/* begin is12BitValue:ifTrue:ifFalse: */
			_constant9 = (self_in_usesOutOfLineLiteral->operands)[0];
			_signedConstant2 = ((sqInt) _constant9 );
			return (((SQABS(_signedConstant2)) <= 0x7FF)
				 ? ((_twoComplement4 = ((_signedConstant2 >= 0)
					 ? _signedConstant2
					 : (0xFFF - (SQABS(_signedConstant2))) + 1)), 0)
				 : 1);
			/* end is12BitValue:ifTrue:ifFalse: */
		}
		case MoveM32rR:
		case MoveMwrR:
		{
			_offset = (self_in_usesOutOfLineLiteral->operands)[0];
			if ((_offset >= 0) && ((_offset & 0xFFF) == _offset)) {
				return 0;
			} else {
				/* begin is9BitValue:ifTrue:ifFalse: */
				_constant10 = ((sqInt) _offset );
				if (((SQABS(_constant10)) <= 0xFF) || (_constant10 == -256)) {
					_twoComplement5 = ((_constant10 >= 0)
						 ? _constant10
						 : (0x1FF - (SQABS(_constant10))) + 1);
					{
						return 0;
					}
				} else {
					{
						return 1;
					}
				}
				/* end is9BitValue:ifTrue:ifFalse: */
			}
		}
		break;
		case PushCq:
		{
			/* begin shiftable16bitImmediate:ifTrue:ifFalse: */
			_constant11 = (self_in_usesOutOfLineLiteral->operands)[0];
			if ((_constant11 & 0xFFFF) == _constant11) {
				return 0;
			}
			for (_i5 = 0; _i5 <= 1; _i5 += 1) {
				_shiftMagnitude2 = (1ULL << _i5) * 16;
				_shiftedValue2 = ((usqInt) _constant11 ) >> _shiftMagnitude2;
				if ((((sqInt) (((usqInt) _shiftedValue2 ) << _shiftMagnitude2) ) == _constant11) && ((_shiftedValue2 & 0xFFFF) == _shiftedValue2)) {
					return 0;
				}
			}
			return 1;
			/* end shiftable16bitImmediate:ifTrue:ifFalse: */
		}
		default:
		{
			error("We should not be here!!!");
		}
	}
	return 0;
}
/*	Copy the value of the current entry to the register argument. 
	Do not touch the stack */
/* CogSimStackEntry>>#copyToReg: */
static SimStackEntry * NoDbgRegParms
copyToReg(SimStackEntry * self_in_copyToReg, sqInt _reg)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	sqInt _literal;
	sqInt _quickConstant;
	sqInt _reg1;

	switch ((self_in_copyToReg->type)) {
		case SSBaseOffset:
		case SSSpill:
		{
			/* begin checkQuickConstant:forInstruction: */
			_literal = (self_in_copyToReg->offset);
			_anInstruction = genoperandoperandoperand(MoveMwrR, (self_in_copyToReg->offset), (self_in_copyToReg->registerr), _reg);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(_literal));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		break;
		case SSConstant:
		{
			if (shouldAnnotateObjectReference((self_in_copyToReg->constant))) {
				annotateobjRef(gMoveCwR((self_in_copyToReg->constant), _reg), (self_in_copyToReg->constant));
			} else {
				/* begin MoveCq:R: */
				_quickConstant = (self_in_copyToReg->constant);
				/* begin checkQuickConstant:forInstruction: */
				_anInstruction2 = genoperandoperand(MoveCqR, _quickConstant, _reg);
				if (usesOutOfLineLiteral(_anInstruction2)) {
					(_anInstruction2->dependent = locateLiteral(_quickConstant));
				}
				/* end checkQuickConstant:forInstruction: */
				/* end MoveCq:R: */
			}
		}
		break;
		case SSRegister:
		{
			if (_reg == ((self_in_copyToReg->registerr))) {
				/* begin Label */
				genoperandoperand(Label, (labelCounter += 1), bytecodePC);
				/* end Label */
			} else {
				/* begin MoveR:R: */
				_reg1 = (self_in_copyToReg->registerr);
				genoperandoperand(MoveRR, _reg1, _reg);
				/* end MoveR:R: */
			}
		}
		break;
		default:
		error("Case not found and no otherwise clause");
	}
	return self_in_copyToReg;
}
/* CogSimStackEntry>>#ensureSpilledAt:from: */
static SimStackEntry * NoDbgRegParms
ensureSpilledAtfrom(SimStackEntry * self_in_ensureSpilledAtfrom, sqInt _baseOffset, sqInt _baseRegister)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_inst;
	sqInt _literal;
	sqInt _reg;
	sqInt _wordConstant;

	if ((self_in_ensureSpilledAtfrom->spilled)) {
		if (((self_in_ensureSpilledAtfrom->type)) == SSSpill) {
			assert(((((self_in_ensureSpilledAtfrom->offset)) == _baseOffset) && (((self_in_ensureSpilledAtfrom->registerr)) == _baseRegister)) || (violatesEnsureSpilledSpillAssert()));
			return self_in_ensureSpilledAtfrom;
		}
	}
	assert(((self_in_ensureSpilledAtfrom->type)) != SSSpill);
	traceSpill(self_in_ensureSpilledAtfrom);
	if (((self_in_ensureSpilledAtfrom->type)) == SSConstant) {
		if (shouldAnnotateObjectReference((self_in_ensureSpilledAtfrom->constant))) {
			_inst = annotateobjRef(gPushCw((self_in_ensureSpilledAtfrom->constant)), (self_in_ensureSpilledAtfrom->constant));
		} else {
			/* begin PushCq: */
			_wordConstant = (self_in_ensureSpilledAtfrom->constant);
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperand(PushCq, _wordConstant);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(_wordConstant));
			}
			_inst = _anInstruction;
			/* end checkQuickConstant:forInstruction: */
			/* end PushCq: */
		}
	} else {
		if (((self_in_ensureSpilledAtfrom->type)) == SSBaseOffset) {
			/* begin checkQuickConstant:forInstruction: */
			_literal = (self_in_ensureSpilledAtfrom->offset);
			_anInstruction2 = genoperandoperandoperand(MoveMwrR, (self_in_ensureSpilledAtfrom->offset), (self_in_ensureSpilledAtfrom->registerr), TempReg);
			if (usesOutOfLineLiteral(_anInstruction2)) {
				(_anInstruction2->dependent = locateLiteral(_literal));
			}
			/* end checkQuickConstant:forInstruction: */
			/* begin PushR: */
			_inst = genoperand(PushR, TempReg);
			/* end PushR: */
		} else {
			assert(((self_in_ensureSpilledAtfrom->type)) == SSRegister);
			/* begin PushR: */
			_reg = (self_in_ensureSpilledAtfrom->registerr);
			_inst = genoperand(PushR, _reg);
			/* end PushR: */
		}
		(self_in_ensureSpilledAtfrom->type) = SSSpill;
		(self_in_ensureSpilledAtfrom->offset) = _baseOffset;
		(self_in_ensureSpilledAtfrom->registerr) = _baseRegister;
	}
	(self_in_ensureSpilledAtfrom->spilled) = 1;
	return self_in_ensureSpilledAtfrom;
}
/* CogSimStackEntry>>#isSameEntryAs: */
static sqInt NoDbgRegParms
isSameEntryAs(SimStackEntry * self_in_isSameEntryAs, CogSimStackEntry *_ssEntry)
{
	return (((self_in_isSameEntryAs->type)) == ((_ssEntry->type))) && ((((((self_in_isSameEntryAs->type)) == SSBaseOffset) || (((self_in_isSameEntryAs->type)) == SSSpill)) && ((((self_in_isSameEntryAs->offset)) == ((_ssEntry->offset))) && (((self_in_isSameEntryAs->registerr)) == ((_ssEntry->registerr))))) || (((((self_in_isSameEntryAs->type)) == SSRegister) && (((self_in_isSameEntryAs->registerr)) == ((_ssEntry->registerr)))) || ((((self_in_isSameEntryAs->type)) == SSConstant) && (((self_in_isSameEntryAs->constant)) == ((_ssEntry->constant))))));
}
/* CogSimStackEntry>>#moveToVectorReg: */
static SimStackEntry * NoDbgRegParms
moveToVectorReg(SimStackEntry * self_in_moveToVectorReg, sqInt _reg)
{
	assert(((self_in_moveToVectorReg->type)) == SSVectorRegister);
	if ((self_in_moveToVectorReg->spilled)) {
		/* begin notYetImplemented */
		/* begin notYetImplemented: */
		{
			logError("Not Yet Implemented!");
			abort();
		}
		/* end notYetImplemented: */
		/* end notYetImplemented */
	} else {
		switch ((self_in_moveToVectorReg->type)) {
			case SSVectorRegister:
			{
				if (_reg != ((self_in_moveToVectorReg->registerr))) {
					/* begin notYetImplemented */
					/* begin notYetImplemented: */
					{
						logError("Not Yet Implemented!");
						abort();
					}
					/* end notYetImplemented: */
					/* end notYetImplemented */
				} else {
					/* begin Label */
					genoperandoperand(Label, (labelCounter += 1), bytecodePC);
					/* end Label */
				}
			}
			break;
			default:
			error("Case not found and no otherwise clause");
		}
	}
	return self_in_moveToVectorReg;
}
/*	Answer a bit mask for the receiver's register, if any. */
/* CogSimStackEntry>>#registerMask */
static sqInt NoDbgRegParms
registerMask(SimStackEntry * self_in_registerMask)
{
	sqInt _reg;

	return (((((self_in_registerMask->type)) == SSBaseOffset) || ((((self_in_registerMask->type)) == SSRegister) || (((self_in_registerMask->type)) == SSVectorRegister)))
		 ? (/* begin registerMaskFor: */ (_reg = (self_in_registerMask->registerr)), 1ULL << _reg /* end registerMaskFor: */)
		 : 0);
}
/* CogSimStackEntry>>#registerMaskOrNone */
static sqInt NoDbgRegParms
registerMaskOrNone(SimStackEntry * self_in_registerMaskOrNone)
{
	sqInt _reg;

	return (((((self_in_registerMaskOrNone->type)) == SSRegister) || (((self_in_registerMaskOrNone->type)) == SSVectorRegister))
		 ? (/* begin registerMaskFor: */ (_reg = (self_in_registerMaskOrNone->registerr)), 1ULL << _reg /* end registerMaskFor: */)
		 : 0);
}
/* CogSimStackEntry>>#registerOrNone */
static signed char NoDbgRegParms
registerOrNone(SimStackEntry * self_in_registerOrNone)
{
	return (((((self_in_registerOrNone->type)) == SSRegister) || (((self_in_registerOrNone->type)) == SSVectorRegister))
		 ? (self_in_registerOrNone->registerr)
		 : NoReg);
}
/* CogSSBytecodeFixup>>#isMergeFixup */
static sqInt NoDbgRegParms
isMergeFixup(BytecodeFixup * self_in_isMergeFixup)
{
	return ((usqInt) ((self_in_isMergeFixup->targetInstruction)) ) == NeedsMergeFixupFlag;
}
/*	Allocate an unsharable Literal instruction for the literal and answer it. */
/* OutOfLineLiteralsManager>>#allocateLiteral: */
static AbstractInstruction * NoDbgRegParms
allocateLiteral(sqInt _aLiteral)
{
	AbstractInstruction *_existingInst;
	sqInt _i;
	sqInt _iLimit;
	sqInt _initialNumLiterals;
	AbstractInstruction *_litInst;
	AbstractInstruction *_newInst;
	AbstractInstruction *_newLiterals;

	if (nextLiteralIndex >= literalsSize) {
		/* begin allocateLiterals: */
		_initialNumLiterals = literalsSize + 8;
		if (_initialNumLiterals > literalsSize) {
			_newLiterals = calloc(_initialNumLiterals, sizeof(CogAbstractInstruction));
			if (literals) {
				for (_i = 0; _i < nextLiteralIndex; _i += 1) {
					_existingInst = literalInstructionAt(_i);
					_newInst = &(_newLiterals[_i]);
					cloneLiteralFrom(_newInst, _existingInst);
					assert(((_existingInst->dependent)) == null);
					(_existingInst->dependent = _newInst);
				}
				for (_i = 0, _iLimit = opcodeIndex - 1; _i <= _iLimit; _i += 1) {
					_existingInst = abstractInstructionAt(_i);
					if ((((_existingInst->dependent)) != null) && (((((_existingInst->dependent))->opcode)) == Literal)) {
						(_existingInst->dependent = (((_existingInst->dependent))->dependent));
					}
				}
			}
			free(literals);
			literals = _newLiterals;
			literalsSize = _initialNumLiterals;
		}
		/* end allocateLiterals: */
	}
	_litInst = literalInstructionAt(nextLiteralIndex);
	initializeUniqueLiteral(_litInst, _aLiteral);
	nextLiteralIndex += 1;
	if (firstOpcodeIndex > opcodeIndex) {
		firstOpcodeIndex = opcodeIndex - 1;
	}
	return _litInst;
}
/* OutOfLineLiteralsManager>>#checkLiteral:forInstruction: */
static AbstractInstruction * NoDbgRegParms
checkLiteralforInstruction(sqInt _literal, AbstractInstruction *_anInstruction)
{
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_literal));
	}
	return _anInstruction;
}
/* OutOfLineLiteralsManager>>#checkQuickConstant:forInstruction: */
static AbstractInstruction * NoDbgRegParms
checkQuickConstantforInstruction(sqInt _literal, AbstractInstruction *_anInstruction)
{
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_literal));
	}
	return _anInstruction;
}
/*	Output all pending literal instructions, making the originals dependents 
	of the generated ones 
	so that a later pass will copy the address of each generated literl inst 
	to its original in literals, 
	and hence allow the instruction using the literal to compute the correct 
	address..  */
/* OutOfLineLiteralsManager>>#dumpLiterals: */
static sqInt NoDbgRegParms
dumpLiterals(sqInt _generateBranchAround)
{
	sqInt _alignment;
	sqInt _i;
	sqInt _index;
	AbstractInstruction *_jump;
	AbstractInstruction *_litInst;

	_jump = ((AbstractInstruction *) 0 );
	if (_generateBranchAround) {
		/* begin Jump: */
		_jump = genoperand(Jump, ((sqInt) 0 ));
		/* end Jump: */
	}
	/* begin AlignmentNops: */
	_alignment = BytesPerWord;
	genoperand(AlignmentNops, _alignment);
	/* end AlignmentNops: */
	for (_i = lastDumpedLiteralIndex; _i < nextLiteralIndex; _i += 1) {
		_litInst = literalInstructionAt(_i);
		((genoperand(Literal, (_litInst->operands)[0]))->dependent = _litInst);
		/* begin setLiteralOpcodeIndex: */
		_index = opcodeIndex;
		assert(((_litInst->opcode)) == Literal);
		(_litInst->operands)[2] = _index;
		/* end setLiteralOpcodeIndex: */
	}
	if (_generateBranchAround) {
		jmpTarget(_jump, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	/* begin getOpcodeIndex */
	firstOpcodeIndex = opcodeIndex;
	/* end getOpcodeIndex */
	lastDumpedLiteralIndex = nextLiteralIndex;
	return 0;
}
/*	return the offset need from the cPICEndSize in order to point to just 
	after the last instruction - here that means bytesPerOop * list size */
/* OutOfLineLiteralsManager>>#endSizeOffset */
static sqInt
endSizeOffset(void)
{
	return nextLiteralIndex * BytesPerOop;
}
/*	A literal is in range if its opcode index is within 
	outOfLineLiteralOpcodeLimit, or if its index has yet to be assigned. */
/* OutOfLineLiteralsManager>>#literalInstructionInRange: */
static sqInt NoDbgRegParms
literalInstructionInRange(AbstractInstruction *_litInst)
{
	sqInt _opcodeIdx;

	/* begin literalOpcodeIndex */
	assert(((_litInst->opcode)) == Literal);
	_opcodeIdx = ((sqInt) ((_litInst->operands)[2]) );
	/* end literalOpcodeIndex */
	return (((sqInt) _opcodeIdx ) < 0) || ((assert((getOpcodeIndex()) >= _opcodeIdx), (opcodeIndex - _opcodeIdx) < (outOfLineLiteralOpcodeLimit(backEnd()))));
}
/*	Search for a Literal instruction that is in-range and answer it. Otherwise 
	allocate a new sharable Literal instruction for the literal and answer it. */
/* OutOfLineLiteralsManager>>#locateLiteral: */
static AbstractInstruction * NoDbgRegParms
locateLiteral(sqInt _aLiteral)
{
	AbstractInstruction *_existingInst;
	sqInt _i;
	sqInt _i2;
	sqInt _iLimit;
	sqInt _initialNumLiterals;
	AbstractInstruction *_litInst;
	AbstractInstruction *_newInst;
	AbstractInstruction *_newLiterals;

	for (_i = 0; _i < nextLiteralIndex; _i += 1) {
		_litInst = literalInstructionAt(_i);
		if ((((_litInst->operands)[0]) == _aLiteral) && (((assert(((_litInst->opcode)) == Literal), (_litInst->operands)[1])) && (literalInstructionInRange(_litInst)))) {
			return _litInst;
		}
	}
	if (nextLiteralIndex >= literalsSize) {
		/* begin allocateLiterals: */
		_initialNumLiterals = literalsSize + 8;
		if (_initialNumLiterals > literalsSize) {
			_newLiterals = calloc(_initialNumLiterals, sizeof(CogAbstractInstruction));
			if (literals) {
				for (_i2 = 0; _i2 < nextLiteralIndex; _i2 += 1) {
					_existingInst = literalInstructionAt(_i2);
					_newInst = &(_newLiterals[_i2]);
					cloneLiteralFrom(_newInst, _existingInst);
					assert(((_existingInst->dependent)) == null);
					(_existingInst->dependent = _newInst);
				}
				for (_i2 = 0, _iLimit = opcodeIndex - 1; _i2 <= _iLimit; _i2 += 1) {
					_existingInst = abstractInstructionAt(_i2);
					if ((((_existingInst->dependent)) != null) && (((((_existingInst->dependent))->opcode)) == Literal)) {
						(_existingInst->dependent = (((_existingInst->dependent))->dependent));
					}
				}
			}
			free(literals);
			literals = _newLiterals;
			literalsSize = _initialNumLiterals;
		}
		/* end allocateLiterals: */
	}
	_litInst = literalInstructionAt(nextLiteralIndex);
	initializeSharableLiteral(_litInst, _aLiteral);
	nextLiteralIndex += 1;
	if (firstOpcodeIndex > opcodeIndex) {
		firstOpcodeIndex = opcodeIndex - 1;
	}
	return _litInst;
}
/* OutOfLineLiteralsManager>>#mustDumpLiterals: */
static sqInt NoDbgRegParms
mustDumpLiterals(sqInt _currentOpcodeIndex)
{
	return (_currentOpcodeIndex >= firstOpcodeIndex) && ((_currentOpcodeIndex - firstOpcodeIndex) >= (outOfLineLiteralOpcodeLimit(backEnd())));
}
/*	After pushing the temporaries but before the stack limit check a primitive 
	method needs to fetch the error code, if any. If the primitive has failed, 
	call the trampoline 
	that will assign it to the last temp. */
/* SimpleStackBasedCogit>>#compileGetErrorCode */
static void
compileGetErrorCode(void)
{
	AbstractInstruction *_abstractInstruction;
	sqInt _address;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_jmpNoError;

	/* begin MoveAw:R: */
	_address = primFailCodeAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, TempReg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	flag("ask concrete code gen if move sets condition codes?");
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(CmpCqR, 0, TempReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpZero: */
	_jmpNoError = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	addDependent(methodLabel, annotateAbsolutePCRef(gMoveCwR(((sqInt) methodLabel ), ClassReg)));
	/* begin CallRT: */
	/* begin annotateCall: */
	_abstractInstruction = genoperand(Call, ceReapAndResetErrorCodeTrampoline);
	(_abstractInstruction->annotation = IsRelativeCall);
	/* end annotateCall: */
	/* end CallRT: */
	jmpTarget(_jmpNoError, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
}
/* SimpleStackBasedCogit>>#compileInterpreterPrimitive */
static sqInt
compileInterpreterPrimitive(void)
{
	void (*_primitiveRoutine)(void);

	_primitiveRoutine = functionPointerForCompiledMethodprimitiveIndex(methodObj, primitiveIndex);
	return compileInterpreterPrimitiveflags(_primitiveRoutine, primitivePropertyFlagsprimitiveDescriptor(primitiveIndex, primitiveDescriptor()));
}
/*	Compile a call to an interpreter primitive. Call the C routine with the 
	usual stack-switching dance, test the primFailCode and then either 
	return on success or continue to the method body. */
/* SimpleStackBasedCogit>>#compileInterpreterPrimitiveMayCallBack:flags: */
static sqInt NoDbgRegParms
compileInterpreterPrimitiveMayCallBackflags(void (*_primitiveRoutine)(void), sqInt _flags)
{
	sqInt _address3;
	sqInt _address4;
	sqInt _address5;
	sqInt _address6;
	sqInt _address7;
	sqInt _address8;
	sqInt _address9;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	sqInt _arrivingJmp;
	CogPrimitiveCallState *_cogPrimitiveCallState;
	sqInt _offset;
	sqInt _operand2;
	sqInt _retpc;
	sqInt _returningLabel;

	_cogPrimitiveCallState = ((CogPrimitiveCallState*) (alloca(sizeof(CogPrimitiveCallState))) );
	genExternalizePointersForPrimitiveCall();
	genLoadCStackPointersForPrimCall();
	if (_flags & PrimCallCollectsProfileSamples) {
		{
			/* begin MoveAw:R: */
			_address3 = nextProfileTickAddress();
			/* begin gen:literal:operand: */
			checkLiteralforInstruction(_address3, genoperandoperand(MoveAwR, _address3, TempReg));
			/* end gen:literal:operand: */
			/* end MoveAw:R: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperand(CmpCqR, 0, TempReg);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		(_cogPrimitiveCallState->jmpSampleNonPrim = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 )));
		(_cogPrimitiveCallState->continuePostSampleNonPrim = genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	if (recordPrimTrace()) {
		genFastPrimTraceUsingand(ClassReg, SendNumArgsReg);
	}
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction5 = genoperandoperand(MoveCqR, 0, TempReg);
	if (usesOutOfLineLiteral(_anInstruction5)) {
		(_anInstruction5->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin MoveR:Aw: */
	_address7 = primFailCodeAddress();
	/* begin gen:operand:literal: */
	checkLiteralforInstruction(_address7, genoperandoperand(MoveRAw, TempReg, _address7));
	/* end gen:operand:literal: */
	/* end MoveR:Aw: */
	if (methodOrBlockNumArgs != 0) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(MoveCqR, methodOrBlockNumArgs, TempReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(methodOrBlockNumArgs));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin MoveR:Aw: */
	_address8 = argumentCountAddress();
	/* begin gen:operand:literal: */
	checkLiteralforInstruction(_address8, genoperandoperand(MoveRAw, TempReg, _address8));
	/* end gen:operand:literal: */
	/* end MoveR:Aw: */
	if (_flags & PrimCallNeedsPrimitiveFunction) {
		/* begin MoveCw:R: */
		/* begin gen:literal:operand: */
		checkLiteralforInstruction(((sqInt) _primitiveRoutine ), genoperandoperand(MoveCwR, ((sqInt) _primitiveRoutine ), TempReg));
		/* end gen:literal:operand: */
		/* end MoveCw:R: */
		/* begin MoveR:Aw: */
		_address4 = primitiveFunctionPointerAddress();
		/* begin gen:operand:literal: */
		primSetFunctionLabel = checkLiteralforInstruction(_address4, genoperandoperand(MoveRAw, TempReg, _address4));
		/* end gen:operand:literal: */
		/* end MoveR:Aw: */
	}
	if (_flags & (PrimCallNeedsNewMethod + PrimCallMayCallBack)) {
		if (_flags & PrimCallMayCallBack) {
			needsFrame = 1;
		}
		addDependent(methodLabel, annotateAbsolutePCRef(gMoveCwR(((sqInt) methodLabel ), ClassReg)));
		/* begin MoveMw:r:R: */
		_offset = offsetof(CogMethod, methodObject);
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperandoperand(MoveMwrR, _offset, ClassReg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(_offset));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
		/* begin MoveR:Aw: */
		_address5 = newMethodAddress();
		/* begin gen:operand:literal: */
		checkLiteralforInstruction(_address5, genoperandoperand(MoveRAw, TempReg, _address5));
		/* end gen:operand:literal: */
		/* end MoveR:Aw: */
	}
	/* begin PrefetchAw: */
	_address9 = primFailCodeAddress();
	/* begin gen:literal: */
	checkLiteralforInstruction(_address9, genoperand(PrefetchAw, _address9));
	/* end gen:literal: */
	/* end PrefetchAw: */
	assert(_flags & PrimCallNeedsPrimitiveFunction);
	{
		/* begin genMarshallNArgs:arg:arg:arg:arg: */
		{
			goto l16;
		}
		{
			genoperandoperand(MoveRR, 0, CArg0Reg);
		}
		{
			genoperandoperand(MoveRR, 0, CArg1Reg);
		}
		{
			genoperandoperand(MoveRR, 0, CArg2Reg);
		}
		{
			genoperandoperand(MoveRR, 0, CArg3Reg);
		}
		l16:
		;
		/* end genMarshallNArgs:arg:arg:arg:arg: */
		/* begin genSubstituteReturnAddress: */
		_retpc = ((_flags & PrimCallCollectsProfileSamples)
			 ? cePrimReturnEnterCogCodeProfiling
			 : cePrimReturnEnterCogCode);
		/* begin gen:literal:operand: */
		checkLiteralforInstruction(_retpc, genoperandoperand(MoveCwR, _retpc, LR));
		/* end gen:literal:operand: */
		/* end genSubstituteReturnAddress: */
	}
	{
		/* begin gen:literal: */
		primInvokeInstruction = checkLiteralforInstruction(((sqInt) ((sqInt) _primitiveRoutine ) ), genoperand(JumpFull, ((sqInt) ((sqInt) _primitiveRoutine ) )));
		/* end gen:literal: */
	}
	if (_flags & PrimCallCollectsProfileSamples) {
		/* begin generateCheckProfileTickFromJump:returningTo:beforeCallDo: */
		_arrivingJmp = ((sqInt) ((_cogPrimitiveCallState->jmpSampleNonPrim)) );
		_returningLabel = ((sqInt) ((_cogPrimitiveCallState->continuePostSampleNonPrim)) );
		jmpTarget(_arrivingJmp, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
		{
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction4 = genoperandoperand(MoveCqR, 0, TempReg);
			if (usesOutOfLineLiteral(_anInstruction4)) {
				(_anInstruction4->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
			/* begin MoveR:Aw: */
			_address6 = newMethodAddress();
			/* begin gen:operand:literal: */
			checkLiteralforInstruction(_address6, genoperandoperand(MoveRAw, TempReg, _address6));
			/* end gen:operand:literal: */
			/* end MoveR:Aw: */
		}
		{
			/* begin gen:literal: */
			_operand2 = ((usqIntptr_t) ceCheckProfileTick );
			checkLiteralforInstruction(_operand2, genoperand(CallFull, _operand2));
			/* end gen:literal: */
		}
		/* begin Jump: */
		genoperand(Jump, ((sqInt) ((void *) _returningLabel ) ));
		/* end Jump: */
		/* end generateCheckProfileTickFromJump:returningTo:beforeCallDo: */
	}
	return 0;
}
/*	Compile a call to an interpreter primitive. Call the C routine with the 
	usual stack-switching dance, test the primFailCode and then either 
	return on success or continue to the method body. */
/* SimpleStackBasedCogit>>#compileInterpreterPrimitive:flags: */
static sqInt NoDbgRegParms
compileInterpreterPrimitiveflags(void (*_primitiveRoutine)(void), sqInt _flags)
{
	sqInt _address10;
	sqInt _address11;
	sqInt _address12;
	sqInt _address13;
	sqInt _address14;
	sqInt _address3;
	sqInt _address4;
	sqInt _address5;
	sqInt _address8;
	sqInt _address9;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction *_anInstruction7;
	AbstractInstruction *_anInstruction8;
	AbstractInstruction *_anInstruction9;
	sqInt _arrivingJmp;
	sqInt _arrivingJmp2;
	CogPrimitiveCallState *_cogPrimitiveCallState;
	sqInt _offset;
	sqInt _offset2;
	sqInt _offset3;
	sqInt _operand2;
	sqInt _operand22;
	sqInt _reg;
	sqInt _returningLabel;
	sqInt _returningLabel2;

	if (_flags & PrimCallMayCallBack) {
		return compileInterpreterPrimitiveMayCallBackflags(_primitiveRoutine, _flags);
	}
	_cogPrimitiveCallState = ((CogPrimitiveCallState*) (alloca(sizeof(CogPrimitiveCallState))) );
	genExternalizePointersForPrimitiveCall();
	genLoadCStackPointersForPrimCall();
	if (_flags & PrimCallCollectsProfileSamples) {
		{
			/* begin MoveAw:R: */
			_address3 = nextProfileTickAddress();
			/* begin gen:literal:operand: */
			checkLiteralforInstruction(_address3, genoperandoperand(MoveAwR, _address3, TempReg));
			/* end gen:literal:operand: */
			/* end MoveAw:R: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperand(CmpCqR, 0, TempReg);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		(_cogPrimitiveCallState->jmpSampleNonPrim = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 )));
		(_cogPrimitiveCallState->continuePostSampleNonPrim = genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	if (recordPrimTrace()) {
		genFastPrimTraceUsingand(ClassReg, SendNumArgsReg);
	}
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction6 = genoperandoperand(MoveCqR, 0, TempReg);
	if (usesOutOfLineLiteral(_anInstruction6)) {
		(_anInstruction6->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin MoveR:Aw: */
	_address10 = primFailCodeAddress();
	/* begin gen:operand:literal: */
	checkLiteralforInstruction(_address10, genoperandoperand(MoveRAw, TempReg, _address10));
	/* end gen:operand:literal: */
	/* end MoveR:Aw: */
	if (methodOrBlockNumArgs != 0) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(MoveCqR, methodOrBlockNumArgs, TempReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(methodOrBlockNumArgs));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin MoveR:Aw: */
	_address11 = argumentCountAddress();
	/* begin gen:operand:literal: */
	checkLiteralforInstruction(_address11, genoperandoperand(MoveRAw, TempReg, _address11));
	/* end gen:operand:literal: */
	/* end MoveR:Aw: */
	if (_flags & PrimCallNeedsPrimitiveFunction) {
		/* begin MoveCw:R: */
		/* begin gen:literal:operand: */
		checkLiteralforInstruction(((sqInt) _primitiveRoutine ), genoperandoperand(MoveCwR, ((sqInt) _primitiveRoutine ), TempReg));
		/* end gen:literal:operand: */
		/* end MoveCw:R: */
		/* begin MoveR:Aw: */
		_address4 = primitiveFunctionPointerAddress();
		/* begin gen:operand:literal: */
		primSetFunctionLabel = checkLiteralforInstruction(_address4, genoperandoperand(MoveRAw, TempReg, _address4));
		/* end gen:operand:literal: */
		/* end MoveR:Aw: */
	}
	if (_flags & (PrimCallNeedsNewMethod + PrimCallMayCallBack)) {
		if (_flags & PrimCallMayCallBack) {
			needsFrame = 1;
		}
		addDependent(methodLabel, annotateAbsolutePCRef(gMoveCwR(((sqInt) methodLabel ), ClassReg)));
		/* begin MoveMw:r:R: */
		_offset = offsetof(CogMethod, methodObject);
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperandoperand(MoveMwrR, _offset, ClassReg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(_offset));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
		/* begin MoveR:Aw: */
		_address5 = newMethodAddress();
		/* begin gen:operand:literal: */
		checkLiteralforInstruction(_address5, genoperandoperand(MoveRAw, TempReg, _address5));
		/* end gen:operand:literal: */
		/* end MoveR:Aw: */
	}
	/* begin PrefetchAw: */
	_address12 = primFailCodeAddress();
	/* begin gen:literal: */
	checkLiteralforInstruction(_address12, genoperand(PrefetchAw, _address12));
	/* end gen:literal: */
	/* end PrefetchAw: */
	/* begin genMarshallNArgs:arg:arg:arg:arg: */
	{
		goto l30;
	}
	{
		genoperandoperand(MoveRR, 0, CArg0Reg);
	}
	{
		genoperandoperand(MoveRR, 0, CArg1Reg);
	}
	{
		genoperandoperand(MoveRR, 0, CArg2Reg);
	}
	{
		genoperandoperand(MoveRR, 0, CArg3Reg);
	}
	l30:
	;
	/* end genMarshallNArgs:arg:arg:arg:arg: */
	{
		/* begin gen:literal: */
		primInvokeInstruction = checkLiteralforInstruction(((sqInt) _primitiveRoutine ), genoperand(CallFull, ((sqInt) _primitiveRoutine )));
		/* end gen:literal: */
	}
	/* begin genRemoveNArgsFromStack: */
	assert(0 <= 4);
	/* end genRemoveNArgsFromStack: */
	if (_flags & PrimCallCollectsProfileSamples) {
		assert(_flags & PrimCallNeedsNewMethod);
		{
			/* begin MoveAw:R: */
			_address8 = nextProfileTickAddress();
			/* begin gen:literal:operand: */
			checkLiteralforInstruction(_address8, genoperandoperand(MoveAwR, _address8, TempReg));
			/* end gen:literal:operand: */
			/* end MoveAw:R: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction4 = genoperandoperand(CmpCqR, 0, TempReg);
			if (usesOutOfLineLiteral(_anInstruction4)) {
				(_anInstruction4->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		(_cogPrimitiveCallState->jmpSamplePrim = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 )));
		(_cogPrimitiveCallState->continuePostSamplePrim = genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	maybeCompileRetryOnPrimitiveFail(primitiveIndex);
	maybeCompileAllocFillerCheck();
	/* begin MoveAw:R: */
	_address13 = instructionPointerAddress();
	_reg = LinkReg;
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address13, genoperandoperand(MoveAwR, _address13, _reg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	genLoadStackPointers(backEnd);
	/* begin MoveAw:R: */
	_address14 = primFailCodeAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address14, genoperandoperand(MoveAwR, _address14, TempReg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	flag("ask concrete code gen if move sets condition codes?");
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction7 = genoperandoperand(CmpCqR, 0, TempReg);
	if (usesOutOfLineLiteral(_anInstruction7)) {
		(_anInstruction7->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	(_cogPrimitiveCallState->jmpToFallbackCode = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 )));
	/* begin MoveMw:r:R: */
	_offset2 = 0;
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction8 = genoperandoperandoperand(MoveMwrR, _offset2, SPReg, ReceiverResultReg);
	if (usesOutOfLineLiteral(_anInstruction8)) {
		(_anInstruction8->dependent = locateLiteral(_offset2));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end MoveMw:r:R: */
	/* begin RetN: */
	genoperand(RetN, BytesPerWord);
	/* end RetN: */
	if (_flags & PrimCallCollectsProfileSamples) {
		/* begin generateCheckProfileTickFromJump:returningTo:beforeCallDo: */
		_arrivingJmp = ((sqInt) ((_cogPrimitiveCallState->jmpSamplePrim)) );
		_returningLabel = ((sqInt) ((_cogPrimitiveCallState->continuePostSamplePrim)) );
		jmpTarget(_arrivingJmp, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
		{
		}
		{
			/* begin gen:literal: */
			_operand2 = ((usqIntptr_t) ceCheckProfileTick );
			checkLiteralforInstruction(_operand2, genoperand(CallFull, _operand2));
			/* end gen:literal: */
		}
		/* begin Jump: */
		genoperand(Jump, ((sqInt) ((void *) _returningLabel ) ));
		/* end Jump: */
		/* end generateCheckProfileTickFromJump:returningTo:beforeCallDo: */
		/* begin generateCheckProfileTickFromJump:returningTo:beforeCallDo: */
		_arrivingJmp2 = ((sqInt) ((_cogPrimitiveCallState->jmpSampleNonPrim)) );
		_returningLabel2 = ((sqInt) ((_cogPrimitiveCallState->continuePostSampleNonPrim)) );
		jmpTarget(_arrivingJmp2, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
		{
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction5 = genoperandoperand(MoveCqR, 0, TempReg);
			if (usesOutOfLineLiteral(_anInstruction5)) {
				(_anInstruction5->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
			/* begin MoveR:Aw: */
			_address9 = newMethodAddress();
			/* begin gen:operand:literal: */
			checkLiteralforInstruction(_address9, genoperandoperand(MoveRAw, TempReg, _address9));
			/* end gen:operand:literal: */
			/* end MoveR:Aw: */
		}
		{
			/* begin gen:literal: */
			_operand22 = ((usqIntptr_t) ceCheckProfileTick );
			checkLiteralforInstruction(_operand22, genoperand(CallFull, _operand22));
			/* end gen:literal: */
		}
		/* begin Jump: */
		genoperand(Jump, ((sqInt) ((void *) _returningLabel2 ) ));
		/* end Jump: */
		/* end generateCheckProfileTickFromJump:returningTo:beforeCallDo: */
	}
	jmpTarget((_cogPrimitiveCallState->jmpToFallbackCode), genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	/* begin MoveMw:r:R: */
	_offset3 = BytesPerWord * (methodOrBlockNumArgs + 0);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction9 = genoperandoperandoperand(MoveMwrR, _offset3, SPReg, ReceiverResultReg);
	if (usesOutOfLineLiteral(_anInstruction9)) {
		(_anInstruction9->dependent = locateLiteral(_offset3));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end MoveMw:r:R: */
	return 0;
}
/*	Compile a call to a machine-code convention interpreter primitive. Call 
	the C routine 
	on the Smalltalk stack, assuming it consumes little or no stack space.for now handle functions with less than 4 arguments; our C call 
	marshalling machinery 
	extends up to 4 arguments only, and the first argument of an mcprim is the 
	receiver.  */
/* SimpleStackBasedCogit>>#compileMachineCodeInterpreterPrimitive: */
static sqInt NoDbgRegParms
compileMachineCodeInterpreterPrimitive(void (*_primitiveRoutine)(void))
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction * _jmpFail;
	sqInt _liveRegsMask;
	sqInt _n;
	sqInt _offset;
	sqInt _reg;
	sqInt _reg1;
	sqInt _reg2;
	int _registerCount;
	int _registerCount2;
	sqInt _regMask;
	sqInt _regMask2;

	assert(methodOrBlockNumArgs <= 3);
	if ((methodOrBlockNumArgs > 2) || (methodOrBlockNumArgs == 0)) {
		/* begin registerMaskFor:and: */
		_liveRegsMask = (1U << ReceiverResultReg) | (1U << ClassReg);
		/* end registerMaskFor:and: */
	} else {
		if (methodOrBlockNumArgs > 1) {
			/* begin registerMaskFor:and:and:and: */
			_liveRegsMask = (((1U << ReceiverResultReg) | (1U << Arg0Reg)) | (1U << Arg1Reg)) | (1U << ClassReg);
			/* end registerMaskFor:and:and:and: */
		}
 else {
			/* begin registerMaskFor:and:and: */
			_liveRegsMask = ((1U << ReceiverResultReg) | (1U << Arg0Reg)) | (1U << ClassReg);
			/* end registerMaskFor:and:and: */
		}
	}
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, LinkReg, Extra0Reg);
		/* end MoveR:R: */
	}
	/* begin genSaveRegs: */
	_regMask2 = _liveRegsMask & CallerSavedRegisterMask;
	assert(((R12 - R1) + 1) == 12);
	assert(!(_regMask2 & (registerMaskForand(SPReg, FPReg))));
	_registerCount2 = 0;
	for (_reg2 = R12; _reg2 >= R1; _reg2 += -1) {
		if (_regMask2 & (1ULL << _reg2)) {
			_registerCount2 += 1;
		}
	}
	if (!((_registerCount2 % 2) == 0)) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperand(PushCq, 48879);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(48879));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	for (_reg2 = R12; _reg2 >= R1; _reg2 += -1) {
		if (_regMask2 & (1ULL << _reg2)) {
			genoperand(PushR, _reg2);
		}
	}
	/* end genSaveRegs: */
	if (methodOrBlockNumArgs > 2) {
		error("shouldBeImplemented");
	}
	prepareStackToCallCFunctionInSmalltalkStack(backEnd, methodOrBlockNumArgs + 1);
	/* begin genMarshallNArgs:arg:arg:arg:arg: */
	if ((methodOrBlockNumArgs + 1) == 0) {
		goto l15;
	}
	{
		genoperandoperand(MoveRR, ReceiverResultReg, CArg0Reg);
	}
	if ((methodOrBlockNumArgs + 1) == 1) {
		goto l15;
	}
	{
		genoperandoperand(MoveRR, Arg0Reg, CArg1Reg);
	}
	if ((methodOrBlockNumArgs + 1) == 2) {
		goto l15;
	}
	{
		genoperandoperand(MoveRR, Arg1Reg, CArg2Reg);
	}
	if ((methodOrBlockNumArgs + 1) == 3) {
		goto l15;
	}
	{
		genoperandoperand(MoveRR, SendNumArgsReg, CArg3Reg);
	}
	l15:
	;
	/* end genMarshallNArgs:arg:arg:arg:arg: */
	{
		/* begin gen:literal: */
		checkLiteralforInstruction(((sqInt) _primitiveRoutine ), genoperand(CallFull, ((sqInt) _primitiveRoutine )));
		/* end gen:literal: */
	}
	{
		/* begin genRemoveNArgsFromStack: */
		_n = methodOrBlockNumArgs + 1;
		assert(_n <= 4);
		/* end genRemoveNArgsFromStack: */
		returnFromCallCFunctionInSmalltalkStack(backEnd, methodOrBlockNumArgs + 1);
		/* begin genRestoreRegs: */
		_regMask = _liveRegsMask & CallerSavedRegisterMask;
		assert(((R12 - R1) + 1) == 12);
		assert(!(_regMask & (registerMaskForand(SPReg, FPReg))));
		_registerCount = 0;
		for (_reg = R1; _reg <= R12; _reg += 1) {
			if (_regMask & (1ULL << _reg)) {
				_registerCount += 1;
			}
		}
		for (_reg = R1; _reg <= R12; _reg += 1) {
			if (_regMask & (1ULL << _reg)) {
				genoperand(PopR, _reg);
			}
		}
		if (!((_registerCount % 2) == 0)) {
			genoperand(PopR, R0);
		}
		/* end genRestoreRegs: */
	}
	{
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Extra0Reg, LinkReg);
		/* end MoveR:R: */
	}
	/* begin CmpCq:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(CmpCqR, 0, R0);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpZero: */
	_jmpFail = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	{
		/* begin MoveR:R: */
		_reg1 = R0;
		genoperandoperand(MoveRR, _reg1, ReceiverResultReg);
		/* end MoveR:R: */
	}
	/* begin RetN: */
	_offset = ((methodOrBlockNumArgs > 2)
		 ? (methodOrBlockNumArgs + 1) * BytesPerWord
		 : 0);
	genoperand(RetN, _offset);
	/* end RetN: */
	jmpTarget(_jmpFail, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return 0;
}
/*	Compile one method cache probe in an OpenPIC's lookup of selector. 
	Answer the jump taken if the selector probe fails. 
	The class tag of the receiver must be in SendNumArgsReg. ClassReg and 
	TempReg are used as scratch registers. 
	On a hit, the offset of the entry is in ClassReg. */
/* SimpleStackBasedCogit>>#compileOpenPICMethodCacheProbeFor:withShift:baseRegOrNone: */
static AbstractInstruction * NoDbgRegParms
compileOpenPICMethodCacheProbeForwithShiftbaseRegOrNone(sqInt _selector, sqInt _shift, sqInt _baseRegOrNone)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_jumpSelectorMiss;
	sqInt _offset;
	sqInt _offset2;

	/* begin MoveR:R: */
	genoperandoperand(MoveRR, SendNumArgsReg, ClassReg);
	/* end MoveR:R: */
	maybeShiftClassTagRegisterForMethodCacheProbe(ClassReg);
	annotateobjRef(gXorCwR(_selector, ClassReg), _selector);
	assert(_shift <= (shiftForWord()));
	if (_shift < (shiftForWord())) {
		/* begin LogicalShiftLeftCq:R: */
		genoperandoperand(LogicalShiftLeftCqR, (shiftForWord()) - _shift, ClassReg);
		/* end LogicalShiftLeftCq:R: */
	}
	/* begin AndCq:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction5 = genoperandoperand(AndCqR, ((sqInt) (((usqInt) MethodCacheMask ) << (shiftForWord())) ), ClassReg);
	if (usesOutOfLineLiteral(_anInstruction5)) {
		(_anInstruction5->dependent = locateLiteral(((sqInt) (((usqInt) MethodCacheMask ) << (shiftForWord())) )));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AndCq:R: */
	if (_baseRegOrNone == NoReg) {
		/* begin MoveMw:r:R: */
		_offset = ((usqInt) (methodCacheAddress()) ) + ((sqInt) (((usqInt) MethodCacheSelector ) << (shiftForWord())) );
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMwrR, _offset, ClassReg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_offset));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
	} else {
		{
			/* begin AddR:R: */
			genoperandoperand(AddRR, _baseRegOrNone, ClassReg);
			/* end AddR:R: */
			/* begin MoveMw:r:R: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction2 = genoperandoperandoperand(MoveMwrR, ((sqInt) (((usqInt) MethodCacheSelector ) << (shiftForWord())) ), ClassReg, TempReg);
			if (usesOutOfLineLiteral(_anInstruction2)) {
				(_anInstruction2->dependent = locateLiteral(((sqInt) (((usqInt) MethodCacheSelector ) << (shiftForWord())) )));
			}
			/* end checkQuickConstant:forInstruction: */
			/* end MoveMw:r:R: */
		}
	}
	annotateobjRef(checkLiteralforInstruction(_selector, genoperandoperand(CmpCwR, _selector, TempReg)), _selector);
	/* begin JumpNonZero: */
	_jumpSelectorMiss = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	if (_baseRegOrNone == NoReg) {
		/* begin MoveMw:r:R: */
		_offset2 = ((usqInt) (methodCacheAddress()) ) + ((sqInt) (((usqInt) MethodCacheClass ) << (shiftForWord())) );
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperandoperand(MoveMwrR, _offset2, ClassReg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(_offset2));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
	} else {
		/* begin MoveMw:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction4 = genoperandoperandoperand(MoveMwrR, ((sqInt) (((usqInt) MethodCacheClass ) << (shiftForWord())) ), ClassReg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction4)) {
			(_anInstruction4->dependent = locateLiteral(((sqInt) (((usqInt) MethodCacheClass ) << (shiftForWord())) )));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, SendNumArgsReg, TempReg);
	/* end CmpR:R: */
	return _jumpSelectorMiss;
}
/*	Compile the code for an open PIC. Perform a probe of the first-level 
	method lookup cache followed by a call of ceSendFromInLineCacheMiss: if 
	the probe fails. */
/* SimpleStackBasedCogit>>#compileOpenPIC:numArgs: */
static void NoDbgRegParms
compileOpenPICnumArgs(sqInt _selector, sqInt _numArgs)
{
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _cacheBaseReg;
	AbstractInstruction *_itsAHit;
	AbstractInstruction *_jumpBCMethod;
	AbstractInstruction *_jumpClassMiss;
	AbstractInstruction *_jumpSelectorMiss;
	sqInt _offset;

	/* begin preenMethodLabel */
	/* begin setLabelOffset: */
	((((AbstractInstruction *) methodLabel ))->operands)[1] = 0;
	/* end setLabelOffset: */
	/* end preenMethodLabel */
	compilePICAbort(_numArgs);
	entry = genGetClassTagOfintoscratchReg(ReceiverResultReg, SendNumArgsReg, TempReg);
	_cacheBaseReg = NoReg;
	_jumpSelectorMiss = compileOpenPICMethodCacheProbeForwithShiftbaseRegOrNone(_selector, 0, _cacheBaseReg);
	/* begin JumpNonZero: */
	_jumpClassMiss = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin MoveMw:r:R: */
	_offset = ((_cacheBaseReg == NoReg)
		 ? ((usqInt) (methodCacheAddress()) ) + ((sqInt) (((usqInt) MethodCacheMethod ) << (shiftForWord())) )
		 : ((sqInt) (((usqInt) MethodCacheMethod ) << (shiftForWord())) ));
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, _offset, ClassReg, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_offset));
	}
	_itsAHit = _anInstruction2;
	/* end checkQuickConstant:forInstruction: */
	/* end MoveMw:r:R: */
	genLoadSlotsourceRegdestReg(HeaderIndex, SendNumArgsReg, ClassReg);
	_jumpBCMethod = genJumpImmediate(ClassReg);
	jmpTarget(_jumpBCMethod, picInterpretAbort);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(AddCqR, cmNoCheckEntryOffset, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(cmNoCheckEntryOffset));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpR: */
	genoperand(JumpR, ClassReg);
	/* end JumpR: */
	jmpTarget(_jumpSelectorMiss, jmpTarget(_jumpClassMiss, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	_jumpSelectorMiss = compileOpenPICMethodCacheProbeForwithShiftbaseRegOrNone(_selector, 1, _cacheBaseReg);
	/* begin JumpZero: */
	genConditionalBranchoperand(JumpZero, ((sqInt) _itsAHit ));
	/* end JumpZero: */
	jmpTarget(_jumpSelectorMiss, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	_jumpSelectorMiss = compileOpenPICMethodCacheProbeForwithShiftbaseRegOrNone(_selector, 2, _cacheBaseReg);
	/* begin JumpZero: */
	genConditionalBranchoperand(JumpZero, ((sqInt) _itsAHit ));
	/* end JumpZero: */
	jmpTarget(_jumpSelectorMiss, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	{
		genPushRegisterArgsForNumArgsscratchReg(backEnd, _numArgs, SendNumArgsReg);
	}
	genSmalltalkToCStackSwitch(1);
	addDependent(methodLabel, annotateAbsolutePCRef(gMoveCwR(((sqInt) methodLabel ), SendNumArgsReg)));
	compileCallFornumArgsargargargargresultRegregsToSave(ceSendFromInLineCacheMiss, 1, SendNumArgsReg, null, null, null, NoReg, 0);
}
/*	Compile one method cache probe in a perform: primitive's lookup of 
	selector. Answer the jump taken if the selector probe fails. */
/* SimpleStackBasedCogit>>#compilePerformMethodCacheProbeFor:withShift:baseRegOrNone: */
static AbstractInstruction * NoDbgRegParms
compilePerformMethodCacheProbeForwithShiftbaseRegOrNone(sqInt _selectorReg, sqInt _shift, sqInt _baseRegOrNone)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_jumpSelectorMiss;
	sqInt _offset;
	sqInt _offset2;

	/* begin MoveR:R: */
	genoperandoperand(MoveRR, SendNumArgsReg, ClassReg);
	/* end MoveR:R: */
	maybeShiftClassTagRegisterForMethodCacheProbe(ClassReg);
	/* begin XorR:R: */
	genoperandoperand(XorRR, _selectorReg, ClassReg);
	/* end XorR:R: */
	assert(_shift <= (shiftForWord()));
	if (_shift < (shiftForWord())) {
		/* begin LogicalShiftLeftCq:R: */
		genoperandoperand(LogicalShiftLeftCqR, (shiftForWord()) - _shift, ClassReg);
		/* end LogicalShiftLeftCq:R: */
	}
	/* begin AndCq:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction5 = genoperandoperand(AndCqR, ((sqInt) (((usqInt) MethodCacheMask ) << (shiftForWord())) ), ClassReg);
	if (usesOutOfLineLiteral(_anInstruction5)) {
		(_anInstruction5->dependent = locateLiteral(((sqInt) (((usqInt) MethodCacheMask ) << (shiftForWord())) )));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end AndCq:R: */
	if (_baseRegOrNone == NoReg) {
		/* begin MoveMw:r:R: */
		_offset = ((usqInt) (methodCacheAddress()) ) + ((sqInt) (((usqInt) MethodCacheSelector ) << (shiftForWord())) );
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMwrR, _offset, ClassReg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_offset));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
	} else {
		{
			/* begin AddR:R: */
			genoperandoperand(AddRR, _baseRegOrNone, ClassReg);
			/* end AddR:R: */
			/* begin MoveMw:r:R: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction2 = genoperandoperandoperand(MoveMwrR, ((sqInt) (((usqInt) MethodCacheSelector ) << (shiftForWord())) ), ClassReg, TempReg);
			if (usesOutOfLineLiteral(_anInstruction2)) {
				(_anInstruction2->dependent = locateLiteral(((sqInt) (((usqInt) MethodCacheSelector ) << (shiftForWord())) )));
			}
			/* end checkQuickConstant:forInstruction: */
			/* end MoveMw:r:R: */
		}
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, _selectorReg, TempReg);
	/* end CmpR:R: */
	/* begin JumpNonZero: */
	_jumpSelectorMiss = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	if (_baseRegOrNone == NoReg) {
		/* begin MoveMw:r:R: */
		_offset2 = ((usqInt) (methodCacheAddress()) ) + ((sqInt) (((usqInt) MethodCacheClass ) << (shiftForWord())) );
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperandoperand(MoveMwrR, _offset2, ClassReg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(_offset2));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
	} else {
		/* begin MoveMw:r:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction4 = genoperandoperandoperand(MoveMwrR, ((sqInt) (((usqInt) MethodCacheClass ) << (shiftForWord())) ), ClassReg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction4)) {
			(_anInstruction4->dependent = locateLiteral(((sqInt) (((usqInt) MethodCacheClass ) << (shiftForWord())) )));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
	}
	/* begin CmpR:R: */
	genoperandoperand(CmpRR, SendNumArgsReg, TempReg);
	/* end CmpR:R: */
	return _jumpSelectorMiss;
}
/*	Compile a primitive. If possible, performance-critical primtiives will 
	be generated by their own routines (primitiveGenerator). Otherwise, 
	if there is a primitive at all, we call the C routine with the usual 
	stack-switching dance, test the primFailCode and then either return 
	on success or continue to the method body. */
/* SimpleStackBasedCogit>>#compilePrimitive */
static sqInt
compilePrimitive(void)
{
	PrimitiveDescriptor *_aPrimitiveDescriptor;
	int _code;
	sqInt _flags;
	sqInt _opcodeIndexAtPrimitive;
	void (*_primitiveRoutine)(void);

	if (primitiveIndex == 0) {
		return 0;
	}
	_code = 0;
	_opcodeIndexAtPrimitive = opcodeIndex;
	_aPrimitiveDescriptor = primitiveDescriptor();
	if ((((_aPrimitiveDescriptor->primitiveGenerator)) != null) && ((((_aPrimitiveDescriptor->primNumArgs)) < 0) || (((_aPrimitiveDescriptor->primNumArgs)) == (argumentCountOf(methodObj))))) {
		_code = ((_aPrimitiveDescriptor->primitiveGenerator))();
	}
	if ((_code < 0) && (_code != UnimplementedPrimitive)) {
		return _code;
	}
	if (_code == UnfailingPrimitive) {
		return 0;
	}
	if ((_code == CompletePrimitive) && (!(((primitiveIndexOfMethodheader(methodObj, methodHeader)) > 0) && ((longStoreBytecodeForHeader(methodHeader)) == (fetchByteofObject((startPCOfMethod(methodObj)) + (sizeOfCallPrimitiveBytecode(methodHeader)), methodObj)))))) {
		return 0;
	}
	if (_code == UnimplementedPrimitive) {
		opcodeIndex = _opcodeIndexAtPrimitive;
	}
	_flags = primitivePropertyFlagsprimitiveDescriptor(primitiveIndex, _aPrimitiveDescriptor);
	if (_flags & PrimCallDoNotJIT) {
		return ShouldNotJIT;
	}
	if (_flags & PrimCallOnSmalltalkStack) {
		assert(_flags == PrimCallOnSmalltalkStack);
		return compileMachineCodeInterpreterPrimitive(mcprimFunctionForPrimitiveIndex(primitiveIndex));
	}
	if ((((_primitiveRoutine = functionPointerForCompiledMethodprimitiveIndex(methodObj, primitiveIndex))) == 0) || (_primitiveRoutine == ((void *) primitiveFail ))) {
		return genFastPrimFail();
	}
	minValidCallAddress = ((minValidCallAddress < ((usqInt) _primitiveRoutine )) ? minValidCallAddress : ((usqInt) _primitiveRoutine ));
	return compileInterpreterPrimitiveflags(_primitiveRoutine, _flags);
}
/* SimpleStackBasedCogit>>#frameOffsetOfTemporary: */
static sqInt NoDbgRegParms
frameOffsetOfTemporary(sqInt _index)
{
	return ((_index < methodOrBlockNumArgs)
		 ? FoxCallerSavedIP + ((methodOrBlockNumArgs - _index) * BytesPerWord)
		 : (FoxMFReceiver - BytesPerWord) + ((methodOrBlockNumArgs - _index) * BytesPerWord));
}
/* SimpleStackBasedCogit>>#genDoubleFailIfZeroArgRcvr:arg: */
static AbstractInstruction * NoDbgRegParms
genDoubleFailIfZeroArgRcvrarg(int rcvrReg, int _argReg)
{
	AbstractInstruction *_anInstruction;

	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(MoveCqR, 0, TempReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin ConvertR:Rd: */
	genoperandoperand(ConvertRRd, TempReg, DPFPReg2);
	/* end ConvertR:Rd: */
	/* begin CmpRd:Rd: */
	genoperandoperand(CmpRdRd, DPFPReg2, _argReg);
	/* end CmpRd:Rd: */
	return gJumpFPEqual(0);
}
/*	244		11110100	i i i i i i i i	Pop and Jump 0n False i i i i i i i i (+ 
	Extend B * 256, where Extend B >= 0) */
/* SimpleStackBasedCogit>>#genExtJumpIfFalse */
static sqInt
genExtJumpIfFalse(void)
{
	sqInt _distance;
	sqInt _target;

	_distance = byte1 + ((sqInt) (((usqInt) extB ) << 8) );
	assert(_distance == (v4LongForwardBranchDistance(generatorAt(byte0), bytecodePC, (((extA != 0)
		 ? 1
		 : 0)) + (((extB != 0)
		 ? 1
		 : 0)), methodObj)));
	extB = 0;
	numExtB = 0;
	_target = (_distance + 2) + bytecodePC;
	return genJumpIfto(falseObject(), _target);
}
/*	243		11110011	i i i i i i i i	Pop and Jump 0n True i i i i i i i i (+ 
	Extend B * 256, where Extend B >= 0) */
/* SimpleStackBasedCogit>>#genExtJumpIfTrue */
static sqInt
genExtJumpIfTrue(void)
{
	sqInt _distance;
	sqInt _target;

	_distance = byte1 + ((sqInt) (((usqInt) extB ) << 8) );
	assert(_distance == (v4LongForwardBranchDistance(generatorAt(byte0), bytecodePC, (((extA != 0)
		 ? 1
		 : 0)) + (((extB != 0)
		 ? 1
		 : 0)), methodObj)));
	extB = 0;
	numExtB = 0;
	_target = (_distance + 2) + bytecodePC;
	return genJumpIfto(trueObject(), _target);
}
/*	SistaV1:		 91		01011011'		Nop */
/* SimpleStackBasedCogit>>#genExtNopBytecode */
static sqInt
genExtNopBytecode(void)
{
	extA = (numExtB = (extB = 0));
	return 0;
}
/*	SistaV1:		233		11101001	iiiiiiii		Push Character #iiiiiiii (+ Extend B * 
	256)  */
/* SimpleStackBasedCogit>>#genExtPushCharacterBytecode */
static sqInt
genExtPushCharacterBytecode(void)
{
	sqInt _value;

	_value = byte1 + ((sqInt) (((usqInt) extB ) << 8) );
	extB = 0;
	numExtB = 0;
	return genPushLiteral(characterObjectOf(_value));
}
/*	NewsqueakV4:	229		11100101	iiiiiiii	Push Integer #iiiiiiii (+ Extend B * 
	256, where bbbbbbbb = sddddddd, e.g. -32768 = i=0, a=0, s=1) 
	SistaV1:		232		11101000	iiiiiiii	Push Integer #iiiiiiii (+ Extend B * 256, 
	where bbbbbbbb = sddddddd, e.g. -32768 = i=0, a=0, s=1) */
/* SimpleStackBasedCogit>>#genExtPushIntegerBytecode */
static sqInt
genExtPushIntegerBytecode(void)
{
	sqInt _value;

	_value = byte1 + ((sqInt) (((usqInt) extB ) << 8) );
	extB = 0;
	numExtB = 0;
	return genPushLiteral(((((usqInt) _value ) << 3) | 1));
}
/*	228		11100100	i i i i i i i i	Push Literal #iiiiiiii (+ Extend A * 256) */
/* SimpleStackBasedCogit>>#genExtPushLiteralBytecode */
static sqInt
genExtPushLiteralBytecode(void)
{
	sqInt _index;

	_index = byte1 + ((sqInt) (((usqInt) extA ) << 8) );
	extA = 0;
	return genPushLiteralIndex(_index);
}
/*	227		11100011	i i i i i i i i	Push Literal Variable #iiiiiiii (+ Extend A 
	* 256) */
/* SimpleStackBasedCogit>>#genExtPushLiteralVariableBytecode */
static sqInt
genExtPushLiteralVariableBytecode(void)
{
	sqInt _index;

	_index = byte1 + ((sqInt) (((usqInt) extA ) << 8) );
	extA = 0;
	return genPushLiteralVariable(_index);
}
/*	SistaV1: *	82			01010010			Push thisContext, (then Extend B = 1 => push 
	thisProcess)  */
/* SimpleStackBasedCogit>>#genExtPushPseudoVariable */
static sqInt
genExtPushPseudoVariable(void)
{
	sqInt _ext;

	_ext = extB;
	extB = 0;
	numExtB = 0;
	switch (_ext) {
		case 0:
		{
			return genPushActiveContextBytecode();
		}
		default:
		{
			return unknownBytecode();
		}
	}
	return 0;
}
/*	226		11100010	i i i i i i i i	Push Receiver Variable #iiiiiiii (+ Extend A 
	* 256) */
/* SimpleStackBasedCogit>>#genExtPushReceiverVariableBytecode */
static sqInt
genExtPushReceiverVariableBytecode(void)
{
	sqInt _index;

	_index = byte1 + ((sqInt) (((usqInt) extA ) << 8) );
	extA = 0;
	return ((isReadMediatedContextInstVarIndex(_index))
		 ? genPushMaybeContextReceiverVariable(_index)
		 : genPushReceiverVariable(_index));
}
/*	238		11101110	i i i i i j j j	Send Literal Selector #iiiii (+ Extend A * 
	32) with jjj (+ Extend B * 8) Arguments */
/* SimpleStackBasedCogit>>#genExtSendBytecode */
static sqInt
genExtSendBytecode(void)
{
	sqInt _litIndex;
	sqInt _nArgs;

	_litIndex = (((usqInt) byte1 ) >> 3) + ((sqInt) (((usqInt) extA ) << 5) );
	extA = 0;
	_nArgs = (byte1 & 7) + ((sqInt) (((usqInt) extB ) << 3) );
	extB = 0;
	numExtB = 0;
	return genSendnumArgs(_litIndex, _nArgs);
}
/*	239		11101111	i i i i i j j j	Send To Superclass Literal Selector #iiiii 
	(+ Extend A * 32) with jjj (+ Extend B * 8) Arguments */
/* SimpleStackBasedCogit>>#genExtSendSuperBytecode */
static sqInt
genExtSendSuperBytecode(void)
{
	int _isDirected;
	sqInt _litIndex;
	sqInt _nArgs;

	if ((_isDirected = extB >= 64)) {
		extB = extB & 0x3F;
	}
	_litIndex = (((usqInt) byte1 ) >> 3) + ((sqInt) (((usqInt) extA ) << 5) );
	extA = 0;
	_nArgs = (byte1 & 7) + ((sqInt) (((usqInt) extB ) << 3) );
	extB = 0;
	numExtB = 0;
	return ((_isDirected)
		 ? genSendDirectedSupernumArgs(_litIndex, _nArgs)
		 : genSendSupernumArgs(_litIndex, _nArgs));
}
/*	236		11101100	i i i i i i i i	Pop and Store Literal Variable #iiiiiiii (+ 
	Extend A * 256) */
/* SimpleStackBasedCogit>>#genExtStoreAndPopLiteralVariableBytecode */
static sqInt
genExtStoreAndPopLiteralVariableBytecode(void)
{
	sqInt _index;

	_index = byte1 + ((sqInt) (((usqInt) extA ) << 8) );
	extA = 0;
	return genStorePopLiteralVariableneedsStoreCheckneedsImmutabilityCheck(1, _index, ((((ssTop())->type)) != SSConstant) || ((isNonImmediate(((ssTop())->constant))) && (shouldAnnotateObjectReference(((ssTop())->constant)))), 1);
}
/*	235		11101011	i i i i i i i i	Pop and Store Receiver Variable #iiiiiii (+ 
	Extend A * 256) */
/* SimpleStackBasedCogit>>#genExtStoreAndPopReceiverVariableBytecode */
static sqInt
genExtStoreAndPopReceiverVariableBytecode(void)
{
	sqInt _index;

	_index = byte1 + ((sqInt) (((usqInt) extA ) << 8) );
	extA = 0;
	return ((isWriteMediatedContextInstVarIndex(_index))
		 ? genStorePopMaybeContextReceiverVariableneedsStoreCheckneedsImmutabilityCheck(1, _index, ((((ssTop())->type)) != SSConstant) || ((isNonImmediate(((ssTop())->constant))) && (shouldAnnotateObjectReference(((ssTop())->constant)))), 1)
		 : genStorePopReceiverVariableneedsStoreCheckneedsImmutabilityCheck(1, _index, ((((ssTop())->type)) != SSConstant) || ((isNonImmediate(((ssTop())->constant))) && (shouldAnnotateObjectReference(((ssTop())->constant)))), 1));
}
/*	233		11101001	i i i i i i i i	Store Literal Variable #iiiiiiii (+ Extend A 
	* 256) */
/* SimpleStackBasedCogit>>#genExtStoreLiteralVariableBytecode */
static sqInt
genExtStoreLiteralVariableBytecode(void)
{
	sqInt _index;

	_index = byte1 + ((sqInt) (((usqInt) extA ) << 8) );
	extA = 0;
	return genStorePopLiteralVariableneedsStoreCheckneedsImmutabilityCheck(0, _index, ((((ssTop())->type)) != SSConstant) || ((isNonImmediate(((ssTop())->constant))) && (shouldAnnotateObjectReference(((ssTop())->constant)))), 1);
}
/*	232		11101000	i i i i i i i i	Store Receiver Variable #iiiiiii (+ Extend A 
	* 256) */
/* SimpleStackBasedCogit>>#genExtStoreReceiverVariableBytecode */
static sqInt
genExtStoreReceiverVariableBytecode(void)
{
	sqInt _index;

	_index = byte1 + ((sqInt) (((usqInt) extA ) << 8) );
	extA = 0;
	return ((isWriteMediatedContextInstVarIndex(_index))
		 ? genStorePopMaybeContextReceiverVariableneedsStoreCheckneedsImmutabilityCheck(0, _index, ((((ssTop())->type)) != SSConstant) || ((isNonImmediate(((ssTop())->constant))) && (shouldAnnotateObjectReference(((ssTop())->constant)))), 1)
		 : genStorePopReceiverVariableneedsStoreCheckneedsImmutabilityCheck(0, _index, ((((ssTop())->type)) != SSConstant) || ((isNonImmediate(((ssTop())->constant))) && (shouldAnnotateObjectReference(((ssTop())->constant)))), 1));
}
/*	242		11110010	i i i i i i i i	Jump i i i i i i i i (+ Extend B * 256, 
	where bbbbbbbb = sddddddd, e.g. -32768 = i=0, a=0, s=1) */
/* SimpleStackBasedCogit>>#genExtUnconditionalJump */
static sqInt
genExtUnconditionalJump(void)
{
	AbstractInstruction *_abstractInstruction;
	sqInt _distance;
	sqInt _target;

	_distance = byte1 + ((sqInt) (((usqInt) extB ) << 8) );
	assert(_distance == (v4LongBranchDistance(generatorAt(byte0), bytecodePC, (((extA != 0)
		 ? 1
		 : 0)) + (((extB != 0)
		 ? 1
		 : 0)), methodObj)));
	extB = 0;
	numExtB = 0;
	_target = (_distance + 2) + bytecodePC;
	if (_distance < 0) {
		return genJumpBackTo(_target);
	}
	genJumpTo(_target);
	/* begin annotateBytecode: */
	_abstractInstruction = lastOpcode();
	(_abstractInstruction->annotation = HasBytecodePC);
	/* end annotateBytecode: */
	return 0;
}
/* SimpleStackBasedCogit>>#genFastPrimFail */
static sqInt
genFastPrimFail(void)
{
	primitiveIndex = 0;
	return UnfailingPrimitive;
}
/*	Suport for compileInterpreterPrimitive. Generate inline code so as to 
	record the primitive 
	trace as fast as possible. */
/* SimpleStackBasedCogit>>#genFastPrimTraceUsing:and: */
static void NoDbgRegParms
genFastPrimTraceUsingand(sqInt _r1, sqInt _r2)
{
	sqInt _address;
	sqInt _address2;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _offset;
	sqInt _wordConstant;

	/* begin MoveAb:R: */
	_address = primTraceLogIndexAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address, genoperandoperand(MoveAbR, _address, _r2));
	/* end gen:literal:operand: */
	/* end MoveAb:R: */
	/* begin MoveR:R: */
	genoperandoperand(MoveRR, _r2, _r1);
	/* end MoveR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(AddCqR, 1, _r1);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin MoveR:Ab: */
	_address2 = primTraceLogIndexAddress();
	/* begin gen:operand:literal: */
	checkLiteralforInstruction(_address2, genoperandoperand(MoveRAb, _r1, _address2));
	/* end gen:operand:literal: */
	/* end MoveR:Ab: */
	addDependent(methodLabel, annotateAbsolutePCRef(gMoveCwR(((sqInt) methodLabel ), _r1)));
	/* begin MoveMw:r:R: */
	_offset = offsetof(CogMethod, selector);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperandoperand(MoveMwrR, _offset, _r1, TempReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(_offset));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end MoveMw:r:R: */
	/* begin MoveCw:R: */
	_wordConstant = ((sqInt) (primTraceLogAddress()) );
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_wordConstant, genoperandoperand(MoveCwR, _wordConstant, _r1));
	/* end gen:literal:operand: */
	/* end MoveCw:R: */
	/* begin MoveR:Xwr:R: */
	genoperandoperandoperand(MoveRXwrR, TempReg, _r2, _r1);
	/* end MoveR:Xwr:R: */
}
/*	230		11100110	i i i i i i i i	Push Temporary Variable #iiiiiiii */
/* SimpleStackBasedCogit>>#genLongPushTemporaryVariableBytecode */
static sqInt
genLongPushTemporaryVariableBytecode(void)
{
	return genPushTemporaryVariable(byte1);
}
/*	237		11101101	i i i i i i i i	Pop and Store Temporary Variable #iiiiiiii */
/* SimpleStackBasedCogit>>#genLongStoreAndPopTemporaryVariableBytecode */
static sqInt
genLongStoreAndPopTemporaryVariableBytecode(void)
{
	return genStorePopTemporaryVariable(1, byte1);
}
/*	234		11101010	i i i i i i i i	Store Temporary Variable #iiiiiiii */
/* SimpleStackBasedCogit>>#genLongStoreTemporaryVariableBytecode */
static sqInt
genLongStoreTemporaryVariableBytecode(void)
{
	return genStorePopTemporaryVariable(0, byte1);
}
/*	Compile the code for a probe of the first-level method cache for a perform 
	primtiive. The selector is assumed to be in Arg0Reg. Defer to 
	adjustArgumentsForPerform: to 
	adjust the arguments before the jump to the method. */
/* SimpleStackBasedCogit>>#genLookupForPerformNumArgs: */
static sqInt NoDbgRegParms
genLookupForPerformNumArgs(sqInt _numArgs)
{
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _cacheBaseReg;
	AbstractInstruction *_itsAHit;
	AbstractInstruction *_jumpClassMiss;
	AbstractInstruction *_jumpInterpret;
	AbstractInstruction *_jumpSelectorMiss;
	sqInt _offset;

	genGetInlineCacheClassTagFrominto(ReceiverResultReg, SendNumArgsReg);
	_cacheBaseReg = NoReg;
	_jumpSelectorMiss = compilePerformMethodCacheProbeForwithShiftbaseRegOrNone(Arg0Reg, 0, _cacheBaseReg);
	/* begin JumpNonZero: */
	_jumpClassMiss = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	/* begin MoveMw:r:R: */
	_offset = ((_cacheBaseReg == NoReg)
		 ? ((usqInt) (methodCacheAddress()) ) + ((sqInt) (((usqInt) MethodCacheMethod ) << (shiftForWord())) )
		 : ((sqInt) (((usqInt) MethodCacheMethod ) << (shiftForWord())) ));
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperandoperand(MoveMwrR, _offset, ClassReg, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_offset));
	}
	_itsAHit = _anInstruction2;
	/* end checkQuickConstant:forInstruction: */
	/* end MoveMw:r:R: */
	genLoadSlotsourceRegdestReg(HeaderIndex, SendNumArgsReg, ClassReg);
	_jumpInterpret = genJumpImmediate(ClassReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(AddCqR, cmNoCheckEntryOffset, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(cmNoCheckEntryOffset));
	}
	/* end checkQuickConstant:forInstruction: */
	adjustArgumentsForPerform(_numArgs);
	/* begin JumpR: */
	genoperand(JumpR, ClassReg);
	/* end JumpR: */
	jmpTarget(_jumpSelectorMiss, jmpTarget(_jumpClassMiss, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	_jumpSelectorMiss = compilePerformMethodCacheProbeForwithShiftbaseRegOrNone(Arg0Reg, 1, _cacheBaseReg);
	/* begin JumpZero: */
	genConditionalBranchoperand(JumpZero, ((sqInt) _itsAHit ));
	/* end JumpZero: */
	jmpTarget(_jumpSelectorMiss, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	_jumpSelectorMiss = compilePerformMethodCacheProbeForwithShiftbaseRegOrNone(Arg0Reg, 2, _cacheBaseReg);
	/* begin JumpZero: */
	genConditionalBranchoperand(JumpZero, ((sqInt) _itsAHit ));
	/* end JumpZero: */
	jmpTarget(_jumpSelectorMiss, jmpTarget(_jumpInterpret, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return 0;
}
/*	If the objectMemory allows it, generates a quick constant move, else 
	generates a word constant move */
/* SimpleStackBasedCogit>>#genMoveConstant:R: */
static AbstractInstruction * NoDbgRegParms
genMoveConstantR(sqInt _constant, sqInt _reg)
{
	AbstractInstruction *_anInstruction;

	return ((shouldAnnotateObjectReference(_constant))
		 ? annotateobjRef(gMoveCwR(_constant, _reg), _constant)
		 : (/* begin checkQuickConstant:forInstruction: */ (_anInstruction = genoperandoperand(MoveCqR, _constant, _reg)), ((usesOutOfLineLiteral(_anInstruction))
			 ? (_anInstruction->dependent = locateLiteral(_constant))
			 : 0), _anInstruction /* end checkQuickConstant:forInstruction: */));
}
/* SimpleStackBasedCogit>>#genMustBeBooleanTrampolineFor:called: */
static sqInt NoDbgRegParms
genMustBeBooleanTrampolineForcalled(sqInt _boolean, char *_trampolineName)
{
	AbstractInstruction *_anInstruction;

	zeroOpcodeIndex();
	assert(!(shouldAnnotateObjectReference(_boolean)));
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(AddCqR, _boolean, TempReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_boolean));
	}
	/* end checkQuickConstant:forInstruction: */
	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(ceSendMustBeBoolean, _trampolineName, 1, TempReg, null, null, null, 0, 1, NoReg, 1);
}
/*	Implement 28-bit hashMultiply for SmallInteger and LargePositiveInteger 
	receivers.  */
/* SimpleStackBasedCogit>>#genPrimitiveHashMultiply */
static sqInt
genPrimitiveHashMultiply(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction * _jmpFailImm;
	AbstractInstruction * _jmpFailNonImm;
	AbstractInstruction * _jmpNotSmallInt;
	AbstractInstruction * _reenter;

	_jmpNotSmallInt = genJumpNotSmallInteger(ReceiverResultReg);
	genConvertSmallIntegerToIntegerInReg(ReceiverResultReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(MoveCqR, HashMultiplyConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(HashMultiplyConstant));
	}
	_reenter = _anInstruction;
	/* end checkQuickConstant:forInstruction: */
	/* begin MulR:R: */
	genMulRR(backEnd, TempReg, ReceiverResultReg);
	/* end MulR:R: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(AndCqR, HashMultiplyMask, ReceiverResultReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(HashMultiplyMask));
	}
	/* end checkQuickConstant:forInstruction: */
	genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
	/* begin RetN: */
	genoperand(RetN, 0);
	/* end RetN: */
	jmpTarget(_jmpNotSmallInt, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	_jmpFailImm = genJumpImmediate(ReceiverResultReg);
	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, ClassReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction3 = genoperandoperand(CmpCqR, ClassLargePositiveIntegerCompactIndex, ClassReg);
	if (usesOutOfLineLiteral(_anInstruction3)) {
		(_anInstruction3->dependent = locateLiteral(ClassLargePositiveIntegerCompactIndex));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpNonZero: */
	_jmpFailNonImm = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	genLoadSlotsourceRegdestReg(0, ReceiverResultReg, ReceiverResultReg);
	/* begin Jump: */
	genoperand(Jump, ((sqInt) _reenter ));
	/* end Jump: */
	jmpTarget(_jmpFailImm, jmpTarget(_jmpFailNonImm, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return 0;
}
/*	Generate the substitute return code for an external or FFI primitive call. 
	On success simply return, extracting numArgs from newMethod. 
	On primitive failure call ceActivateFailingPrimitiveMethod: newMethod. */
/* SimpleStackBasedCogit>>#genPrimReturnEnterCogCodeEnilopmart: */
static void NoDbgRegParms
genPrimReturnEnterCogCodeEnilopmart(sqInt _profiling)
{
	sqInt _address3;
	sqInt _address5;
	sqInt _address7;
	sqInt _address8;
	sqInt _address9;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction *_anInstruction8;
	sqInt _callTarget;
	AbstractInstruction *_continuePostSample;
	AbstractInstruction * _inst;
	AbstractInstruction *_jmpFail;
	AbstractInstruction *_jmpSample;
	sqInt _quickConstant;
	sqInt _reg;

	_continuePostSample = ((AbstractInstruction *) 0 );
	_jmpSample = ((AbstractInstruction *) 0 );
	zeroOpcodeIndex();
	{
		/* begin MoveCq:R: */
		_quickConstant = varBaseAddress();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, _quickConstant, VarBaseReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveCq:R: */
	}
	if (_profiling) {
		{
			/* begin MoveAw:R: */
			_address3 = nextProfileTickAddress();
			/* begin gen:literal:operand: */
			checkLiteralforInstruction(_address3, genoperandoperand(MoveAwR, _address3, TempReg));
			/* end gen:literal:operand: */
			/* end MoveAw:R: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction2 = genoperandoperand(CmpCqR, 0, TempReg);
			if (usesOutOfLineLiteral(_anInstruction2)) {
				(_anInstruction2->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		/* begin JumpNonZero: */
		_jmpSample = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		/* begin Label */
		_continuePostSample = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
		/* end Label */
	}
	maybeCompileAllocFillerCheck();
	/* begin MoveAw:R: */
	_address7 = primFailCodeAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address7, genoperandoperand(MoveAwR, _address7, TempReg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	flag("ask concrete code gen if move sets condition codes?");
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction8 = genoperandoperand(CmpCqR, 0, TempReg);
	if (usesOutOfLineLiteral(_anInstruction8)) {
		(_anInstruction8->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpNonZero: */
	_jmpFail = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	{
		genLoadStackPointers(backEnd);
		{
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction3 = genoperandoperandoperand(MoveMwrR, 0, SPReg, ReceiverResultReg);
			if (usesOutOfLineLiteral(_anInstruction3)) {
				(_anInstruction3->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
			/* begin MoveAw:R: */
			_address5 = instructionPointerAddress();
			/* begin gen:literal:operand: */
			checkLiteralforInstruction(_address5, genoperandoperand(MoveAwR, _address5, LinkReg));
			/* end gen:literal:operand: */
			/* end MoveAw:R: */
			/* begin RetN: */
			genoperand(RetN, BytesPerWord);
			/* end RetN: */
		}
	}
	jmpTarget(_jmpFail, gMoveAwR(newMethodAddress(), SendNumArgsReg));
	/* begin MoveAw:R: */
	_address8 = cStackPointerAddress();
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address8, genoperandoperand(MoveAwR, _address8, SPReg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	compileCallFornumArgsargargargargresultRegregsToSave(ceActivateFailingPrimitiveMethod, 1, SendNumArgsReg, null, null, null, NoReg, 0);
	/* begin MoveAw:R: */
	_address9 = instructionPointerAddress();
	_reg = LinkReg;
	/* begin gen:literal:operand: */
	checkLiteralforInstruction(_address9, genoperandoperand(MoveAwR, _address9, _reg));
	/* end gen:literal:operand: */
	/* end MoveAw:R: */
	genLoadStackPointers(backEnd);
	{
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction6 = genoperandoperandoperand(MoveMwrR, 0, SPReg, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction6)) {
			(_anInstruction6->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin RetN: */
	genoperand(RetN, BytesPerWord);
	/* end RetN: */
	if (_profiling) {
		jmpTarget(_jmpSample, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
		/* begin saveAndRestoreLinkRegAround: */
		_inst = genoperand(PushR, LinkReg);
		{
			/* begin CallFullRT: */
			_callTarget = (usqIntptr_t)ceCheckProfileTick;
			{
				/* begin gen:literal: */
				checkLiteralforInstruction(_callTarget, genoperand(CallFull, _callTarget));
				/* end gen:literal: */
			}
			/* end CallFullRT: */
		}
		genoperand(PopR, LinkReg);
		/* end saveAndRestoreLinkRegAround: */
		/* begin Jump: */
		genoperand(Jump, ((sqInt) _continuePostSample ));
		/* end Jump: */
	}
}
/* SimpleStackBasedCogit>>#genPushConstantFalseBytecode */
static sqInt
genPushConstantFalseBytecode(void)
{
	return genPushLiteral(falseObject());
}
/* SimpleStackBasedCogit>>#genPushConstantNilBytecode */
static sqInt
genPushConstantNilBytecode(void)
{
	return genPushLiteral(nilObject());
}
/*	79			01001111		Push 1 */
/* SimpleStackBasedCogit>>#genPushConstantOneBytecode */
static sqInt
genPushConstantOneBytecode(void)
{
	return genPushLiteral(((((usqInt) 1 ) << 3) | 1));
}
/* SimpleStackBasedCogit>>#genPushConstantTrueBytecode */
static sqInt
genPushConstantTrueBytecode(void)
{
	return genPushLiteral(trueObject());
}
/*	78			01001110		Push 0 */
/* SimpleStackBasedCogit>>#genPushConstantZeroBytecode */
static sqInt
genPushConstantZeroBytecode(void)
{
	return genPushLiteral(((((usqInt) 0 ) << 3) | 1));
}
/* SimpleStackBasedCogit>>#genPushLiteralConstantBytecode */
static sqInt
genPushLiteralConstantBytecode(void)
{
	return genPushLiteralIndex(byte0 & 0x1F);
}
/*	16-31		0001 i i i i		Push Literal Variable #iiii */
/* SimpleStackBasedCogit>>#genPushLiteralVariable16CasesBytecode */
static sqInt
genPushLiteralVariable16CasesBytecode(void)
{
	return genPushLiteralVariable(byte0 & 15);
}
/* SimpleStackBasedCogit>>#genPushQuickIntegerConstantBytecode */
static sqInt
genPushQuickIntegerConstantBytecode(void)
{
	return genPushLiteral(((((usqInt) (byte0 - 117) ) << 3) | 1));
}
/* SimpleStackBasedCogit>>#genPushReceiverVariableBytecode */
static sqInt
genPushReceiverVariableBytecode(void)
{
	return genPushReceiverVariable(byte0 & 15);
}
/* SimpleStackBasedCogit>>#genPushTemporaryVariableBytecode */
static sqInt
genPushTemporaryVariableBytecode(void)
{
	return genPushTemporaryVariable(byte0 & 15);
}
/*	because selected by CoInterpreter>>quickPrimitiveGeneratorFor: */
/* SimpleStackBasedCogit>>#genQuickReturnConst */
sqInt
genQuickReturnConst(void)
{
	AbstractInstruction *_anInstruction;
	sqInt _constant;

	_constant = quickPrimitiveConstantFor(primitiveIndex);
	/* begin genMoveConstant:R: */
	if (shouldAnnotateObjectReference(_constant)) {
		annotateobjRef(gMoveCwR(_constant, ReceiverResultReg), _constant);
	} else {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, _constant, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_constant));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* end genMoveConstant:R: */
	genUpArrowReturn();
	return UnfailingPrimitive;
}
/*	because selected by CoInterpreter>>quickPrimitiveGeneratorFor: */
/* SimpleStackBasedCogit>>#genQuickReturnInstVar */
sqInt
genQuickReturnInstVar(void)
{
	sqInt _index;

	_index = quickPrimitiveInstVarIndexFor(primitiveIndex);
	genLoadSlotsourceRegdestReg(_index, ReceiverResultReg, ReceiverResultReg);
	genUpArrowReturn();
	return UnfailingPrimitive;
}
/*	because selected by CoInterpreter>>quickPrimitiveGeneratorFor: */
/* SimpleStackBasedCogit>>#genQuickReturnSelf */
sqInt
genQuickReturnSelf(void)
{
	genUpArrowReturn();
	return UnfailingPrimitive;
}
/* SimpleStackBasedCogit>>#genReturnFalse */
static sqInt
genReturnFalse(void)
{
	AbstractInstruction *_anInstruction;
	sqInt _constant;

	/* begin genMoveFalseR: */
	/* begin genMoveConstant:R: */
	_constant = falseObject();
	if (shouldAnnotateObjectReference(_constant)) {
		annotateobjRef(gMoveCwR(_constant, ReceiverResultReg), _constant);
	} else {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, _constant, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_constant));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* end genMoveConstant:R: */
	/* end genMoveFalseR: */
	return genUpArrowReturn();
}
/* SimpleStackBasedCogit>>#genReturnNil */
static sqInt
genReturnNil(void)
{
	AbstractInstruction *_anInstruction;
	sqInt _constant;

	/* begin genMoveNilR: */
	/* begin genMoveConstant:R: */
	_constant = nilObject();
	if (shouldAnnotateObjectReference(_constant)) {
		annotateobjRef(gMoveCwR(_constant, ReceiverResultReg), _constant);
	} else {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, _constant, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_constant));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* end genMoveConstant:R: */
	/* end genMoveNilR: */
	return genUpArrowReturn();
}
/* SimpleStackBasedCogit>>#genReturnNilFromBlock */
static sqInt
genReturnNilFromBlock(void)
{
	AbstractInstruction *_anInstruction;
	sqInt _constant;

	assert(inBlock > 0);
	/* begin genMoveNilR: */
	/* begin genMoveConstant:R: */
	_constant = nilObject();
	if (shouldAnnotateObjectReference(_constant)) {
		annotateobjRef(gMoveCwR(_constant, ReceiverResultReg), _constant);
	} else {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, _constant, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_constant));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* end genMoveConstant:R: */
	/* end genMoveNilR: */
	return genBlockReturn();
}
/* SimpleStackBasedCogit>>#genReturnTrue */
static sqInt
genReturnTrue(void)
{
	AbstractInstruction *_anInstruction;
	sqInt _constant;

	/* begin genMoveTrueR: */
	/* begin genMoveConstant:R: */
	_constant = trueObject();
	if (shouldAnnotateObjectReference(_constant)) {
		annotateobjRef(gMoveCwR(_constant, ReceiverResultReg), _constant);
	} else {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, _constant, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_constant));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* end genMoveConstant:R: */
	/* end genMoveTrueR: */
	return genUpArrowReturn();
}
/* SimpleStackBasedCogit>>#genSendLiteralSelector0ArgsBytecode */
static sqInt
genSendLiteralSelector0ArgsBytecode(void)
{
	return genSendnumArgs(byte0 & 15, 0);
}
/* SimpleStackBasedCogit>>#genSendLiteralSelector1ArgBytecode */
static sqInt
genSendLiteralSelector1ArgBytecode(void)
{
	return genSendnumArgs(byte0 & 15, 1);
}
/* SimpleStackBasedCogit>>#genSendLiteralSelector2ArgsBytecode */
static sqInt
genSendLiteralSelector2ArgsBytecode(void)
{
	return genSendnumArgs(byte0 & 15, 2);
}
/* SimpleStackBasedCogit>>#genShortJumpIfFalse */
static sqInt
genShortJumpIfFalse(void)
{
	sqInt _distance;
	sqInt _target;

	_distance = v3ShortForwardBranchDistance(generatorAt(byte0), bytecodePC, 0, methodObj);
	_target = (_distance + 1) + bytecodePC;
	return genJumpIfto(falseObject(), _target);
}
/* SimpleStackBasedCogit>>#genShortJumpIfTrue */
static sqInt
genShortJumpIfTrue(void)
{
	sqInt _distance;
	sqInt _target;

	_distance = v3ShortForwardBranchDistance(generatorAt(byte0), bytecodePC, 0, methodObj);
	_target = (_distance + 1) + bytecodePC;
	return genJumpIfto(trueObject(), _target);
}
/* SimpleStackBasedCogit>>#genShortUnconditionalJump */
static sqInt
genShortUnconditionalJump(void)
{
	sqInt _distance;
	sqInt _target;

	_distance = v3ShortForwardBranchDistance(generatorAt(byte0), bytecodePC, 0, methodObj);
	_target = (_distance + 1) + bytecodePC;
	return genJumpTo(_target);
}
/* SimpleStackBasedCogit>>#genSpecialSelectorEqualsEquals */
static sqInt
genSpecialSelectorEqualsEquals(void)
{
	return genInlinedIdenticalOrNotIf(0);
}
/* SimpleStackBasedCogit>>#genSpecialSelectorNotEqualsEquals */
static sqInt
genSpecialSelectorNotEqualsEquals(void)
{
	return genInlinedIdenticalOrNotIf(1);
}
/* SimpleStackBasedCogit>>#genSpecialSelectorSend */
static sqInt
genSpecialSelectorSend(void)
{
	sqInt _index;
	sqInt _numArgs;

	_index = byte0 - FirstSpecialSelector;
	_numArgs = specialSelectorNumArgs(_index);
	return genSendnumArgs(-_index - 1, _numArgs);
}
/* SimpleStackBasedCogit>>#genStoreAndPopReceiverVariableBytecode */
static sqInt
genStoreAndPopReceiverVariableBytecode(void)
{
	return genStorePopReceiverVariableneedsStoreCheckneedsImmutabilityCheck(1, byte0 & 7, ((((ssTop())->type)) != SSConstant) || ((isNonImmediate(((ssTop())->constant))) && (shouldAnnotateObjectReference(((ssTop())->constant)))), 1);
}
/* SimpleStackBasedCogit>>#genStoreAndPopRemoteTempLongBytecode */
static sqInt
genStoreAndPopRemoteTempLongBytecode(void)
{
	return genStorePopRemoteTempAtneedsStoreCheck(1, byte1, byte2, ((((ssTop())->type)) != SSConstant) || ((isNonImmediate(((ssTop())->constant))) && (shouldAnnotateObjectReference(((ssTop())->constant)))));
}
/* SimpleStackBasedCogit>>#genStoreAndPopTemporaryVariableBytecode */
static sqInt
genStoreAndPopTemporaryVariableBytecode(void)
{
	return genStorePopTemporaryVariable(1, byte0 & 7);
}
/* SimpleStackBasedCogit>>#genStoreRemoteTempLongBytecode */
static sqInt
genStoreRemoteTempLongBytecode(void)
{
	return genStorePopRemoteTempAtneedsStoreCheck(0, byte1, byte2, ((((ssTop())->type)) != SSConstant) || ((isNonImmediate(((ssTop())->constant))) && (shouldAnnotateObjectReference(((ssTop())->constant)))));
}
/*	SistaV1: *	217		Trap */
/* SimpleStackBasedCogit>>#genUnconditionalTrapBytecode */
static sqInt
genUnconditionalTrapBytecode(void)
{
	return EncounteredUnknownBytecode;
}
/*	Collect the branch and send data for cogMethod, storing it into arrayObj. */
/* SimpleStackBasedCogit>>#mapPCDataFor:into: */
sqInt
mapPCDataForinto(CogMethod *_cogMethod, sqInt _arrayObj)
{
	sqInt _aMethodObj;
	sqInt _annotation;
	sqInt _bcpc;
	sqInt _byte;
	BytecodeDescriptor *_descriptor;
	sqInt _distance;
	sqInt _endbcpc;
	sqInt _errCode;
	CogMethod *_homeMethod;
	sqInt _isBackwardBranch;
	usqInt _isInBlock;
	sqInt _latestContinuation;
	usqInt _map;
	sqInt _mapByte;
	usqInt _mcpc;
	sqInt _nExts;
	sqInt _nextBcpc;
	sqInt _result;
	sqInt _startbcpc;
	sqInt _targetPC;

	introspectionDataIndex = 0;
	introspectionData = _arrayObj;
	if (((_cogMethod->stackCheckOffset)) == 0) {
		assert(introspectionDataIndex == 0);
		if ((_cogMethod->cpicHasMNUCaseOrCMIsFullBlock)) {
			{
				storePointerUncheckedofObjectwithValue(0, introspectionData, nilObject());
				storePointerUncheckedofObjectwithValue(1, introspectionData, ((((usqInt) cbNoSwitchEntryOffset ) << 3) | 1));
				storePointerUncheckedofObjectwithValue(2, introspectionData, nilObject());
				storePointerUncheckedofObjectwithValue(3, introspectionData, ((((usqInt) cbEntryOffset ) << 3) | 1));
			}
		}
 else {
			{
				storePointerUncheckedofObjectwithValue(0, introspectionData, nilObject());
				storePointerUncheckedofObjectwithValue(1, introspectionData, ((((usqInt) cmEntryOffset ) << 3) | 1));
				storePointerUncheckedofObjectwithValue(2, introspectionData, nilObject());
				storePointerUncheckedofObjectwithValue(3, introspectionData, ((((usqInt) cmNoCheckEntryOffset ) << 3) | 1));
			}
		}
		return 4;
	}
	/* begin mapFor:bcpc:performUntil:arg: */
	_startbcpc = startPCOfMethod((_cogMethod->methodObject));
	assert(((_cogMethod->stackCheckOffset)) > 0);
	_mcpc = ((usqInt) _cogMethod ) + ((_cogMethod->stackCheckOffset));
	_result = pcDataForAnnotationMcpcBcpcMethod(null, 0 + ((sqInt) (((usqInt) HasBytecodePC ) << 1) ), ((char *) _mcpc ), _startbcpc, ((void *) _cogMethod ));
	if (_result != 0) {
		_errCode = _result;
		goto l3;
	}
	_bcpc = _startbcpc;
	_isInBlock = (_cogMethod->cpicHasMNUCaseOrCMIsFullBlock);
	_homeMethod = ((CogMethod *) _cogMethod );
	assert(_startbcpc == (startPCOfMethodHeader((_homeMethod->methodHeader))));
	_map = (((usqInt) _homeMethod ) + ((_homeMethod->blockSize))) - 1;
	_annotation = ((usqInt) (byteAt(_map)) ) >> AnnotationShift;
	assert((_annotation == IsAbsPCReference) || ((_annotation == IsObjectReference) || ((_annotation == IsRelativeCall) || (_annotation == IsDisplacementX2N))));
	_latestContinuation = _startbcpc;
	_aMethodObj = (_homeMethod->methodObject);
	_endbcpc = (numBytesOf(_aMethodObj)) - 1;
	_bcpc += deltaToSkipPrimAndErrorStoreInheader(_aMethodObj, (_homeMethod->methodHeader));
	_nExts = 0;
	{
		enumeratingCogMethod = _homeMethod;
	}
	while ((((usqInt) (byteAt(_map)) ) >> AnnotationShift) != HasBytecodePC) {
		_map -= 1;
	}
	_map -= 1;
	while (((_mapByte = byteAt(_map))) != MapEnd) {
		if (_mapByte >= FirstAnnotation) {
			_annotation = ((usqInt) _mapByte ) >> AnnotationShift;
			_mcpc += (_mapByte & DisplacementMask) * 4;
			if (_annotation >= HasBytecodePC) {
				if ((_annotation == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
					_annotation += _mapByte & DisplacementMask;
					_map -= 1;
				}
				while (1) {
					_byte = fetchByteofObject(_bcpc, _aMethodObj);
					_descriptor = generatorAt(_byte);
					if (_isInBlock) {
						if (_bcpc >= _endbcpc) {
							_errCode = 0;
							goto l3;
						}
					} else {
						if (((_descriptor->isReturn)) && (_bcpc >= _latestContinuation)) {
							_errCode = 0;
							goto l3;
						}
						if (isBranch(_descriptor)) {
							/* begin latestContinuationPCFor:at:exts:in: */
							_distance = ((_descriptor->spanFunction))(_descriptor, _bcpc, _nExts, _aMethodObj);
							_targetPC = (_bcpc + ((_descriptor->numBytes))) + (((_distance < 0) ? 0 : _distance));
							/* end latestContinuationPCFor:at:exts:in: */
							_latestContinuation = ((_latestContinuation < _targetPC) ? _targetPC : _latestContinuation);
						}
					}
					_nextBcpc = _bcpc + ((_descriptor->numBytes));
					if (((_descriptor->isMapped)) || (_isInBlock && ((_descriptor->isMappedInBlock)))) 
						break;
					_bcpc = _nextBcpc;
					_nExts = (((_descriptor->isExtension))
						 ? _nExts + 1
						 : 0);
				}
				_isBackwardBranch = (isBranch(_descriptor)) && ((assert(((_descriptor->spanFunction)) != null), (((_descriptor->spanFunction))(_descriptor, _bcpc, _nExts, _aMethodObj)) < 0));
				_result = pcDataForAnnotationMcpcBcpcMethod(_descriptor, ((_isBackwardBranch)
					 ? ((sqInt) (((usqInt) _annotation ) << 1) ) + 1
					 : ((sqInt) (((usqInt) _annotation ) << 1) )), ((char *) _mcpc ), ((_isBackwardBranch)
					 ? _bcpc - (2 * _nExts)
					 : _bcpc), ((void *) _cogMethod ));
				if (_result != 0) {
					_errCode = _result;
					goto l3;
				}
				_bcpc = _nextBcpc;
				_nExts = (((_descriptor->isExtension))
					 ? _nExts + 1
					 : 0);
			}
		} else {
			assert(((((usqInt) _mapByte ) >> AnnotationShift) == IsDisplacementX2N) || ((((usqInt) _mapByte ) >> AnnotationShift) == IsAnnotationExtension));
			if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
				_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
			}
		}
		_map -= 1;
	}
	_errCode = 0;
	l3:
	;
	/* end mapFor:bcpc:performUntil:arg: */
	if (_errCode != 0) {
		assert(_errCode == PrimErrNoMemory);
		return -1;
	}
	return introspectionDataIndex;
}
/*	If allocCheckFiller is true, words in newSpace from freeStart to 
	scavengeThreshold are filled with their address, and after each call of a 
	plugin primitive, the VM checks 
	that freeStart points to a word containing the value of freeStart. This is 
	a simple 
	check for primitives overwriting the ends of an object. */
/* SimpleStackBasedCogit>>#maybeCompileAllocFillerCheck */
static void
maybeCompileAllocFillerCheck(void)
{
	sqInt _address;
	sqInt _address2;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_jmpOk;

	if (getCheckAllocFiller()) {
		/* begin MoveAw:R: */
		_address = freeStartAddress();
		/* begin gen:literal:operand: */
		checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, ClassReg));
		/* end gen:literal:operand: */
		/* end MoveAw:R: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMwrR, 0, ClassReg, TempReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, ClassReg, TempReg);
		/* end CmpR:R: */
		/* begin JumpZero: */
		_jmpOk = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
		/* end JumpZero: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(MoveCqR, PrimErrWritePastObject, TempReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(PrimErrWritePastObject));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin MoveR:Aw: */
		_address2 = primFailCodeAddress();
		/* begin gen:operand:literal: */
		checkLiteralforInstruction(_address2, genoperandoperand(MoveRAw, TempReg, _address2));
		/* end gen:operand:literal: */
		/* end MoveR:Aw: */
		jmpTarget(_jmpOk, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
}
/* SimpleStackBasedCogit>>#numSpecialSelectors */
static sqInt
numSpecialSelectors(void)
{
	return NumSpecialSelectors;
}
/* SimpleStackBasedCogit>>#pcDataFor:Annotation:Mcpc:Bcpc:Method: */
static sqInt NoDbgRegParms
pcDataForAnnotationMcpcBcpcMethod(BytecodeDescriptor *_descriptor, sqInt _isBackwardBranchAndAnnotation, char *_mcpc, sqInt _bcpc, void *_cogMethodArg)
{
	sqInt _actualBcpc;
	sqInt _actualMcpc;

	if (!_descriptor) {
		assert(introspectionDataIndex == 0);
		if (((((CogMethod *) _cogMethodArg ))->cpicHasMNUCaseOrCMIsFullBlock)) {
			{
				storePointerUncheckedofObjectwithValue(introspectionDataIndex, introspectionData, nilObject());
				storePointerUncheckedofObjectwithValue(introspectionDataIndex + 1, introspectionData, ((((usqInt) cbNoSwitchEntryOffset ) << 3) | 1));
				storePointerUncheckedofObjectwithValue(introspectionDataIndex + 2, introspectionData, nilObject());
				storePointerUncheckedofObjectwithValue(introspectionDataIndex + 3, introspectionData, ((((usqInt) cbEntryOffset ) << 3) | 1));
			}
		}
 else {
			{
				storePointerUncheckedofObjectwithValue(introspectionDataIndex, introspectionData, nilObject());
				storePointerUncheckedofObjectwithValue(introspectionDataIndex + 1, introspectionData, ((((usqInt) cmEntryOffset ) << 3) | 1));
				storePointerUncheckedofObjectwithValue(introspectionDataIndex + 2, introspectionData, nilObject());
				storePointerUncheckedofObjectwithValue(introspectionDataIndex + 3, introspectionData, ((((usqInt) cmNoCheckEntryOffset ) << 3) | 1));
			}
		}
		{
			storePointerUncheckedofObjectwithValue(introspectionDataIndex + 4, introspectionData, ((((usqInt) (_bcpc + 1) ) << 3) | 1));
			storePointerUncheckedofObjectwithValue(introspectionDataIndex + 5, introspectionData, (((((((CogMethod *) _cogMethodArg ))->stackCheckOffset)) << 3) | 1));
		}
		introspectionDataIndex += 6;
		return 0;
	}
	if ((((usqInt) _isBackwardBranchAndAnnotation ) >> 1) >= HasBytecodePC) {
		_actualBcpc = ((_isBackwardBranchAndAnnotation & 1)
			 ? _bcpc + 1
			 : (_bcpc + ((_descriptor->numBytes))) + 1);
		_actualMcpc = ((usqInt) _mcpc ) - ((usqInt) _cogMethodArg );
		{
			storePointerUncheckedofObjectwithValue(introspectionDataIndex, introspectionData, ((((usqInt) _actualBcpc ) << 3) | 1));
			storePointerUncheckedofObjectwithValue(introspectionDataIndex + 1, introspectionData, ((((usqInt) _actualMcpc ) << 3) | 1));
		}
		introspectionDataIndex += 2;
	}
	return 0;
}
/*	If there is a generator for the current primitive then answer it; 
	otherwise answer nil. */
/* SimpleStackBasedCogit>>#primitiveDescriptor */
static PrimitiveDescriptor *
primitiveDescriptor(void)
{
	static PrimitiveDescriptor primitiveGeneratorTable[MaxCompiledPrimitiveIndex+1] = {
	{ 0, -1, 0 },
	{ genPrimitiveAdd, 1, 0 },
	{ genPrimitiveSubtract, 1, 0 },
	{ genPrimitiveLessThan, 1, 0 },
	{ genPrimitiveGreaterThan, 1, 0 },
	{ genPrimitiveLessOrEqual, 1, 0 },
	{ genPrimitiveGreaterOrEqual, 1, 0 },
	{ genPrimitiveEqual, 1, 0 },
	{ genPrimitiveNotEqual, 1, 0 },
	{ genPrimitiveMultiply, 1, 0 },
	{ genPrimitiveDivide, 1, 0 },
	{ genPrimitiveMod, 1, 0 },
	{ genPrimitiveDiv, 1, 0 },
	{ genPrimitiveQuo, 1, 0 },
	{ genPrimitiveBitAnd, 1, 0 },
	{ genPrimitiveBitOr, 1, 0 },
	{ genPrimitiveBitXor, 1, 0 },
	{ genPrimitiveBitShift, 1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genPrimitiveAsFloat, 0, 0 },
	{ genPrimitiveFloatAdd, 1, 0 },
	{ genPrimitiveFloatSubtract, 1, 0 },
	{ genPrimitiveFloatLessThan, 1, 0 },
	{ genPrimitiveFloatGreaterThan, 1, 0 },
	{ genPrimitiveFloatLessOrEqual, 1, 0 },
	{ genPrimitiveFloatGreaterOrEqual, 1, 0 },
	{ genPrimitiveFloatEqual, 1, 0 },
	{ genPrimitiveFloatNotEqual, 1, 0 },
	{ genPrimitiveFloatMultiply, 1, 0 },
	{ genPrimitiveFloatDivide, 1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genPrimitiveFloatSquareRoot, 0, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genPrimitiveAt, 1, 0 },
	{ genPrimitiveAtPut, 2, 0 },
	{ genPrimitiveSize, 0, 0 },
	{ genPrimitiveStringAt, 1, 0 },
	{ genPrimitiveStringAtPut, 2, 0 },
	{ genFastPrimFail, -1, 0 },
	{ genFastPrimFail, -1, 0 },
	{ genFastPrimFail, -1, 0 },
	{ genPrimitiveObjectAt, 1, 0 },
	{ 0, -1, 0 },
	{ genPrimitiveNew, 0, 0 },
	{ genPrimitiveNewWithArg, 1, 0 },
	{ 0, -1, 0 },
	{ genNonImplementedPrimitive, -1, 1 },
	{ 0, -1, 0 },
	{ genPrimitiveIdentityHash, 0, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genPrimitiveNewMethod, 2, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genPrimitivePerform, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genPrimitiveStringReplace, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genPrimitiveIdentical, 1, 0 },
	{ genPrimitiveClass, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genNonImplementedPrimitive, -1, 1 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genNonImplementedPrimitive, -1, 1 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genPrimitiveShallowCopy, 0, 1 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genPrimitiveStringCompareWith, 1, 0 },
	{ genPrimitiveHashMultiply, 0, 0 },
	{ genNonImplementedPrimitive, -1, 1 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genPrimitiveIntegerAt, 1, 0 },
	{ genPrimitiveIntegerAtPut, 2, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genPrimitiveNotIdentical, 1, 0 },
	{ genPrimitiveAsCharacter, -1, 0 },
	{ genPrimitiveImmediateAsInteger, 0, 0 },
	{ 0, -1, 0 },
	{ genNonImplementedPrimitive, -1, 1 },
	{ 0, -1, 0 },
	{ genPrimitiveIdentityHash, 0, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genFastPrimFail, -1, 0 },
	{ genFastPrimFail, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genPrimitiveFullClosureValue, -1, 0 },
	{ 0, -1, 0 },
	{ genPrimitiveFullClosureValue, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genNonImplementedPrimitive, -1, 1 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genPrimitiveFormat, 0, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genPrimitiveSmallFloatAdd, 1, 0 },
	{ genPrimitiveSmallFloatSubtract, 1, 0 },
	{ genPrimitiveSmallFloatLessThan, 1, 0 },
	{ genPrimitiveSmallFloatGreaterThan, 1, 0 },
	{ genPrimitiveSmallFloatLessOrEqual, 1, 0 },
	{ genPrimitiveSmallFloatGreaterOrEqual, 1, 0 },
	{ genPrimitiveSmallFloatEqual, 1, 0 },
	{ genPrimitiveSmallFloatNotEqual, 1, 0 },
	{ genPrimitiveSmallFloatMultiply, 1, 0 },
	{ genPrimitiveSmallFloatDivide, 1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genPrimitiveSmallFloatSquareRoot, 0, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ 0, -1, 0 },
	{ genPrimitiveLoadBoolean8FromBytes, -1, 0 },
	{ genPrimitiveLoadUInt8FromBytes, -1, 0 },
	{ genPrimitiveLoadInt8FromBytes, -1, 0 },
	{ genPrimitiveLoadUInt16FromBytes, -1, 0 },
	{ genPrimitiveLoadInt16FromBytes, -1, 0 },
	{ genPrimitiveLoadUInt32FromBytes, -1, 0 },
	{ genPrimitiveLoadInt32FromBytes, -1, 0 },
	{ genPrimitiveLoadUInt64FromBytes, -1, 0 },
	{ genPrimitiveLoadInt64FromBytes, -1, 0 },
	{ genPrimitiveLoadPointerFromBytes, -1, 0 },
	{ genPrimitiveLoadChar8FromBytes, -1, 0 },
	{ genPrimitiveLoadChar16FromBytes, -1, 0 },
	{ genPrimitiveLoadChar32FromBytes, -1, 0 },
	{ genPrimitiveLoadFloat32FromBytes, -1, 0 },
	{ genPrimitiveLoadFloat64FromBytes, -1, 0 },
	{ genPrimitiveStoreBoolean8IntoBytes, -1, 0 },
	{ genPrimitiveStoreUInt8IntoBytes, -1, 0 },
	{ genPrimitiveStoreInt8IntoBytes, -1, 0 },
	{ genPrimitiveStoreUInt16IntoBytes, -1, 0 },
	{ genPrimitiveStoreInt16IntoBytes, -1, 0 },
	{ genPrimitiveStoreUInt32IntoBytes, -1, 0 },
	{ genPrimitiveStoreInt32IntoBytes, -1, 0 },
	{ genPrimitiveStoreUInt64IntoBytes, -1, 0 },
	{ genPrimitiveStoreInt64IntoBytes, -1, 0 },
	{ genPrimitiveStorePointerIntoBytes, -1, 0 },
	{ genPrimitiveStoreChar8IntoBytes, -1, 0 },
	{ genPrimitiveStoreChar16IntoBytes, -1, 0 },
	{ genPrimitiveStoreChar32IntoBytes, -1, 0 },
	{ genPrimitiveStoreFloat32IntoBytes, -1, 0 },
	{ genPrimitiveStoreFloat64IntoBytes, -1, 0 },
	{ genPrimitiveLoadBoolean8FromExternalAddress, -1, 0 },
	{ genPrimitiveLoadUInt8FromExternalAddress, -1, 0 },
	{ genPrimitiveLoadInt8FromExternalAddress, -1, 0 },
	{ genPrimitiveLoadUInt16FromExternalAddress, -1, 0 },
	{ genPrimitiveLoadInt16FromExternalAddress, -1, 0 },
	{ genPrimitiveLoadUInt32FromExternalAddress, -1, 0 },
	{ genPrimitiveLoadInt32FromExternalAddress, -1, 0 },
	{ genPrimitiveLoadUInt64FromExternalAddress, -1, 0 },
	{ genPrimitiveLoadInt64FromExternalAddress, -1, 0 },
	{ genPrimitiveLoadPointerFromExternalAddress, -1, 0 },
	{ genPrimitiveLoadChar8FromExternalAddress, -1, 0 },
	{ genPrimitiveLoadChar16FromExternalAddress, -1, 0 },
	{ genPrimitiveLoadChar32FromExternalAddress, -1, 0 },
	{ genPrimitiveLoadFloat32FromExternalAddress, -1, 0 },
	{ genPrimitiveLoadFloat64FromExternalAddress, -1, 0 },
	{ genPrimitiveStoreBoolean8IntoExternalAddress, -1, 0 },
	{ genPrimitiveStoreUInt8IntoExternalAddress, -1, 0 },
	{ genPrimitiveStoreInt8IntoExternalAddress, -1, 0 },
	{ genPrimitiveStoreUInt16IntoExternalAddress, -1, 0 },
	{ genPrimitiveStoreInt16IntoExternalAddress, -1, 0 },
	{ genPrimitiveStoreUInt32IntoExternalAddress, -1, 0 },
	{ genPrimitiveStoreInt32IntoExternalAddress, -1, 0 },
	{ genPrimitiveStoreUInt64IntoExternalAddress, -1, 0 },
	{ genPrimitiveStoreInt64IntoExternalAddress, -1, 0 },
	{ genPrimitiveStorePointerIntoExternalAddress, -1, 0 },
	{ genPrimitiveStoreChar8IntoExternalAddress, -1, 0 },
	{ genPrimitiveStoreChar16IntoExternalAddress, -1, 0 },
	{ genPrimitiveStoreChar32IntoExternalAddress, -1, 0 },
	{ genPrimitiveStoreFloat32IntoExternalAddress, -1, 0 },
	{ genPrimitiveStoreFloat64IntoExternalAddress, -1, 0 }
};
	PrimitiveDescriptor *_aPrimitiveDescriptor;

	if (isQuickPrimitiveIndex(primitiveIndex)) {
		_aPrimitiveDescriptor = &(primitiveGeneratorTable[0]);
		(_aPrimitiveDescriptor->primitiveGenerator = quickPrimitiveGeneratorFor(primitiveIndex));
		return _aPrimitiveDescriptor;
	}
	if ((primitiveIndex >= 1) && (primitiveIndex <= MaxCompiledPrimitiveIndex)) {
		return &(primitiveGeneratorTable[primitiveIndex]);
	}
	_aPrimitiveDescriptor = &(primitiveGeneratorTable[0]);
	(_aPrimitiveDescriptor->primitiveGenerator = null);
	(_aPrimitiveDescriptor->primNumArgs = -1);
	(_aPrimitiveDescriptor->primMayCallBack = 0);
	return _aPrimitiveDescriptor;
}
/*	Answer any special requirements of the given primitive. Spur always needs 
	to set 
	primitiveFunctionPointer and newMethod so primitives can retry on failure 
	due to forwarders. */
/* SimpleStackBasedCogit>>#primitivePropertyFlags:primitiveDescriptor: */
static sqInt NoDbgRegParms
primitivePropertyFlagsprimitiveDescriptor(sqInt _primIndex, CogPrimitiveDescriptor *_aPrimitiveDescriptor)
{
	sqInt _baseFlags;

	if (_primIndex == PrimNumberHashMultiply) {
		return PrimCallOnSmalltalkStack;
	}
	_baseFlags = PrimCallNeedsPrimitiveFunction + PrimCallNeedsNewMethod;
	if (hasProfileSemaphore()) {
		_baseFlags = _baseFlags | PrimCallCollectsProfileSamples;
	}
	if ((_aPrimitiveDescriptor->primMayCallBack)) {
		_baseFlags = _baseFlags | PrimCallMayCallBack;
		if (hasCheckAllocFiller()) {
			_baseFlags = _baseFlags | CheckAllocationFillerAfterPrimCall;
		}
	}
	return _baseFlags;
}
/* SimpleStackBasedCogit>>#recordCallOffsetIn: */
void
recordCallOffsetIn(CogMethod *_cogMethod)
{
	sqInt _offset;
	sqInt *_offsetTable;

	_offset = ((primSetFunctionLabel->address)) - ((sqInt) _cogMethod );
	if ((externalSetPrimOffsets[(_cogMethod->cmNumArgs)]) == null) {
		externalSetPrimOffsets[(_cogMethod->cmNumArgs)] = _offset;
	} else {
		assert((externalSetPrimOffsets[(_cogMethod->cmNumArgs)]) == _offset);
	}
	_offsetTable = ((isJump(primInvokeInstruction))
		 ? externalPrimJumpOffsets
		 : externalPrimCallOffsets);
	_offset = (((primInvokeInstruction->address)) + ((primInvokeInstruction->machineCodeSize))) - ((sqInt) _cogMethod );
	if ((_offsetTable[(_cogMethod->cmNumArgs)]) == null) {
		_offsetTable[(_cogMethod->cmNumArgs)] = _offset;
	} else {
		assert((_offsetTable[(_cogMethod->cmNumArgs)]) == _offset);
	}
}
/* SimpleStackBasedCogit>>#rewritePrimInvocationIn:to: */
void
rewritePrimInvocationInto(CogMethod *_cogMethod, void (*_primFunctionPointer)(void))
{
	usqInt _address;
	sqInt _callTargetAddress;
	sqInt _callTargetAddress2;
	sqInt _extent;
	sqInt _flags;
	sqInt _primIndex;

	/* begin enableCodeZoneWriteDuring:flushingCacheWith: */
	/* begin enableCodeZoneWrite */
	if (jitCodeZoneWriteEnabled) {
		error("Code zone writing is not reentrant");
	}
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(0);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryNotExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 1;
	/* end enableCodeZoneWrite */
	{
		assert(((_cogMethod->cmType)) == CMMethod);
		_primIndex = (primitiveIndex = primitiveIndexOfMethodheader((_cogMethod->methodObject), (_cogMethod->methodHeader)));
		_flags = primitivePropertyFlagsprimitiveDescriptor(_primIndex, primitiveDescriptor());
		if (_flags & PrimCallNeedsPrimitiveFunction) {
			storeLiteralbeforeFollowingAddress(backEnd, ((usqInt) _primFunctionPointer ), ((usqInt) _cogMethod ) + (externalSetPrimOffsets[(_cogMethod->cmNumArgs)]));
		}
		if (_flags & PrimCallMayCallBack) {
			_address = ((usqInt) _cogMethod ) + (externalPrimJumpOffsets[(_cogMethod->cmNumArgs)]);
			/* begin rewriteJumpFullAt:target: */
			_callTargetAddress = ((usqInt) _primFunctionPointer );
			_extent = rewriteFullTransferAttargetexpectedInstruction(((AbstractInstruction *) backEnd ), _address, _callTargetAddress, 3592356352U);
			/* end rewriteJumpFullAt:target: */
		} else {
			_address = ((usqInt) _cogMethod ) + (externalPrimCallOffsets[(_cogMethod->cmNumArgs)]);
			/* begin rewriteCallFullAt:target: */
			_callTargetAddress2 = ((usqInt) _primFunctionPointer );
			_extent = rewriteFullTransferAttargetexpectedInstruction(((AbstractInstruction *) backEnd ), _address, _callTargetAddress2, 3778019132U);
			/* end rewriteCallFullAt:target: */
		}
	}
	/* begin disableCodeZoneWrite */
	
#  if READ_ONLY_CODE_ZONE
	{
		
#    if __APPLE__
		{
			pthread_jit_write_protect_np(1);
		}
#    else /* __APPLE__ */
		{
			sqMakeMemoryExecutableFromTo(codeStart(), codeEnd());
		}
#    endif /* __APPLE__ */
	}
#  endif /* READ_ONLY_CODE_ZONE */
	jitCodeZoneWriteEnabled = 0;
	/* end disableCodeZoneWrite */
	{
		flushICacheFromto(((usqInt) _cogMethod ) + cmNoCheckEntryOffset, ((usqInt) _address ) + _extent);
	}
	/* end enableCodeZoneWriteDuring:flushingCacheWith: */
}
/*	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. */
/* SimpleStackBasedCogit>>#seemsToBeInstantiating: */
static sqInt NoDbgRegParms
seemsToBeInstantiating(sqInt _format)
{
	return maybeMethodClassOfseemsToBeInstantiating(methodObj, _format);
}
/*	N.B. This serves for both BlueBook/V3 and V4 short jumps. */
/* SimpleStackBasedCogit>>#v3:ShortForward:Branch:Distance: */
static sqInt NoDbgRegParms
v3ShortForwardBranchDistance(BytecodeDescriptor *descriptor, sqInt _pc, sqInt _nExts, sqInt _aMethodObj)
{
	assert(_nExts == 0);
	return ((fetchByteofObject(_pc, _aMethodObj)) & 7) + 1;
}
/*	242		11110010	i i i i i i i i	Jump i i i i i i i i (+ Extend B * 256, 
	where bbbbbbbb = sddddddd, e.g. -32768 = i=0, a=0, s=1)243		11110011	i i i i i i i i	Pop and Jump 0n True i i i i i i i i (+ 
	Extend A * 256)244		11110100	i i i i i i i i	Pop and Jump 0n False i i i i i i i i (+ 
	Extend A * 256) */
/* SimpleStackBasedCogit>>#v4:LongForward:Branch:Distance: */
static sqInt NoDbgRegParms
v4LongForwardBranchDistance(BytecodeDescriptor *descriptor, sqInt _pc, sqInt _nExts, sqInt _aMethodObj)
{
	sqInt _byte;
	sqInt _extAValue;
	sqInt _extBValue;
	sqInt _extBValue2;
	sqInt _extByte;
	sqInt _pc2;

	assert(_nExts >= 0);
	/* begin parseV4Exts:priorTo:in:into: */
	_extAValue = (_extBValue2 = 0);
	_pc2 = (_pc - _nExts) - _nExts;
	while (_pc2 < _pc) {
		_byte = fetchByteofObject(_pc2, _aMethodObj);
		_pc2 += 1;
		_extByte = fetchByteofObject(_pc2, _aMethodObj);
		_pc2 += 1;
		assert((_byte == 224) || (_byte == 225));
		if (_byte == 224) {
			_extAValue = (((usqInt) _extAValue ) << 8) + _extByte;
		} else {
			_extBValue2 = (((_extBValue2 == 0) && (_extByte > 0x7F))
				 ? _extByte - 256
				 : (((usqInt) _extBValue2 ) << 8) + _extByte);
		}
	}
	{
		_extBValue = _extBValue2;
	}
	/* end parseV4Exts:priorTo:in:into: */
	return (fetchByteofObject(_pc + 1, _aMethodObj)) + ((sqInt) (((usqInt) _extBValue ) << 8) );
}
/*	242		11110010	i i i i i i i i	Jump i i i i i i i i (+ Extend B * 256, 
	where bbbbbbbb = sddddddd, e.g. -32768 = i=0, a=0, s=1) */
/* SimpleStackBasedCogit>>#v4:Long:Branch:Distance: */
static sqInt NoDbgRegParms
v4LongBranchDistance(BytecodeDescriptor *descriptor, sqInt _pc, sqInt _nExts, sqInt _aMethodObj)
{
	sqInt _byte;
	sqInt _extAValue;
	sqInt _extBValue;
	sqInt _extBValue2;
	sqInt _extByte;
	sqInt _pc2;

	assert(_nExts >= 0);
	/* begin parseV4Exts:priorTo:in:into: */
	_extAValue = (_extBValue2 = 0);
	_pc2 = (_pc - _nExts) - _nExts;
	while (_pc2 < _pc) {
		_byte = fetchByteofObject(_pc2, _aMethodObj);
		_pc2 += 1;
		_extByte = fetchByteofObject(_pc2, _aMethodObj);
		_pc2 += 1;
		assert((_byte == 224) || (_byte == 225));
		if (_byte == 224) {
			_extAValue = (((usqInt) _extAValue ) << 8) + _extByte;
		} else {
			_extBValue2 = (((_extBValue2 == 0) && (_extByte > 0x7F))
				 ? _extByte - 256
				 : (((usqInt) _extBValue2 ) << 8) + _extByte);
		}
	}
	{
		_extBValue = _extBValue2;
	}
	/* end parseV4Exts:priorTo:in:into: */
	return (fetchByteofObject(_pc + 1, _aMethodObj)) + ((sqInt) (((usqInt) _extBValue ) << 8) );
}
/* SimpleStackBasedCogit>>#voidCogCompiledCode */
void
voidCogCompiledCode(void)
{
	sqInt _i;

	clearCogCompiledCode();
	for (_i = 0; _i <= MaxNumArgs; _i += 1) {
		externalPrimJumpOffsets[_i] = null;
		externalPrimCallOffsets[_i] = null;
		externalSetPrimOffsets[_i] = null;
	}
}
/*	e.g.	Receiver				Receiver	or	Receiver				Receiver	(RISC) 
	Selector/Arg0	=>		Arg1			Selector/Arg0	=>		Arg1 
	Arg1					Arg2			Arg1					Arg2 
	Arg2					Arg3			Arg2			sp->	Arg3 
	Arg3			sp->	retpc	sp->	Arg3 
	sp->	retpcGenerate code to adjust the possibly stacked arguments immediately 
	before jumping to a method looked up by a perform primitive. */
/* StackToRegisterMappingCogit>>#adjustArgumentsForPerform: */
static void NoDbgRegParms
adjustArgumentsForPerform(sqInt _numArgs)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction11;
	AbstractInstruction *_anInstruction12;
	AbstractInstruction *_anInstruction13;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction4;

	assert((numRegArgs()) <= 2);
	assert(_numArgs >= 1);
	if (_numArgs <= 2) {
		if (_numArgs == 2) {
			/* begin MoveR:R: */
			genoperandoperand(MoveRR, Arg1Reg, Arg0Reg);
			/* end MoveR:R: */
		}
		return;
	}
	if ((2 + 1) == _numArgs) {
		{
			{
				/* begin checkQuickConstant:forInstruction: */
				_anInstruction = genoperandoperandoperand(MoveMwrR, 0, SPReg, Arg1Reg);
				if (usesOutOfLineLiteral(_anInstruction)) {
					(_anInstruction->dependent = locateLiteral(0));
				}
				/* end checkQuickConstant:forInstruction: */
				/* begin checkQuickConstant:forInstruction: */
				_anInstruction2 = genoperandoperandoperand(MoveMwrR, BytesPerWord, SPReg, Arg0Reg);
				if (usesOutOfLineLiteral(_anInstruction2)) {
					(_anInstruction2->dependent = locateLiteral(BytesPerWord));
				}
				/* end checkQuickConstant:forInstruction: */
			}
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction4 = genoperandoperand(AddCqR, (_numArgs + 1) * BytesPerWord, SPReg);
			if (usesOutOfLineLiteral(_anInstruction4)) {
				(_anInstruction4->dependent = locateLiteral((_numArgs + 1) * BytesPerWord));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		return;
	}
	{
		sqInt _index;

		{
			for (_index = _numArgs - 2; _index >= 0; _index += -1) {
				/* begin checkQuickConstant:forInstruction: */
				_anInstruction11 = genoperandoperandoperand(MoveMwrR, _index * BytesPerWord, SPReg, TempReg);
				if (usesOutOfLineLiteral(_anInstruction11)) {
					(_anInstruction11->dependent = locateLiteral(_index * BytesPerWord));
				}
				/* end checkQuickConstant:forInstruction: */
				/* begin checkQuickConstant:forInstruction: */
				_anInstruction12 = genoperandoperandoperand(MoveRMwr, TempReg, (_index + 1) * BytesPerWord, SPReg);
				if (usesOutOfLineLiteral(_anInstruction12)) {
					(_anInstruction12->dependent = locateLiteral((_index + 1) * BytesPerWord));
				}
				/* end checkQuickConstant:forInstruction: */
			}
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction13 = genoperandoperand(AddCqR, BytesPerWord, SPReg);
			if (usesOutOfLineLiteral(_anInstruction13)) {
				(_anInstruction13->dependent = locateLiteral(BytesPerWord));
			}
			/* end checkQuickConstant:forInstruction: */
		}
	}
}
/*	If the stack entry is already in a register not conflicting with regMask, 
	answers it, 
	else allocate a new register not conflicting with reg mask */
/* StackToRegisterMappingCogit>>#allocateRegForStackEntryAt:notConflictingWith: */
static signed char NoDbgRegParms
allocateRegForStackEntryAtnotConflictingWith(sqInt _index, sqInt _regMask)
{
	sqInt _mask;
	CogSimStackEntry *_stackEntry;

	_stackEntry = ssValue(_index);
	_mask = registerMaskOrNone(_stackEntry);
	if ((_mask != 0) && ((_mask & _regMask) == 0)) {
		flag("TODO");
		return registerOrNone(_stackEntry);
	}
	return allocateRegNotConflictingWith(_regMask);
}
/*	if there's a free register, use it */
/* StackToRegisterMappingCogit>>#allocateRegNotConflictingWith: */
static sqInt NoDbgRegParms
allocateRegNotConflictingWith(sqInt _regMask)
{
	sqInt _reg;

	_reg = availableRegisterOrNoneFor(backEnd, (liveRegisters()) | _regMask);
	if (_reg == NoReg) {
		_reg = freeAnyRegNotConflictingWith(_regMask);
	}
	if (_reg == ReceiverResultReg) {
		voidReceiverResultRegContainsSelf();
	}
	return _reg;
}
/*	If the stack entry is already in a register not conflicting with regMask, 
	answers it, 
	else allocate a new register not conflicting with reg mask */
/* StackToRegisterMappingCogit>>#allocateVectorRegForStackEntryAt:notConflictingWith: */

#if FEATURE_JIT_SIMD
static signed char NoDbgRegParms
allocateVectorRegForStackEntryAtnotConflictingWith(sqInt _index, sqInt _regMask)
{
	sqInt _mask;
	CogSimStackEntry *_stackEntry;

	_stackEntry = ssValue(_index);
	_mask = registerMaskOrNone(_stackEntry);
	if ((_mask != 0) && ((_mask & _regMask) == 0)) {
		flag("TODO");
		return registerOrNone(_stackEntry);
	}
	return allocateVectorRegNotConflictingWith(_regMask);
}
#endif /* FEATURE_JIT_SIMD */
/*	if there's a free register, use it */
/* StackToRegisterMappingCogit>>#allocateVectorRegNotConflictingWith: */

#if FEATURE_JIT_SIMD
static sqInt NoDbgRegParms
allocateVectorRegNotConflictingWith(sqInt _regMask)
{
	sqInt _reg;

	_reg = availableVectorRegisterOrNoneFor(backEnd, (liveVectorRegisters()) | _regMask);
	return _reg;
}
#endif /* FEATURE_JIT_SIMD */
/* StackToRegisterMappingCogit>>#anyReferencesToRegister:inTopNItems: */
static sqInt NoDbgRegParms
anyReferencesToRegisterinTopNItems(sqInt _reg, sqInt _n)
{
	sqInt _i;
	sqInt _regMask;

	/* begin registerMaskFor: */
	_regMask = 1ULL << _reg;
	/* end registerMaskFor: */
	for (_i = simStackPtr; _i >= ((simStackPtr - _n) + 1); _i += -1) {
		if ((registerMask(simStackAt(_i))) & _regMask) {
			return 1;
		}
	}
	return 0;
}
/*	This is a static version of ceCallCogCodePopReceiverArg0Regs 
	for break-pointing when debugging in C.This exists only for break-pointing. */
/* StackToRegisterMappingCogit>>#callCogCodePopReceiverArg0Regs */
void
callCogCodePopReceiverArg0Regs(void)
{
	realCECallCogCodePopReceiverArg0Regs();
}
/*	This is a static version of ceCallCogCodePopReceiverArg1Arg0Regs 
	for break-pointing when debugging in C.This exists only for break-pointing. */
/* StackToRegisterMappingCogit>>#callCogCodePopReceiverArg1Arg0Regs */
void
callCogCodePopReceiverArg1Arg0Regs(void)
{
	realCECallCogCodePopReceiverArg1Arg0Regs();
}
/*	Loop over bytecodes, dispatching to the generator for each bytecode, 
	handling fixups in due course. */
/* StackToRegisterMappingCogit>>#compileAbstractInstructionsFrom:through: */
static sqInt NoDbgRegParms
compileAbstractInstructionsFromthrough(sqInt _start, sqInt _end)
{
	BytecodeDescriptor *_descriptor;
	BytecodeFixup *_fixup;
	sqInt _nExts;
	sqInt _nextOpcodeIndex;
	sqInt _result;

	bytecodePC = _start;
	_nExts = (_result = 0);
	_descriptor = null;
	deadCode = 0;
	while (1) {
		mergeWithFixupIfRequired((_fixup = fixupAt(bytecodePC)));
		_descriptor = loadBytesAndGetDescriptor();
		_nextOpcodeIndex = opcodeIndex;
		_result = ((deadCode)
			 ? mapDeadDescriptorIfNeeded(_descriptor)
			 : ((_descriptor->generator))());
		if (_result == 0) {
			/* begin assertExtsAreConsumed: */
			if (!((_descriptor->isExtension))) {
				assert((extA == 0) && ((extB == 0) && (numExtB == 0)));
			}
			/* end assertExtsAreConsumed: */
		}
		/* begin patchFixupTargetIfNeeded:nextOpcodeIndex: */
		if ((((usqInt) ((_fixup->targetInstruction)) ) >= NeedsNonMergeFixupFlag) && (((usqInt) ((_fixup->targetInstruction)) ) <= NeedsMergeFixupFlag)) {
			if (opcodeIndex == _nextOpcodeIndex) {
				/* begin Label */
				genoperandoperand(Label, (labelCounter += 1), bytecodePC);
				/* end Label */
			}
			(_fixup->targetInstruction = abstractInstructionAt(_nextOpcodeIndex));
		}
		/* end patchFixupTargetIfNeeded:nextOpcodeIndex: */
		/* begin maybeDumpLiterals: */
		if ((mustDumpLiterals(opcodeIndex)) || (((isBranch(_descriptor)) && (!(((_descriptor->isBranchTrue)) || ((_descriptor->isBranchFalse))))) || ((_descriptor->isReturn)))) {
			dumpLiterals(!(((isBranch(_descriptor)) && (!(((_descriptor->isBranchTrue)) || ((_descriptor->isBranchFalse))))) || ((_descriptor->isReturn))));
		}
		/* end maybeDumpLiterals: */
		/* begin nextBytecodePCFor:exts: */
		/* begin nextBytecodePCFor:at:exts:in: */
		bytecodePC += (_descriptor->numBytes);
		/* end nextBytecodePCFor:at:exts:in: */
		/* end nextBytecodePCFor:exts: */
		if (!((_result == 0) && (bytecodePC <= _end))) 
			break;
		_nExts = (((_descriptor->isExtension))
			 ? _nExts + 1
			 : 0);
	}
	/* begin checkEnoughOpcodes */
	if (opcodeIndex > numAbstractOpcodes) {
		error("Cog JIT internal error. Too many abstract opcodes.  Num opcodes heuristic is too optimistic.");
	}
	/* end checkEnoughOpcodes */
	return _result;
}
/* StackToRegisterMappingCogit>>#compileCogFullBlockMethod: */
static CogMethod * NoDbgRegParms
compileCogFullBlockMethod(sqInt _numCopied)
{
	sqInt _numberOfAbstractOpcodes;

	methodOrBlockNumTemps = tempCountOf(methodObj);
	{
		sqInt _numBytecodes;
		sqInt _result;
		sqInt _successScan;

		hasYoungReferent = isYoungObject(getMemoryMap(), methodObj);
		methodOrBlockNumArgs = argumentCountOf(methodObj);
		inBlock = InFullBlock;
		postCompileHook = null;
		maxLitIndex = -1;
		initialPC = startPCOfMethod(methodObj);
		endPC = numBytesOf(methodObj);
		_numBytecodes = (endPC - initialPC) + 1;
		primitiveIndex = 0;
		/* begin allocateOpcodes:bytecodes:ifFail: */
		_numberOfAbstractOpcodes = (_numBytecodes + 10) * 15;
		if (_numberOfAbstractOpcodes > MaxNumberOfAbstractOpcodes) {
			{
				return ((CogMethod *) MethodTooBig );
			}
			goto l2;
		}
		ensureAndClearAbstractOpcodes(_numberOfAbstractOpcodes);
		zeroOpcodeIndexForNewOpcodes();
		labelCounter = 0;
		l2:
		;
		/* end allocateOpcodes:bytecodes:ifFail: */
		flag("TODO");
		if (((_successScan = scanMethod())) < 0) {
			return ((CogMethod *) _successScan );
		}
		(methodLabel->dependent = null);
		if (((_result = compileEntireFullBlockMethod(_numCopied))) < 0) {
			return ((CogMethod *) _result );
		}
		return generateCogFullBlock();
	}
	return 0;
}
/* StackToRegisterMappingCogit>>#compileCogMethod: */
static CogMethod * NoDbgRegParms
compileCogMethod(sqInt _selector)
{
	sqInt _numberOfAbstractOpcodes;

	methodOrBlockNumTemps = tempCountOf(methodObj);
	{
		int _extra;
		sqInt _numBytecodes;
		sqInt _result;
		sqInt _successScan;

		hasYoungReferent = (isYoungObject(getMemoryMap(), methodObj)) || (isYoung(_selector));
		methodOrBlockNumArgs = argumentCountOf(methodObj);
		inBlock = 0;
		postCompileHook = null;
		maxLitIndex = -1;
		_extra = (((((primitiveIndex = primitiveIndexOf(methodObj))) > 0) && (!(isQuickPrimitiveIndex(primitiveIndex))))
			 ? 30
			 : 10);
		initialPC = startPCOfMethod(methodObj);
		endPC = ((isQuickPrimitiveIndex(primitiveIndex))
			 ? initialPC - 1
			 : numBytesOf(methodObj));
		_numBytecodes = (endPC - initialPC) + 1;
		/* begin allocateOpcodes:bytecodes:ifFail: */
		_numberOfAbstractOpcodes = (_numBytecodes + _extra) * 15;
		if (_numberOfAbstractOpcodes > MaxNumberOfAbstractOpcodes) {
			{
				return ((CogMethod *) MethodTooBig );
			}
			goto l2;
		}
		ensureAndClearAbstractOpcodes(_numberOfAbstractOpcodes);
		zeroOpcodeIndexForNewOpcodes();
		labelCounter = 0;
		l2:
		;
		/* end allocateOpcodes:bytecodes:ifFail: */
		if (((_successScan = scanMethod())) < 0) {
			return ((CogMethod *) _successScan );
		}
		if (methodFoundInvalidPostScan()) {
			return ((CogMethod *) ShouldNotJIT );
		}
		(methodLabel->dependent = null);
		if (((_result = compileEntireMethod())) < 0) {
			return ((CogMethod *) _result );
		}
		return generateCogMethod(_selector);
	}
	return 0;
}
/*	Compile the abstract instructions for the entire method, including blocks.Compile the abstract instructions for the entire method, including blocks. */
/* StackToRegisterMappingCogit>>#compileEntireMethod */
static sqInt
compileEntireMethod(void)
{
	regArgsHaveBeenPushed = 0;
	{
		sqInt _result;

		/* begin preenMethodLabel */
		/* begin setLabelOffset: */
		((((AbstractInstruction *) methodLabel ))->operands)[1] = 0;
		/* end setLabelOffset: */
		/* end preenMethodLabel */
		compileAbort();
		compileEntry();
		if (((_result = compilePrimitive())) < 0) {
			return _result;
		}
		compileFrameBuild();
		/* begin compileMethodBody */
		if (endPC < initialPC) {
			return 0;
		}
		return compileAbstractInstructionsFromthrough(initialPC + (deltaToSkipPrimAndErrorStoreInheader(methodObj, methodHeader)), endPC);
		/* end compileMethodBody */
	}
	return 0;
}
/*	Build a frame for a CogMethod activation. See CoInterpreter 
	class>>initializeFrameIndices. receiver (in ReceiverResultReg) 
	arg0 
	... 
	argN 
	caller's saved ip/this stackPage (for a base frame) 
	fp->	saved fp 
	method 
	context (uninitialized?) 
	receiver 
	first temp 
	... 
	sp->	Nth temp 
	If there is a primitive and an error code the Nth temp is the error code. 
	Ensure SendNumArgsReg is set early on (incidentally to nilObj) because 
	it is the flag determining whether context switch is allowed on 
	stack-overflow. Build a frame for a CogMethod activation. See CoInterpreter 
	class>>initializeFrameIndices. Override to push the register receiver and 
	register arguments, if any. */
/* StackToRegisterMappingCogit>>#compileFrameBuild */
static void
compileFrameBuild(void)
{
	sqInt _address;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	sqInt _constant;
	sqInt _iLimit;

	
#  if IMMUTABILITY
	{
		if (useTwoPaths) {
			compileTwoPathFrameBuild();
			return;
		}
	}
#  endif /* IMMUTABILITY */
	if (!needsFrame) {
		if (useTwoPaths) {
			compileTwoPathFramelessInit();
		}
		initSimStackForFramelessMethod(initialPC);
		return;
	}
	assert(!useTwoPaths);
	genPushRegisterArgs();
	{
		sqInt _i;
		AbstractInstruction *_jumpSkip;

		if (!needsFrame) {
			return;
		}
		{
			/* begin PushR: */
			genoperand(PushR, LinkReg);
			/* end PushR: */
		}
		/* begin PushR: */
		genoperand(PushR, FPReg);
		/* end PushR: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SPReg, FPReg);
		/* end MoveR:R: */
		addDependent(methodLabel, annotateAbsolutePCRef(gPushCw(((sqInt) methodLabel ))));
		/* begin genMoveNilR: */
		/* begin genMoveConstant:R: */
		_constant = nilObject();
		if (shouldAnnotateObjectReference(_constant)) {
			annotateobjRef(gMoveCwR(_constant, SendNumArgsReg), _constant);
		} else {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperand(MoveCqR, _constant, SendNumArgsReg);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(_constant));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		/* end genMoveConstant:R: */
		/* end genMoveNilR: */
		/* begin PushR: */
		genoperand(PushR, SendNumArgsReg);
		/* end PushR: */
		/* begin PushR: */
		genoperand(PushR, ReceiverResultReg);
		/* end PushR: */
		for (_i = methodOrBlockNumArgs + 1, _iLimit = temporaryCountOfMethodHeader(methodHeader); _i <= _iLimit; _i += 1) {
			/* begin PushR: */
			genoperand(PushR, SendNumArgsReg);
			/* end PushR: */
		}
		if (((primitiveIndexOfMethodheader(methodObj, methodHeader)) > 0) && ((longStoreBytecodeForHeader(methodHeader)) == (fetchByteofObject((startPCOfMethod(methodObj)) + (sizeOfCallPrimitiveBytecode(methodHeader)), methodObj)))) {
			compileGetErrorCode();
		}
		/* begin MoveAw:R: */
		_address = stackLimitAddress();
		/* begin gen:literal:operand: */
		checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, TempReg));
		/* end gen:literal:operand: */
		/* end MoveAw:R: */
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, TempReg, SPReg);
		/* end CmpR:R: */
		if (canContextSwitchIfActivatingheader(methodObj, methodHeader)) {
			/* begin JumpBelow: */
			genConditionalBranchoperand(JumpBelow, ((sqInt) stackOverflowCall ));
			/* end JumpBelow: */
			/* begin Label */
			stackCheckLabel = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
			/* end Label */
		} else {
			/* begin JumpAboveOrEqual: */
			_jumpSkip = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
			/* end JumpAboveOrEqual: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction2 = genoperandoperand(MoveCqR, 0, SendNumArgsReg);
			if (usesOutOfLineLiteral(_anInstruction2)) {
				(_anInstruction2->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
			/* begin Jump: */
			genoperand(Jump, ((sqInt) stackOverflowCall ));
			/* end Jump: */
			jmpTarget(_jumpSkip, (stackCheckLabel = genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
		}
		/* begin annotateBytecode: */
		(stackCheckLabel->annotation = HasBytecodePC);
		/* end annotateBytecode: */
	}
	initSimStackForFramefulMethod(initialPC);
}
/*	Make sure ReceiverResultReg holds the receiver, loaded from the closure, 
	which is what is initially in ReceiverResultReg. Make sure ReceiverResultReg holds the receiver, loaded from 
	the closure, which is what is initially in ReceiverResultReg */
/* StackToRegisterMappingCogit>>#compileFullBlockFramelessEntry: */
static void NoDbgRegParms
compileFullBlockFramelessEntry(sqInt numCopied)
{
	initSimStackForFramelessBlock(initialPC);
	{
		flag("TODO");
		genLoadSlotsourceRegdestReg(FullClosureReceiverIndex, ReceiverResultReg, Arg0Reg);
		genEnsureOopInRegNotForwardedscratchRegupdatingSlotin(Arg0Reg, TempReg, FullClosureReceiverIndex, ReceiverResultReg);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg0Reg, ReceiverResultReg);
		/* end MoveR:R: */
	}
}
/*	Build a frame for a block activation. See CoInterpreter 
	class>>initializeFrameIndices. closure (in ReceiverResultReg) 
	arg0 
	... 
	argN 
	caller's saved ip/this stackPage (for a base frame) 
	fp->	saved fp 
	method 
	context (uninitialized?) 
	receiver 
	first temp 
	... 
	sp->	Nth temp 
	Avoid use of SendNumArgsReg which is the flag determining whether 
	context switch is allowed on stack-overflow. */
/* StackToRegisterMappingCogit>>#compileFullBlockMethodFrameBuild: */
static void NoDbgRegParms
compileFullBlockMethodFrameBuild(sqInt _numCopied)
{
	AbstractInstruction *_abstractInstruction;
	sqInt _address;
	AbstractInstruction *_anInstruction;
	sqInt _constant;
	sqInt _iLimit;

	if (useTwoPaths) {
		useTwoPaths = 0;
		
#    if IMMUTABILITY
		{
			needsFrame = 1;
		}
#    endif /* IMMUTABILITY */
	}
	if (!needsFrame) {
		assert(_numCopied == 0);
		compileFullBlockFramelessEntry(_numCopied);
		initSimStackForFramelessBlock(initialPC);
		return;
	}
	{
		sqInt _i;

		if (!needsFrame) {
			return;
		}
		{
			/* begin PushR: */
			genoperand(PushR, LinkReg);
			/* end PushR: */
		}
		/* begin PushR: */
		genoperand(PushR, FPReg);
		/* end PushR: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SPReg, FPReg);
		/* end MoveR:R: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, ReceiverResultReg, ClassReg);
		/* end MoveR:R: */
		{
			addDependent(methodLabel, annotateAbsolutePCRef(gPushCw(((sqInt) methodLabel ))));
			/* begin setLabelOffset: */
			((((AbstractInstruction *) methodLabel ))->operands)[1] = MFMethodFlagIsBlockFlag;
			/* end setLabelOffset: */
		}
		/* begin genMoveNilR: */
		/* begin genMoveConstant:R: */
		_constant = nilObject();
		if (shouldAnnotateObjectReference(_constant)) {
			annotateobjRef(gMoveCwR(_constant, SendNumArgsReg), _constant);
		} else {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperand(MoveCqR, _constant, SendNumArgsReg);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(_constant));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		/* end genMoveConstant:R: */
		/* end genMoveNilR: */
		/* begin PushR: */
		genoperand(PushR, SendNumArgsReg);
		/* end PushR: */
		flag("TODO");
		genLoadSlotsourceRegdestReg(FullClosureReceiverIndex, ClassReg, Arg0Reg);
		genEnsureOopInRegNotForwardedscratchRegupdatingSlotin(Arg0Reg, TempReg, FullClosureReceiverIndex, ReceiverResultReg);
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, Arg0Reg, ReceiverResultReg);
		/* end MoveR:R: */
		/* begin PushR: */
		genoperand(PushR, ReceiverResultReg);
		/* end PushR: */
		for (_i = 0; _i < _numCopied; _i += 1) {
			genLoadSlotsourceRegdestReg(_i + FullClosureFirstCopiedValueIndex, ClassReg, TempReg);
			/* begin PushR: */
			genoperand(PushR, TempReg);
			/* end PushR: */
		}
		for (_i = (methodOrBlockNumArgs + _numCopied) + 1, _iLimit = temporaryCountOfMethodHeader(methodHeader); _i <= _iLimit; _i += 1) {
			/* begin PushR: */
			genoperand(PushR, SendNumArgsReg);
			/* end PushR: */
		}
		/* begin MoveAw:R: */
		_address = stackLimitAddress();
		/* begin gen:literal:operand: */
		checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, TempReg));
		/* end gen:literal:operand: */
		/* end MoveAw:R: */
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, TempReg, SPReg);
		/* end CmpR:R: */
		/* begin JumpBelow: */
		genConditionalBranchoperand(JumpBelow, ((sqInt) stackOverflowCall ));
		/* end JumpBelow: */
		/* begin annotateBytecode: */
		_abstractInstruction = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
		(_abstractInstruction->annotation = HasBytecodePC);
		stackCheckLabel = _abstractInstruction;
		/* end annotateBytecode: */
	}
	initSimStackForFramefulMethod(initialPC);
}
/*	Build a frame for a CogMethod activation. See CoInterpreter 
	class>>initializeFrameIndices. receiver (in ReceiverResultReg) 
	arg0 
	... 
	argN 
	caller's saved ip/this stackPage (for a base frame) 
	fp->	saved fp 
	method 
	context (uninitialized?) 
	receiver 
	first temp 
	... 
	sp->	Nth temp 
	If there is a primitive and an error code the Nth temp is the error code. 
	Ensure SendNumArgsReg is set early on (incidentally to nilObj) because 
	it is the flag determining whether context switch is allowed on 
	stack-overflow. We are in a method where the frame is needed *only* for instance variable 
	store, typically a setter method. 
	This case has 20% overhead with Immutability compared to setter without 
	immutability because of the stack 
	frame creation. We compile two path, one where the object is immutable, 
	one where it isn't. At the beginning  
	of the frame build, we take one path or the other depending on the 
	receiver mutability. 
	 
	Note: this specific case happens only where there are only instance 
	variabel stores. We could do something 
	similar for literal variable stores, but we don't as it's too uncommon. */
/* StackToRegisterMappingCogit>>#compileTwoPathFrameBuild */

#if IMMUTABILITY
static void
compileTwoPathFrameBuild(void)
{
	sqInt _address;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _constant;
	sqInt _iLimit;
	AbstractInstruction * _jumpImmutable;
	AbstractInstruction * _jumpOld;
	sqInt _quickConstant;

	assert(useTwoPaths);
	_jumpImmutable = genJumpImmutablescratchReg(ReceiverResultReg, TempReg);
	{
		/* begin CmpCq:R: */
		_quickConstant = storeCheckBoundary();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, _quickConstant, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpAboveOrEqual: */
		_jumpOld = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
		/* end JumpAboveOrEqual: */
	}
	assert(!needsFrame);
	initSimStackForFramelessMethod(initialPC);
	/* begin compileMethodBody */
	if (endPC < initialPC) {
		goto l16;
	}
	compileAbstractInstructionsFromthrough(initialPC + (deltaToSkipPrimAndErrorStoreInheader(methodObj, methodHeader)), endPC);
	l16:
	;
	/* end compileMethodBody */
	useTwoPaths = 0;
	needsFrame = 1;
	jmpTarget(_jumpOld, jmpTarget(_jumpImmutable, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	genPushRegisterArgs();
	{
		sqInt _i;
		AbstractInstruction *_jumpSkip;

		if (!needsFrame) {
			return;
		}
		{
			/* begin PushR: */
			genoperand(PushR, LinkReg);
			/* end PushR: */
		}
		/* begin PushR: */
		genoperand(PushR, FPReg);
		/* end PushR: */
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, SPReg, FPReg);
		/* end MoveR:R: */
		addDependent(methodLabel, annotateAbsolutePCRef(gPushCw(((sqInt) methodLabel ))));
		/* begin genMoveNilR: */
		/* begin genMoveConstant:R: */
		_constant = nilObject();
		if (shouldAnnotateObjectReference(_constant)) {
			annotateobjRef(gMoveCwR(_constant, SendNumArgsReg), _constant);
		} else {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction2 = genoperandoperand(MoveCqR, _constant, SendNumArgsReg);
			if (usesOutOfLineLiteral(_anInstruction2)) {
				(_anInstruction2->dependent = locateLiteral(_constant));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		/* end genMoveConstant:R: */
		/* end genMoveNilR: */
		/* begin PushR: */
		genoperand(PushR, SendNumArgsReg);
		/* end PushR: */
		/* begin PushR: */
		genoperand(PushR, ReceiverResultReg);
		/* end PushR: */
		for (_i = methodOrBlockNumArgs + 1, _iLimit = temporaryCountOfMethodHeader(methodHeader); _i <= _iLimit; _i += 1) {
			/* begin PushR: */
			genoperand(PushR, SendNumArgsReg);
			/* end PushR: */
		}
		if (((primitiveIndexOfMethodheader(methodObj, methodHeader)) > 0) && ((longStoreBytecodeForHeader(methodHeader)) == (fetchByteofObject((startPCOfMethod(methodObj)) + (sizeOfCallPrimitiveBytecode(methodHeader)), methodObj)))) {
			compileGetErrorCode();
		}
		/* begin MoveAw:R: */
		_address = stackLimitAddress();
		/* begin gen:literal:operand: */
		checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, TempReg));
		/* end gen:literal:operand: */
		/* end MoveAw:R: */
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, TempReg, SPReg);
		/* end CmpR:R: */
		if (canContextSwitchIfActivatingheader(methodObj, methodHeader)) {
			/* begin JumpBelow: */
			genConditionalBranchoperand(JumpBelow, ((sqInt) stackOverflowCall ));
			/* end JumpBelow: */
			/* begin Label */
			stackCheckLabel = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
			/* end Label */
		} else {
			/* begin JumpAboveOrEqual: */
			_jumpSkip = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
			/* end JumpAboveOrEqual: */
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction3 = genoperandoperand(MoveCqR, 0, SendNumArgsReg);
			if (usesOutOfLineLiteral(_anInstruction3)) {
				(_anInstruction3->dependent = locateLiteral(0));
			}
			/* end checkQuickConstant:forInstruction: */
			/* begin Jump: */
			genoperand(Jump, ((sqInt) stackOverflowCall ));
			/* end Jump: */
			jmpTarget(_jumpSkip, (stackCheckLabel = genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
		}
		/* begin annotateBytecode: */
		(stackCheckLabel->annotation = HasBytecodePC);
		/* end annotateBytecode: */
	}
	initSimStackForFramefulMethod(initialPC);
}
#endif /* IMMUTABILITY */
/*	We are in a frameless method with at least two inst var stores. We compile 
	two paths, 
	one where the object is in new space, and one where it isn't. At the 
	beginning  
	of the method, we take one path or the other depending on the receiver 
	being in newSpace. */
/* StackToRegisterMappingCogit>>#compileTwoPathFramelessInit */
static void
compileTwoPathFramelessInit(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction * _jumpOld;
	sqInt _quickConstant;

	assert(!IMMUTABILITY);
	assert(!needsFrame);
	assert(useTwoPaths);
	{
		/* begin CmpCq:R: */
		_quickConstant = storeCheckBoundary();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, _quickConstant, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpAboveOrEqual: */
		_jumpOld = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) 0 ));
		/* end JumpAboveOrEqual: */
	}
	initSimStackForFramelessMethod(initialPC);
	/* begin compileMethodBody */
	if (endPC < initialPC) {
		goto l2;
	}
	compileAbstractInstructionsFromthrough(initialPC + (deltaToSkipPrimAndErrorStoreInheader(methodObj, methodHeader)), endPC);
	l2:
	;
	/* end compileMethodBody */
	useTwoPaths = 0;
	jmpTarget(_jumpOld, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
}
/* StackToRegisterMappingCogit>>#cPICMissTrampolineFor: */
static sqInt NoDbgRegParms
cPICMissTrampolineFor(sqInt _numArgs)
{
	return picMissTrampolines[((_numArgs < (2 + 1)) ? _numArgs : 2 + 1)];
}
/* StackToRegisterMappingCogit>>#duplicateTopBytecode */
static sqInt
duplicateTopBytecode(void)
{
	SimStackEntry _desc;

	/* begin ssTopDescriptor */
	_desc = simStack[simStackPtr];
	/* end ssTopDescriptor */
	return ssPushDesc(_desc);
}
/* StackToRegisterMappingCogit>>#ensureFixupAt: */
static BytecodeFixup * NoDbgRegParms
ensureFixupAt(sqInt _targetPC)
{
	return ensureFixupAtwithStackPointer(_targetPC, simStackPtr);
}
/*	Make sure there's a flagged fixup at the target pc in fixups. 
	Initially a fixup's target is just a flag. Later on it is replaced with a 
	proper instruction. */
/* StackToRegisterMappingCogit>>#ensureFixupAt:withStackPointer: */
static BytecodeFixup * NoDbgRegParms
ensureFixupAtwithStackPointer(sqInt _targetPC, sqInt _aStackPointer)
{
	BytecodeFixup *_fixup;

	/* begin fixupAt: */
	_fixup = fixupAtIndex(_targetPC - initialPC);
	/* end fixupAt: */
	if (((usqInt) ((_fixup->targetInstruction)) ) <= NeedsNonMergeFixupFlag) {
		/* begin becomeMergeFixup */
		(_fixup->targetInstruction) = ((AbstractInstruction *) NeedsMergeFixupFlag );
		/* end becomeMergeFixup */
		(_fixup->simStackPtr = _aStackPointer);
	} else {
		if ((_fixup->isTargetOfBackwardBranch)) {
			(_fixup->simStackPtr = _aStackPointer);
		} else {
			assert(((_fixup->simStackPtr)) == _aStackPointer);
		}
	}
	/* begin recordBcpc: */
	/* end recordBcpc: */
	return _fixup;
}
/*	Make sure there's a flagged fixup at the target pc in fixups. 
	Initially a fixup's target is just a flag. Later on it is replaced with a 
	proper instruction. */
/* StackToRegisterMappingCogit>>#ensureNonMergeFixupAt: */
static BytecodeFixup * NoDbgRegParms
ensureNonMergeFixupAt(sqInt _targetPC)
{
	BytecodeFixup *_fixup;

	/* begin fixupAt: */
	_fixup = fixupAtIndex(_targetPC - initialPC);
	/* end fixupAt: */
	if (((_fixup->targetInstruction)) == 0) {
		/* begin becomeNonMergeFixup */
		(_fixup->targetInstruction) = ((AbstractInstruction *) NeedsNonMergeFixupFlag );
		/* end becomeNonMergeFixup */
	}
	/* begin recordBcpc: */
	/* end recordBcpc: */
	return _fixup;
}
/* StackToRegisterMappingCogit>>#ensureReceiverResultRegContainsSelf */
static void
ensureReceiverResultRegContainsSelf(void)
{
	if (needsFrame) {
		if (!((((simSelf())->liveRegister)) == ReceiverResultReg)) {
			/* begin ssAllocateRequiredReg: */
			ssAllocateRequiredRegMaskupThrough(1U << ReceiverResultReg, simStackPtr);
			/* end ssAllocateRequiredReg: */
			/* begin putSelfInReceiverResultReg */
			copyToReg(simSelf(), ReceiverResultReg);
			/* end putSelfInReceiverResultReg */
			((simSelf())->liveRegister = ReceiverResultReg);
		}
	} else {
		assert(((((simSelf())->type)) == SSRegister) && (((((simSelf())->registerr)) == ReceiverResultReg) && (receiverIsInReceiverResultReg())));
	}
}
/* StackToRegisterMappingCogit>>#evaluate:at: */
static void NoDbgRegParms
evaluateat(BytecodeDescriptor *_descriptor, sqInt _pc)
{
	byte0 = fetchByteofObject(_pc, methodObj);
	assert(_descriptor == (generatorAt(byte0)));
	loadSubsequentBytesForDescriptorat(_descriptor, _pc);
	((_descriptor->generator))();
}
/*	Attempt to follow a branch to a pc. Handle branches to unconditional jumps 
	and branches to push: aBoolean; conditional branch pairs. If the branch 
	cannot be 
	followed answer targetBytecodePC. It is not possible to follow jumps to 
	conditional branches because the stack changes depth. That following is 
	left to the genJumpIf:to: 
	clients. */
/* StackToRegisterMappingCogit>>#eventualTargetOf: */
static sqInt NoDbgRegParms
eventualTargetOf(sqInt _targetBytecodePC)
{
	int _cond;
	sqInt _currentTarget;
	BytecodeDescriptor *_descriptor;
	int _nExts;
	sqInt _nextPC;
	sqInt _span;

	_cond = 0;
	_nextPC = (_currentTarget = _targetBytecodePC);
	while (1) {
		_nExts = 0;
		while (1) {
			/* begin generatorForPC: */
			_descriptor = generatorAt(fetchByteofObject(_nextPC, methodObj));
			/* end generatorForPC: */
			if ((_descriptor->isReturn)) {
				return _currentTarget;
			}
			if (!((_descriptor->isExtension))) 
				break;
			_nExts += 1;
			_nextPC += (_descriptor->numBytes);
		}
		if ((isBranch(_descriptor)) && (!(((_descriptor->isBranchTrue)) || ((_descriptor->isBranchFalse))))) {
			/* begin spanFor:at:exts:in: */
			_span = ((_descriptor->spanFunction))(_descriptor, _nextPC, _nExts, methodObj);
			/* end spanFor:at:exts:in: */
			if (_span < 0) {
				return _currentTarget;
			}
			_nextPC = (_nextPC + ((_descriptor->numBytes))) + _span;
		} else {
			if (((_descriptor->generator)) == genPushConstantTrueBytecode) {
				_cond = 1;
			} else {
				if (((_descriptor->generator)) == genPushConstantFalseBytecode) {
					_cond = 0;
				} else {
					return _currentTarget;
				}
			}
			if (((fixupAt(_nextPC))->isTargetOfBackwardBranch)) {
				return _currentTarget;
			}
			_nextPC = eventualTargetOf(_nextPC + ((_descriptor->numBytes)));
			_nExts = 0;
			while (1) {
				/* begin generatorForPC: */
				_descriptor = generatorAt(fetchByteofObject(_nextPC, methodObj));
				/* end generatorForPC: */
				if ((_descriptor->isReturn)) {
					return _currentTarget;
				}
				if (!((_descriptor->isExtension))) 
					break;
				_nExts += 1;
				_nextPC += (_descriptor->numBytes);
			}
			if (!(isBranch(_descriptor))) {
				return _currentTarget;
			}
			if ((isBranch(_descriptor)) && (!(((_descriptor->isBranchTrue)) || ((_descriptor->isBranchFalse))))) {
				return _currentTarget;
			}
			_nextPC = ((_cond == ((_descriptor->isBranchTrue)))
				 ? (_nextPC + ((_descriptor->numBytes))) + (((_descriptor->spanFunction))(_descriptor, _nextPC, _nExts, methodObj))
				 : _nextPC + ((_descriptor->numBytes)));
		}
		_currentTarget = _nextPC;
	}
	return 0;
}
/*	Spill the closest register on stack not conflicting with regMask.  
	Assertion Failure if regMask has already all the registers */
/* StackToRegisterMappingCogit>>#freeAnyRegNotConflictingWith: */
static sqInt NoDbgRegParms
freeAnyRegNotConflictingWith(sqInt _regMask)
{
	CogSimStackEntry *_desc;
	sqInt _index;
	sqInt _reg;

	assert(needsFrame);
	_reg = NoReg;
	_index = ((simSpillBase < 0) ? 0 : simSpillBase);
	while ((_reg == NoReg) && (_index < simStackPtr)) {
		_desc = simStackAt(_index);
		if (((_desc->type)) == SSRegister) {
			if (!(_regMask & (1ULL << ((_desc->registerr))))) {
				_reg = (_desc->registerr);
			}
		}
		_index += 1;
	}
	assert(!(_reg == NoReg));
	/* begin ssAllocateRequiredReg: */
	ssAllocateRequiredRegMaskupThrough(1ULL << _reg, simStackPtr);
	/* end ssAllocateRequiredReg: */
	return _reg;
}
/* StackToRegisterMappingCogit>>#genAddFloat32Vector */

#if FEATURE_JIT_SIMD
static sqInt
genAddFloat32Vector(void)
{
	signed char _array1Reg;
	signed char _array2Reg;
	sqInt _sumReg;

	_array2Reg = allocateVectorRegForStackEntryAtnotConflictingWith(0, 0);
	_array1Reg = allocateVectorRegForStackEntryAtnotConflictingWith(1, 1ULL << _array2Reg);
	_sumReg = _array1Reg;
	ssPopTopToVectorReg(_array2Reg);
	ssPopTopToVectorReg(_array1Reg);
	gFaddSRvRvRv(32, _array1Reg, _array2Reg, _sumReg);
	ssPushVectorRegister(_sumReg);
	return 0;
}
#endif /* FEATURE_JIT_SIMD */
/* StackToRegisterMappingCogit>>#genAddFloat64Vector */

#if FEATURE_JIT_SIMD
static sqInt
genAddFloat64Vector(void)
{
	signed char _array1Reg;
	signed char _array2Reg;
	sqInt _sumReg;

	_array2Reg = allocateVectorRegForStackEntryAtnotConflictingWith(0, 0);
	_array1Reg = allocateVectorRegForStackEntryAtnotConflictingWith(1, 1ULL << _array2Reg);
	_sumReg = _array1Reg;
	ssPopTopToVectorReg(_array2Reg);
	ssPopTopToVectorReg(_array1Reg);
	gFaddSRvRvRv(64, _array1Reg, _array2Reg, _sumReg);
	ssPushVectorRegister(_sumReg);
	return 0;
}
#endif /* FEATURE_JIT_SIMD */
/*	Return from block, assuming result already loaded into ReceiverResultReg.Return from block, assuming result already loaded into ReceiverResultReg. */
/* StackToRegisterMappingCogit>>#genBlockReturn */
static sqInt
genBlockReturn(void)
{
	{
		if (needsFrame) {
			/* begin MoveR:R: */
			genoperandoperand(MoveRR, FPReg, SPReg);
			/* end MoveR:R: */
			/* begin PopR: */
			genoperand(PopR, FPReg);
			/* end PopR: */
			{
				/* begin PopR: */
				genoperand(PopR, LinkReg);
				/* end PopR: */
			}
		}
		/* begin RetN: */
		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
		/* end RetN: */
	}
	deadCode = 1;
	return 0;
}
/*	SistaV1:	236		11101100	iiiiiiii		callMappedInlinedPrimitive */
/* StackToRegisterMappingCogit>>#genCallMappedInlinedPrimitive */
static sqInt
genCallMappedInlinedPrimitive(void)
{
	return genMappedInlinePrimitive(byte1);
}
/*	Generate special versions of the ceCallCogCodePopReceiverAndClassRegs 
	enilopmart that also pop register args from the stack to undo the pushing 
	of register args in the abort/miss trampolines. */
/* StackToRegisterMappingCogit>>#genCallPICEnilopmartNumArgs: */
static void (*genCallPICEnilopmartNumArgs(sqInt _numArgs))(void)

{
	AbstractInstruction *_anInstruction;
	sqInt _endAddress;
	sqInt _enilopmart;
	sqInt _quickConstant;
	sqInt _reg;
	sqInt _size;

	zeroOpcodeIndex();
	{
		/* begin MoveCq:R: */
		_quickConstant = varBaseAddress();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, _quickConstant, VarBaseReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveCq:R: */
	}
	genLoadStackPointers(backEnd);
	/* begin PopR: */
	genoperand(PopR, ClassReg);
	/* end PopR: */
	/* begin PopR: */
	genoperand(PopR, TempReg);
	/* end PopR: */
	/* begin PopR: */
	_reg = LinkReg;
	genoperand(PopR, _reg);
	/* end PopR: */
	if (_numArgs > 0) {
		if (_numArgs > 1) {
			/* begin PopR: */
			genoperand(PopR, Arg1Reg);
			/* end PopR: */
			assert((numRegArgs()) == 2);
		}
		/* begin PopR: */
		genoperand(PopR, Arg0Reg);
		/* end PopR: */
	}
	/* begin PopR: */
	genoperand(PopR, ReceiverResultReg);
	/* end PopR: */
	/* begin JumpR: */
	genoperand(JumpR, TempReg);
	/* end JumpR: */
	computeMaximumSizes();
	_size = generateInstructionsAt(methodZoneBase);
	_endAddress = outputInstructionsAt(methodZoneBase);
	assert((methodZoneBase + _size) == _endAddress);
	_enilopmart = methodZoneBase;
	methodZoneBase = alignUptoRoutineBoundary(_endAddress);
	stopsFromto(backEnd, _endAddress, methodZoneBase - 1);
	recordGeneratedRunTimeaddress(trampolineNamenumRegArgs("ceCallPIC", _numArgs), _enilopmart);
	return ((void (*)(void)) _enilopmart );
}
/*	SistaV1: 248		11111000 iiiiiiii		mjjjjjjj		Call Primitive #iiiiiiii + 
	(jjjjjjj * 256) m=1 means inlined primitive, no hard return after 
	execution. See EncoderForSistaV1's class comment and 
	StackInterpreter>>#inlinePrimitiveBytecode:  */
/* StackToRegisterMappingCogit>>#genCallPrimitiveBytecode */
static sqInt
genCallPrimitiveBytecode(void)
{
	sqInt _prim;
	sqInt _primSet;

	if (byte2 < 128) {
		return ((bytecodePC == initialPC)
			 ? 0
			 : EncounteredUnknownBytecode);
	}
	_prim = ((sqInt) (((usqInt) (byte2 - 128) ) << 8) ) + byte1;
	_primSet = (((usqInt) _prim ) >> 13) & 3;
	_prim = _prim & 0x1FFF;
	return EncounteredUnknownBytecode;
}
/*	Override to push the register receiver and register arguments, if any. */
/* StackToRegisterMappingCogit>>#genExternalizePointersForPrimitiveCall */
static sqInt
genExternalizePointersForPrimitiveCall(void)
{
	sqInt _address;
	sqInt _address2;
	sqInt _address5;

	genPushRegisterArgs();
	{
		/* begin MoveR:Aw: */
		_address5 = framePointerAddress();
		/* begin gen:operand:literal: */
		checkLiteralforInstruction(_address5, genoperandoperand(MoveRAw, FPReg, _address5));
		/* end gen:operand:literal: */
		/* end MoveR:Aw: */
		{
			/* begin MoveR:Aw: */
			_address = stackPointerAddress();
			/* begin gen:operand:literal: */
			checkLiteralforInstruction(_address, genoperandoperand(MoveRAw, SPReg, _address));
			/* end gen:operand:literal: */
			/* end MoveR:Aw: */
			/* begin MoveR:Aw: */
			_address2 = instructionPointerAddress();
			/* begin gen:operand:literal: */
			checkLiteralforInstruction(_address2, genoperandoperand(MoveRAw, LinkReg, _address2));
			/* end gen:operand:literal: */
			/* end MoveR:Aw: */
		}
		return 0;
	}
	return 0;
}
/*	Full Block creation compilation. The block's actual code will be compiled 
	separatedly. *	255		11111111	xxxxxxxx	siyyyyyy	push Closure Compiled block literal 
	index xxxxxxxx (+ Extend A * 256) numCopied yyyyyy receiverOnStack: s = 1 
	ignoreOuterContext: i = 1 */
/* StackToRegisterMappingCogit>>#genExtPushFullClosureBytecode */
static sqInt
genExtPushFullClosureBytecode(void)
{
	sqInt _compiledBlock;
	sqInt _i;
	int _ignoreContext;
	sqInt _numCopied;
	int _receiverIsOnStack;
	sqInt _reg;

	assert(needsFrame);
	_compiledBlock = getLiteral(byte1 + ((sqInt) (((usqInt) extA ) << 8) ));
	extA = 0;
	_numCopied = byte2 & ((1U << 6) - 1);
	_receiverIsOnStack = byte2 & (1U << 7);
	_ignoreContext = byte2 & (1U << 6);
	voidReceiverResultRegContainsSelf();
	/* begin ssAllocateCallReg:and:and: */
	ssAllocateRequiredRegMaskupThrough(CallerSavedRegisterMask | (((1U << ReceiverResultReg) | (1U << SendNumArgsReg)) | (1U << ClassReg)), simStackPtr);
	/* end ssAllocateCallReg:and:and: */
	genCreateFullClosurenumArgsnumCopiedignoreContextcontextNumArgslargeinBlock(_compiledBlock, argumentCountOf(_compiledBlock), _numCopied, _ignoreContext, methodOrBlockNumArgs, methodNeedsLargeContext(methodObj), inBlock);
	for (_i = 1; _i <= _numCopied; _i += 1) {
		_reg = ssStorePoptoPreferredReg(1, TempReg);
		genStoreSourceRegslotIndexintoNewObjectInDestReg(_reg, (FullClosureFirstCopiedValueIndex + _numCopied) - _i, ReceiverResultReg);
	}
	if (_receiverIsOnStack) {
		_reg = ssStorePoptoPreferredReg(1, TempReg);
	} else {
		copyToReg(simSelf(), (_reg = TempReg));
	}
	genStoreSourceRegslotIndexintoNewObjectInDestReg(_reg, FullClosureReceiverIndex, ReceiverResultReg);
	ssPushRegister(ReceiverResultReg);
	return 0;
}
/*	Enilopmarts transfer control from C into machine code (backwards 
	trampolines). Enilopmarts transfer control from C into machine code (backwards 
	trampolines). Override to add version for generic and PIC-specific entry 
	with reg args. */
/* StackToRegisterMappingCogit>>#generateEnilopmarts */
static void
generateEnilopmarts(void)
{
	{
		
#    if Debug
		{
			/* begin genEnilopmartFor:forCall:called: */
			realCEEnterCogCodePopReceiverReg = genEnilopmartForandandforCallcalled(ReceiverResultReg, NoReg, NoReg, 0, "realCEEnterCogCodePopReceiverReg");
			/* end genEnilopmartFor:forCall:called: */
			ceEnterCogCodePopReceiverReg = enterCogCodePopReceiver;
			/* begin genEnilopmartFor:forCall:called: */
			realCECallCogCodePopReceiverReg = genEnilopmartForandandforCallcalled(ReceiverResultReg, NoReg, NoReg, 1, "realCEEnterCogCodePopReceiverReg");
			/* end genEnilopmartFor:forCall:called: */
			ceCallCogCodePopReceiverReg = callCogCodePopReceiver;
			/* begin genEnilopmartFor:and:forCall:called: */
			realCECallCogCodePopReceiverAndClassRegs = genEnilopmartForandandforCallcalled(ReceiverResultReg, ClassReg, NoReg, 1, "realCECallCogCodePopReceiverAndClassRegs");
			/* end genEnilopmartFor:and:forCall:called: */
			ceCallCogCodePopReceiverAndClassRegs = callCogCodePopReceiverAndClassRegs;
		}
#    else /* Debug */
		{
			/* begin genEnilopmartFor:forCall:called: */
			ceEnterCogCodePopReceiverReg = genEnilopmartForandandforCallcalled(ReceiverResultReg, NoReg, NoReg, 0, "ceEnterCogCodePopReceiverReg");
			/* end genEnilopmartFor:forCall:called: */
			/* begin genEnilopmartFor:forCall:called: */
			ceCallCogCodePopReceiverReg = genEnilopmartForandandforCallcalled(ReceiverResultReg, NoReg, NoReg, 1, "ceCallCogCodePopReceiverReg");
			/* end genEnilopmartFor:forCall:called: */
			/* begin genEnilopmartFor:and:forCall:called: */
			ceCallCogCodePopReceiverAndClassRegs = genEnilopmartForandandforCallcalled(ReceiverResultReg, ClassReg, NoReg, 1, "ceCallCogCodePopReceiverAndClassRegs");
			/* end genEnilopmartFor:and:forCall:called: */
		}
#    endif /* Debug */
		genPrimReturnEnterCogCodeEnilopmart(0);
		cePrimReturnEnterCogCode = methodZoneBase;
		outputInstructionsForGeneratedRuntimeAt(cePrimReturnEnterCogCode);
		recordGeneratedRunTimeaddress("cePrimReturnEnterCogCode", cePrimReturnEnterCogCode);
		genPrimReturnEnterCogCodeEnilopmart(1);
		cePrimReturnEnterCogCodeProfiling = methodZoneBase;
		outputInstructionsForGeneratedRuntimeAt(cePrimReturnEnterCogCodeProfiling);
		recordGeneratedRunTimeaddress("cePrimReturnEnterCogCodeProfiling", cePrimReturnEnterCogCodeProfiling);
	}
	
#  if Debug
	{
		/* begin genEnilopmartFor:and:forCall:called: */
		realCECallCogCodePopReceiverArg0Regs = genEnilopmartForandandforCallcalled(ReceiverResultReg, Arg0Reg, NoReg, 1, "realCECallCogCodePopReceiverArg0Regs");
		/* end genEnilopmartFor:and:forCall:called: */
		ceCallCogCodePopReceiverArg0Regs = callCogCodePopReceiverArg0Regs;
		realCECallCogCodePopReceiverArg1Arg0Regs = genEnilopmartForandandforCallcalled(ReceiverResultReg, Arg0Reg, Arg1Reg, 1, "realCECallCogCodePopReceiverArg1Arg0Regs");
		ceCallCogCodePopReceiverArg1Arg0Regs = callCogCodePopReceiverArg1Arg0Regs;
	}
#  else /* Debug */
	{
		/* begin genEnilopmartFor:and:forCall:called: */
		ceCallCogCodePopReceiverArg0Regs = genEnilopmartForandandforCallcalled(ReceiverResultReg, Arg0Reg, NoReg, 1, "ceCallCogCodePopReceiverArg0Regs");
		/* end genEnilopmartFor:and:forCall:called: */
		ceCallCogCodePopReceiverArg1Arg0Regs = genEnilopmartForandandforCallcalled(ReceiverResultReg, Arg0Reg, Arg1Reg, 1, "ceCallCogCodePopReceiverArg1Arg0Regs");
	}
#  endif /* Debug */
	ceCall0ArgsPIC = genCallPICEnilopmartNumArgs(0);
	{
		ceCall1ArgsPIC = genCallPICEnilopmartNumArgs(1);
		{
			ceCall2ArgsPIC = genCallPICEnilopmartNumArgs(2);
			assert((numRegArgs()) == 2);
		}
	}
}
/*	Size pc-dependent instructions and assign eventual addresses to all 
	instructions. Answer the size of the code. 
	Compute forward branches based on virtual address (abstract code starts at 
	0), assuming that any branches branched over are long. 
	Compute backward branches based on actual address. 
	Reuse the fixups array to record the pc-dependent instructions that need 
	to have 
	their code generation postponed until after the others. 
	 
	Override to andd handling for null branches (branches to the immediately 
	following instruction) occasioned by StackToRegisterMapping's following of 
	jumps.  */
/* StackToRegisterMappingCogit>>#generateInstructionsAt: */
static sqInt NoDbgRegParms
generateInstructionsAt(sqInt _eventualAbsoluteAddress)
{
	sqInt _absoluteAddress;
	AbstractInstruction *_abstractInstruction;
	BytecodeFixup *_fixup;
	sqInt _i;
	sqInt _j;
	int _pcDependentIndex;

	_absoluteAddress = _eventualAbsoluteAddress;
	_pcDependentIndex = 0;
	for (_i = 0; _i < opcodeIndex; _i += 1) {
		_abstractInstruction = abstractInstructionAt(_i);
		if (isPCDependent(_abstractInstruction)) {
			sizePCDependentInstructionAt(_abstractInstruction, _absoluteAddress);
			if ((isJump(_abstractInstruction)) && ((((_i + 1) < opcodeIndex) && (((AbstractInstruction *) ((_abstractInstruction->operands)[0]) ) == (abstractInstructionAt(_i + 1)))) || (((_i + 2) < opcodeIndex) && ((((AbstractInstruction *) ((_abstractInstruction->operands)[0]) ) == (abstractInstructionAt(_i + 2))) && ((((abstractInstructionAt(_i + 1))->opcode)) == Nop))))) {
				{
					(_abstractInstruction->opcode = Nop);
					concretizeAt(_abstractInstruction, _absoluteAddress);
				}
			} else {
				_fixup = fixupAtIndex(_pcDependentIndex);
				_pcDependentIndex += 1;
				(_fixup->instructionIndex = _i);
			}
			_absoluteAddress += (_abstractInstruction->machineCodeSize);
		} else {
			_absoluteAddress = concretizeAt(_abstractInstruction, _absoluteAddress);
		}
	}
	for (_j = 0; _j < _pcDependentIndex; _j += 1) {
		_fixup = fixupAtIndex(_j);
		_abstractInstruction = abstractInstructionAt((_fixup->instructionIndex));
		concretizeAt(_abstractInstruction, (_abstractInstruction->address));
	}
	return _absoluteAddress - _eventualAbsoluteAddress;
}
/*	Generate the run-time entries for the various method and PIC entry misses 
	and aborts. 
	Read the class-side method trampolines for documentation on the various 
	trampolines  */
/* StackToRegisterMappingCogit>>#generateMissAbortTrampolines */
static void
generateMissAbortTrampolines(void)
{
	sqInt _iLimit;
	sqInt _numArgs;

	for (_numArgs = 0, _iLimit = 2 + 1; _numArgs <= _iLimit; _numArgs += 1) {
		methodAbortTrampolines[_numArgs] = genMethodAbortTrampolineFor(_numArgs);
	}
	for (_numArgs = 0, _iLimit = 2 + 1; _numArgs <= _iLimit; _numArgs += 1) {
		picAbortTrampolines[_numArgs] = genPICAbortTrampolineFor(_numArgs);
	}
	for (_numArgs = 0, _iLimit = 2 + 1; _numArgs <= _iLimit; _numArgs += 1) {
		picMissTrampolines[_numArgs] = genPICMissTrampolineFor(_numArgs);
	}
	ceReapAndResetErrorCodeTrampoline = genTrampolineForcalledarg(ceReapAndResetErrorCodeFor, "ceReapAndResetErrorCodeTrampoline", ClassReg);
}
/*	Override to generate code to push the register arg(s) for <= numRegArg 
	arity sends. */
/* StackToRegisterMappingCogit>>#generateSendTrampolines */
static void
generateSendTrampolines(void)
{
	sqInt _numArgs;

	for (_numArgs = 0; _numArgs < NumSendTrampolines; _numArgs += 1) {
		ordinarySendTrampolines[_numArgs] = genSendTrampolineFornumArgscalledargargargarg(ceSendsupertonumArgs, _numArgs, trampolineNamenumArgs("ceSend", _numArgs), ClassReg, trampolineArgConstant(0), ReceiverResultReg, ((_numArgs <= (NumSendTrampolines - 2))
			 ? (/* begin trampolineArgConstant: */ assert(_numArgs >= 0), -2 - _numArgs /* end trampolineArgConstant: */)
			 : SendNumArgsReg));
	}
	{
		for (_numArgs = 0; _numArgs < NumSendTrampolines; _numArgs += 1) {
			generateSuperSendTrampolineTonamednumArgsin(ceSendabovetonumArgs, "ceDirectedSuperSend", _numArgs, directedSuperSendTrampolines);
			generateSuperSendTrampolineTonamednumArgsin(ceSendaboveClassBindingtonumArgs, "ceDirectedSuperBindingSend", _numArgs, directedSuperBindingSendTrampolines);
		}
	}
	for (_numArgs = 0; _numArgs < NumSendTrampolines; _numArgs += 1) {
		superSendTrampolines[_numArgs] = genSendTrampolineFornumArgscalledargargargarg(ceSendsupertonumArgs, _numArgs, trampolineNamenumArgs("ceSuperSend", _numArgs), ClassReg, trampolineArgConstant(1), ReceiverResultReg, ((_numArgs <= (NumSendTrampolines - 2))
			 ? (/* begin trampolineArgConstant: */ assert(_numArgs >= 0), -2 - _numArgs /* end trampolineArgConstant: */)
			 : SendNumArgsReg));
	}
	firstSend = ordinarySendTrampolines[0];
	lastSend = superSendTrampolines[NumSendTrampolines - 1];
}
/* StackToRegisterMappingCogit>>#generateSuperSendTrampolineTo:named:numArgs:in: */
static sqInt NoDbgRegParms
generateSuperSendTrampolineTonamednumArgsin(sqInt _function, sqInt _name, sqInt _numArgs, sqInt *_table)
{
	sqInt _trampoline;

	_trampoline = genSendTrampolineFornumArgscalledargargargarg(_function, _numArgs, trampolineNamenumArgs(_name, _numArgs), ClassReg, TempReg, ReceiverResultReg, ((_numArgs <= (NumSendTrampolines - 2))
		 ? (/* begin trampolineArgConstant: */ assert(_numArgs >= 0), -2 - _numArgs /* end trampolineArgConstant: */)
		 : SendNumArgsReg));
	_table[_numArgs] = _trampoline;
	return _trampoline;
}
/*	Generate trampolines for tracing. In the simulator we can save a lot of 
	time and avoid noise instructions in the lastNInstructions log by 
	short-cutting these 
	trampolines, but we need them in the real vm. */
/* StackToRegisterMappingCogit>>#generateTracingTrampolines */
static void
generateTracingTrampolines(void)
{
	sqInt ceTraceBlockActivationTrampoline;

	ceTraceLinkedSendTrampoline = genTrampolineForcalledargregsToSave(ceTraceLinkedSend, "ceTraceLinkedSendTrampoline", ReceiverResultReg, CallerSavedRegisterMask);
	ceTraceBlockActivationTrampoline = genTrampolineForcalledregsToSave(ceTraceBlockActivation, "ceTraceBlockActivationTrampoline", CallerSavedRegisterMask);
	ceTraceStoreTrampoline = genTrampolineForcalledargargregsToSave(ceTraceStoreOfinto, "ceTraceStoreTrampoline", TempReg, ReceiverResultReg, CallerSavedRegisterMask);
}
/* StackToRegisterMappingCogit>>#genForwardersInlinedIdenticalOrNotIf: */
static sqInt NoDbgRegParms
genForwardersInlinedIdenticalOrNotIf(sqInt _orNot)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	int _argIsConstant;
	sqInt _argReg;
	sqInt _argReg2;
	sqInt _argumentConstant;
	BytecodeDescriptor *_branchDescriptor;
	BytecodeDescriptor *_branchDescriptor2;
	BytecodeFixup * _fixup;
	void *_jumpTarget;
	void *_jumpTarget2;
	AbstractInstruction *_label;
	int _nExts;
	sqInt _nextPC;
	sqInt _nextPC2;
	sqInt _postBranchPC;
	sqInt _postBranchPC2;
	BytecodeDescriptor *_primDescriptor;
	int _rcvrIsConstant;
	sqInt _rcvrReg;
	sqInt _rcvrReg2;
	sqInt _receiverConstant;
	sqInt _reg;
	sqInt _rNext2;
	sqInt _rTop2;
	sqInt _targetBytecodePC;
	sqInt _targetBytecodePC2;
	sqInt _topRegistersMask;
	int _unforwardArg;
	int _unforwardRcvr;

	/* begin extractMaybeBranchDescriptorInto: */
	_primDescriptor = generatorAt(byte0);
	_nextPC2 = bytecodePC + ((_primDescriptor->numBytes));
	_nExts = 0;
	while (1) {
		while (1) {
			/* begin generatorForPC: */
			_branchDescriptor2 = generatorAt(fetchByteofObject(_nextPC2, methodObj));
			/* end generatorForPC: */
			if (!((_branchDescriptor2->isExtension))) 
				break;
			_nExts += 1;
			_nextPC2 += (_branchDescriptor2->numBytes);
		}
		/* begin isUnconditionalBranch */
		/* end isUnconditionalBranch */
		if (!((isBranch(_branchDescriptor2)) && (!(((_branchDescriptor2->isBranchTrue)) || ((_branchDescriptor2->isBranchFalse)))))) 
			break;
		_nextPC2 = eventualTargetOf((_nextPC2 + ((_branchDescriptor2->numBytes))) + (((_branchDescriptor2->spanFunction))(_branchDescriptor2, _nextPC2, _nExts, methodObj)));
	}
	_targetBytecodePC2 = (_postBranchPC2 = 0);
	if (((_branchDescriptor2->isBranchTrue)) || ((_branchDescriptor2->isBranchFalse))) {
		_targetBytecodePC2 = eventualTargetOf((_nextPC2 + ((_branchDescriptor2->numBytes))) + (((_branchDescriptor2->spanFunction))(_branchDescriptor2, _nextPC2, _nExts, methodObj)));
		_postBranchPC2 = eventualTargetOf(_nextPC2 + ((_branchDescriptor2->numBytes)));
	} else {
		_nextPC2 = bytecodePC + ((_primDescriptor->numBytes));
	}
	{
		_branchDescriptor = _branchDescriptor2;
		_nextPC = _nextPC2;
		_postBranchPC = _postBranchPC2;
		_targetBytecodePC = _targetBytecodePC2;
	}
	/* end extractMaybeBranchDescriptorInto: */
	_unforwardRcvr = !(isUnannotatableConstant(ssValue(1)));
	_unforwardArg = !(isUnannotatableConstant(ssTop()));
	/* begin allocateEqualsEqualsRegistersArgNeedsReg:rcvrNeedsReg:into: */
	assert(_unforwardArg || _unforwardRcvr);
	_argReg2 = (_rcvrReg2 = NoReg);
	if (_unforwardArg) {
		if (_unforwardRcvr) {
			/* begin allocateRegForStackTopTwoEntriesInto: */
			_topRegistersMask = 0;
			_rTop2 = (_rNext2 = NoReg);
			if ((registerOrNone(ssTop())) != NoReg) {
				_rTop2 = registerOrNone(ssTop());
			}
			if ((registerOrNone(ssValue(1))) != NoReg) {
				/* begin registerMaskFor: */
				_reg = (_rNext2 = registerOrNone(ssValue(1)));
				_topRegistersMask = 1ULL << _reg;
				/* end registerMaskFor: */
			}
			if (_rTop2 == NoReg) {
				_rTop2 = allocateRegNotConflictingWith(_topRegistersMask);
			}
			if (_rNext2 == NoReg) {
				_rNext2 = allocateRegNotConflictingWith(1ULL << _rTop2);
			}
			assert(!((_rTop2 == NoReg) || (_rNext2 == NoReg)));
			{
				_argReg2 = _rTop2;
				_rcvrReg2 = _rNext2;
			}
			/* end allocateRegForStackTopTwoEntriesInto: */
			copyToReg(ssTop(), _argReg2);
			copyToReg(ssValue(1), _rcvrReg2);
		} else {
			/* begin allocateRegForStackEntryAt: */
			_argReg2 = allocateRegForStackEntryAtnotConflictingWith(0, 0);
			/* end allocateRegForStackEntryAt: */
			copyToReg(ssTop(), _argReg2);
		}
	} else {
		assert(_unforwardRcvr);
		assert(!(((ssTop())->spilled)));
		/* begin allocateRegForStackEntryAt: */
		_rcvrReg2 = allocateRegForStackEntryAtnotConflictingWith(1, 0);
		/* end allocateRegForStackEntryAt: */
		copyToReg(ssValue(1), _rcvrReg2);
	}
	assert(!(_unforwardArg && (_argReg2 == NoReg)));
	assert(!(_unforwardRcvr && (_rcvrReg2 == NoReg)));
	{
		_rcvrReg = _rcvrReg2;
		_argReg = _argReg2;
	}
	/* end allocateEqualsEqualsRegistersArgNeedsReg:rcvrNeedsReg:into: */
	if (!(((_branchDescriptor->isBranchTrue)) || ((_branchDescriptor->isBranchFalse)))) {
		return genIdenticalNoBranchArgIsConstantrcvrIsConstantargRegrcvrRegorNotIf(!_unforwardArg, !_unforwardRcvr, _argReg, _rcvrReg, _orNot);
	}
	ssFlushStackExceptTop(2);
	_argIsConstant = !_unforwardArg;
	_rcvrIsConstant = !_unforwardRcvr;
	_receiverConstant = ((_rcvrIsConstant)
		 ? ((ssValue(1))->constant)
		 : 0);
	_argumentConstant = ((_argIsConstant)
		 ? ((ssTop())->constant)
		 : 0);
	ssPop(2);
	/* begin Label */
	_label = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
	/* end Label */
	assert((_argReg != NoReg) || (_rcvrReg != NoReg));
	if (_argIsConstant) {
		/* begin genCmpConstant:R: */
		if (shouldAnnotateObjectReference(_argumentConstant)) {
			annotateobjRef(checkLiteralforInstruction(_argumentConstant, genoperandoperand(CmpCwR, _argumentConstant, _rcvrReg)), _argumentConstant);
		} else {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperand(CmpCqR, _argumentConstant, _rcvrReg);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(_argumentConstant));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		/* end genCmpConstant:R: */
	} else {
		if (_rcvrIsConstant) {
			/* begin genCmpConstant:R: */
			if (shouldAnnotateObjectReference(_receiverConstant)) {
				annotateobjRef(checkLiteralforInstruction(_receiverConstant, genoperandoperand(CmpCwR, _receiverConstant, _argReg)), _receiverConstant);
			} else {
				/* begin checkQuickConstant:forInstruction: */
				_anInstruction2 = genoperandoperand(CmpCqR, _receiverConstant, _argReg);
				if (usesOutOfLineLiteral(_anInstruction2)) {
					(_anInstruction2->dependent = locateLiteral(_receiverConstant));
				}
				/* end checkQuickConstant:forInstruction: */
			}
			/* end genCmpConstant:R: */
		} else {
			/* begin CmpR:R: */
			genoperandoperand(CmpRR, _argReg, _rcvrReg);
			/* end CmpR:R: */
		}
	}
	if ((((fixupAt(_nextPC))->targetInstruction)) == 0) {
		deadCode = 1;
		ensureFixupAt(_targetBytecodePC);
		ensureFixupAt(_postBranchPC);
	} else {
		assert(!deadCode);
	}
	assert(_unforwardArg || _unforwardRcvr);
	if (_orNot == ((_branchDescriptor->isBranchTrue))) {
		_fixup = ensureNonMergeFixupAt(_targetBytecodePC);
		/* begin JumpZero: */
		_jumpTarget2 = ensureNonMergeFixupAt(_postBranchPC);
		genConditionalBranchoperand(JumpZero, ((sqInt) _jumpTarget2 ));
		/* end JumpZero: */
	} else {
		_fixup = ensureNonMergeFixupAt(_postBranchPC);
		/* begin JumpZero: */
		_jumpTarget = ensureNonMergeFixupAt(_targetBytecodePC);
		genConditionalBranchoperand(JumpZero, ((sqInt) _jumpTarget ));
		/* end JumpZero: */
	}
	if (_unforwardArg && _unforwardRcvr) {
		/* begin genEnsureOopInRegNotForwarded:scratchReg:jumpBackTo: */
		genEnsureOopInRegNotForwardedscratchRegifForwarderifNotForwarder(_argReg, TempReg, _label, 0);
		/* end genEnsureOopInRegNotForwarded:scratchReg:jumpBackTo: */
	}
	genEnsureOopInRegNotForwardedscratchRegifForwarderifNotForwarder(((_unforwardRcvr)
		 ? _rcvrReg
		 : _argReg), TempReg, _label, _fixup);
	if (!deadCode) {
		ssPushConstant(trueObject());
	}
	return 0;
}
/*	Generates the machine code for #== in the case where the instruction is 
	not followed by a branch */
/* StackToRegisterMappingCogit>>#genIdenticalNoBranchArgIsConstant:rcvrIsConstant:argReg:rcvrReg:orNotIf: */
static sqInt NoDbgRegParms
genIdenticalNoBranchArgIsConstantrcvrIsConstantargRegrcvrRegorNotIf(sqInt _argIsConstant, sqInt _rcvrIsConstant, sqInt _argReg, sqInt _rcvrRegOrNone, sqInt _orNot)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	CogSimStackEntry * _argumentStackSlot;
	sqInt _constant;
	sqInt _constant2;
	sqInt _constant3;
	sqInt _constant4;
	sqInt _constant5;
	sqInt _constant6;
	AbstractInstruction *_jumpEqual;
	AbstractInstruction *_jumpNotEqual;
	AbstractInstruction *_label;
	CogSimStackEntry * _receiverStackSlot;
	sqInt _resultReg;

	_receiverStackSlot = ssValue(1);
	_argumentStackSlot = ssTop();
	ssPop(2);
	/* begin Label */
	_label = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
	/* end Label */
	assert((_argReg != NoReg) || (_rcvrRegOrNone != NoReg));
	if (_argIsConstant) {
		/* begin genCmpConstant:R: */
		_constant = (_argumentStackSlot->constant);
		if (shouldAnnotateObjectReference(_constant)) {
			annotateobjRef(checkLiteralforInstruction(_constant, genoperandoperand(CmpCwR, _constant, _rcvrRegOrNone)), _constant);
		} else {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction = genoperandoperand(CmpCqR, _constant, _rcvrRegOrNone);
			if (usesOutOfLineLiteral(_anInstruction)) {
				(_anInstruction->dependent = locateLiteral(_constant));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		/* end genCmpConstant:R: */
	} else {
		if (_rcvrIsConstant) {
			/* begin genCmpConstant:R: */
			_constant2 = (_receiverStackSlot->constant);
			if (shouldAnnotateObjectReference(_constant2)) {
				annotateobjRef(checkLiteralforInstruction(_constant2, genoperandoperand(CmpCwR, _constant2, _argReg)), _constant2);
			} else {
				/* begin checkQuickConstant:forInstruction: */
				_anInstruction2 = genoperandoperand(CmpCqR, _constant2, _argReg);
				if (usesOutOfLineLiteral(_anInstruction2)) {
					(_anInstruction2->dependent = locateLiteral(_constant2));
				}
				/* end checkQuickConstant:forInstruction: */
			}
			/* end genCmpConstant:R: */
		} else {
			/* begin CmpR:R: */
			genoperandoperand(CmpRR, _argReg, _rcvrRegOrNone);
			/* end CmpR:R: */
		}
	}
	_resultReg = ((_rcvrRegOrNone == NoReg)
		 ? _argReg
		 : _rcvrRegOrNone);
	/* begin JumpZero: */
	_jumpEqual = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	if (!_argIsConstant) {
		/* begin genEnsureOopInRegNotForwarded:scratchReg:jumpBackTo: */
		genEnsureOopInRegNotForwardedscratchRegifForwarderifNotForwarder(_argReg, TempReg, _label, 0);
		/* end genEnsureOopInRegNotForwarded:scratchReg:jumpBackTo: */
	}
	if (!_rcvrIsConstant) {
		/* begin genEnsureOopInRegNotForwarded:scratchReg:jumpBackTo: */
		genEnsureOopInRegNotForwardedscratchRegifForwarderifNotForwarder(_rcvrRegOrNone, TempReg, _label, 0);
		/* end genEnsureOopInRegNotForwarded:scratchReg:jumpBackTo: */
	}
	if (_orNot) {
		/* begin genMoveTrueR: */
		/* begin genMoveConstant:R: */
		_constant4 = trueObject();
		if (shouldAnnotateObjectReference(_constant4)) {
			annotateobjRef(gMoveCwR(_constant4, _resultReg), _constant4);
		} else {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction4 = genoperandoperand(MoveCqR, _constant4, _resultReg);
			if (usesOutOfLineLiteral(_anInstruction4)) {
				(_anInstruction4->dependent = locateLiteral(_constant4));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		/* end genMoveConstant:R: */
		/* end genMoveTrueR: */
	} else {
		/* begin genMoveFalseR: */
		/* begin genMoveConstant:R: */
		_constant3 = falseObject();
		if (shouldAnnotateObjectReference(_constant3)) {
			annotateobjRef(gMoveCwR(_constant3, _resultReg), _constant3);
		} else {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction3 = genoperandoperand(MoveCqR, _constant3, _resultReg);
			if (usesOutOfLineLiteral(_anInstruction3)) {
				(_anInstruction3->dependent = locateLiteral(_constant3));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		/* end genMoveConstant:R: */
		/* end genMoveFalseR: */
	}
	/* begin Jump: */
	_jumpNotEqual = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jumpEqual, ((_orNot)
		 ? (/* begin genMoveFalseR: */ /* begin genMoveConstant:R: */ (_constant6 = falseObject()), ((shouldAnnotateObjectReference(_constant6))
			 ? annotateobjRef(gMoveCwR(_constant6, _resultReg), _constant6)
			 : (/* begin checkQuickConstant:forInstruction: */ (_anInstruction6 = genoperandoperand(MoveCqR, _constant6, _resultReg)), ((usesOutOfLineLiteral(_anInstruction6))
				 ? (_anInstruction6->dependent = locateLiteral(_constant6))
				 : 0), _anInstruction6 /* end checkQuickConstant:forInstruction: */)) /* end genMoveConstant:R: */ /* end genMoveFalseR: */)
		 : (/* begin genMoveTrueR: */ /* begin genMoveConstant:R: */ (_constant5 = trueObject()), ((shouldAnnotateObjectReference(_constant5))
			 ? annotateobjRef(gMoveCwR(_constant5, _resultReg), _constant5)
			 : (/* begin checkQuickConstant:forInstruction: */ (_anInstruction5 = genoperandoperand(MoveCqR, _constant5, _resultReg)), ((usesOutOfLineLiteral(_anInstruction5))
				 ? (_anInstruction5->dependent = locateLiteral(_constant5))
				 : 0), _anInstruction5 /* end checkQuickConstant:forInstruction: */)) /* end genMoveConstant:R: */ /* end genMoveTrueR: */)));
	jmpTarget(_jumpNotEqual, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	ssPushRegister(_resultReg);
	return 0;
}
/*	Decompose code generation for #== into a common constant-folding version, 
	followed by a double dispatch throguh the objectRepresentation to a 
	version that doesn't deal with forwarders and a version that does. */
/* StackToRegisterMappingCogit>>#genInlinedIdenticalOrNotIf: */
static sqInt NoDbgRegParms
genInlinedIdenticalOrNotIf(sqInt _orNot)
{
	BytecodeDescriptor *_primDescriptor;
	sqInt _result;

	_primDescriptor = generatorAt(byte0);
	if ((isUnannotatableConstant(ssTop())) && (isUnannotatableConstant(ssValue(1)))) {
		assert(!((_primDescriptor->isMapped)));
		_result = ((((_orNot)
			 ? (((ssTop())->constant)) != (((ssValue(1))->constant))
			 : (((ssTop())->constant)) == (((ssValue(1))->constant))))
			 ? trueObject()
			 : falseObject());
		ssPop(2);
		return ssPushConstant(_result);
	}
	/* begin genInlinedIdenticalOrNotIfGuts: */
	return genForwardersInlinedIdenticalOrNotIf(_orNot);
	/* end genInlinedIdenticalOrNotIfGuts: */
}
/* StackToRegisterMappingCogit>>#genJumpBackTo: */
static sqInt NoDbgRegParms
genJumpBackTo(sqInt _targetBytecodePC)
{
	AbstractInstruction *_abstractInstruction;
	AbstractInstruction *_abstractInstruction2;
	sqInt _address;
	void *_jumpTarget;
	void *_jumpTarget2;

	ssFlushStack();
	deadCode = 1;
	{
		/* begin MoveAw:R: */
		_address = stackLimitAddress();
		/* begin gen:literal:operand: */
		checkLiteralforInstruction(_address, genoperandoperand(MoveAwR, _address, TempReg));
		/* end gen:literal:operand: */
		/* end MoveAw:R: */
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, TempReg, SPReg);
		/* end CmpR:R: */
		/* begin JumpAboveOrEqual: */
		/* begin fixupAt: */
		_jumpTarget = fixupAtIndex(_targetBytecodePC - initialPC);
		/* end fixupAt: */
		genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt) _jumpTarget ));
		/* end JumpAboveOrEqual: */
		/* begin CallRT: */
		/* begin annotateCall: */
		_abstractInstruction = genoperand(Call, ceCheckForInterruptTrampoline);
		(_abstractInstruction->annotation = IsRelativeCall);
		/* end annotateCall: */
		/* end CallRT: */
		/* begin annotateBytecode: */
		_abstractInstruction2 = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
		(_abstractInstruction2->annotation = HasBytecodePC);
		/* end annotateBytecode: */
		/* begin Jump: */
		/* begin fixupAt: */
		_jumpTarget2 = fixupAtIndex(_targetBytecodePC - initialPC);
		/* end fixupAt: */
		genoperand(Jump, ((sqInt) _jumpTarget2 ));
		/* end Jump: */
		return 0;
	}
	return 0;
}
/* StackToRegisterMappingCogit>>#genJumpIf:to: */
static sqInt NoDbgRegParms
genJumpIfto(sqInt _boolean, sqInt _targetBytecodePC)
{
	AbstractInstruction *_abstractInstruction;
	AbstractInstruction *_abstractInstruction2;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	CogSimStackEntry *_desc;
	sqInt _eventualTarget;
	BytecodeFixup *_fixup;
	void *_jumpTarget;
	AbstractInstruction *_ok;
	sqInt _quickConstant;

	_eventualTarget = eventualTargetOf(_targetBytecodePC);
	ssFlushStackExceptTop(1);
	_desc = ssTop();
	if ((((_desc->type)) == SSConstant) && ((((_desc->constant)) == (trueObject())) || (((_desc->constant)) == (falseObject())))) {
		ssPop(1);
		_fixup = ensureFixupAt(_eventualTarget);
		/* begin annotateBytecode: */
		_abstractInstruction = ((AbstractInstruction *) (((((_desc->constant)) == _boolean)
			 ? (/* begin Jump: */ genoperand(Jump, ((sqInt) _fixup )) /* end Jump: */)
			 : ((prevInstIsPCAnnotated())
				 ? (/* begin Nop */ gen(Nop) /* end Nop */)
				 : (/* begin Label */ genoperandoperand(Label, (labelCounter += 1), bytecodePC) /* end Label */)))) );
		(_abstractInstruction->annotation = HasBytecodePC);
		/* end annotateBytecode: */
		extA = 0;
		return 0;
	}
	ssPopTopToReg(TempReg);
	assert((objectAfter(falseObject())) == (trueObject()));
	/* begin genSubConstant:R: */
	if (shouldAnnotateObjectReference(_boolean)) {
		annotateobjRef(gSubCwR(_boolean, TempReg), TempReg);
	} else {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(SubCqR, _boolean, TempReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_boolean));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* end genSubConstant:R: */
	/* begin JumpZero: */
	_jumpTarget = ensureFixupAt(_eventualTarget);
	genConditionalBranchoperand(JumpZero, ((sqInt) _jumpTarget ));
	/* end JumpZero: */
	if (extA & 1) {
		extA = 0;
		/* begin annotateBytecode: */
		_abstractInstruction2 = lastOpcode();
		(_abstractInstruction2->annotation = HasBytecodePC);
		/* end annotateBytecode: */
		return 0;
	}
	extA = 0;
	/* begin CmpCq:R: */
	_quickConstant = ((_boolean == (falseObject()))
		 ? (trueObject()) - (falseObject())
		 : (falseObject()) - (trueObject()));
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_quickConstant));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end CmpCq:R: */
	/* begin JumpZero: */
	_ok = genConditionalBranchoperand(JumpZero, ((sqInt) 0 ));
	/* end JumpZero: */
	genCallMustBeBooleanFor(_boolean);
	jmpTarget(_ok, annotateBytecode(genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
	return 0;
}
/* StackToRegisterMappingCogit>>#genJumpTo: */
static sqInt NoDbgRegParms
genJumpTo(sqInt _targetBytecodePC)
{
	sqInt _eventualTarget;
	BytecodeFixup * _fixup;
	BytecodeDescriptor * _generator;

	_eventualTarget = eventualTargetOf(_targetBytecodePC);
	if ((_eventualTarget > bytecodePC) && (((simStackPtr >= methodOrBlockNumArgs) && (stackEntryIsBoolean(ssTop()))) && (((((_generator = generatorForPC(_eventualTarget)))->isBranchTrue)) || ((((_generator = generatorForPC(_eventualTarget)))->isBranchFalse))))) {
		_eventualTarget = (_eventualTarget + ((_generator->numBytes))) + (((((_generator->isBranchTrue)) == ((((ssTop())->constant)) == (trueObject())))
			 ? (/* begin spanFor:at:exts:in: */ ((_generator->spanFunction))(_generator, _eventualTarget, 0, methodObj) /* end spanFor:at:exts:in: */)
			 : 0));
		ssFlushStackExceptTop(1);
		_fixup = ensureFixupAtwithStackPointer(_eventualTarget, simStackPtr - 1);
	} else {
		ssFlushStack();
		_fixup = ensureFixupAt(_eventualTarget);
	}
	deadCode = 1;
	/* begin Jump: */
	genoperand(Jump, ((sqInt) _fixup ));
	/* end Jump: */
	return 0;
}
/* StackToRegisterMappingCogit>>#genMappedInlinePrimitive: */
static sqInt NoDbgRegParms
genMappedInlinePrimitive(sqInt _primIndex)
{
	AbstractInstruction *_abstractInstruction;
	sqInt _result;

	
#  if FEATURE_JIT_SIMD
	{
		switch (_primIndex) {
			case 0:
			{
				_result = genAddFloat64Vector();
			}
			break;
			case 1:
			{
				_result = genPushFloat64ArrayToRegister();
			}
			break;
			case 2:
			{
				_result = genStoreFloat64RegisterIntoArray();
			}
			break;
			case 3:
			{
				_result = genAddFloat32Vector();
			}
			break;
			case 4:
			{
				_result = genPushFloat32ArrayToRegister();
			}
			break;
			case 5:
			{
				_result = genStoreFloat32RegisterIntoArray();
			}
			break;
			case 6:
			{
				_result = genSubFloat64Vector();
			}
			break;
			default:
			{
				_result = EncounteredUnknownBytecode;
			}
		}
		/* begin annotateBytecode: */
		_abstractInstruction = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
		(_abstractInstruction->annotation = HasBytecodePC);
		/* end annotateBytecode: */
		return _result;
	}
#  else /* FEATURE_JIT_SIMD */
	{
		error("VM built without SIMD support");
	}
#  endif /* FEATURE_JIT_SIMD */
	return 0;
}
/* StackToRegisterMappingCogit>>#genMarshalledSend:numArgs:sendTable: */
static sqInt NoDbgRegParms
genMarshalledSendnumArgssendTable(sqInt _selectorIndex, sqInt _numArgs, sqInt *_sendTable)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	sqInt _annotation;

	assert(needsFrame);
	/* begin annotationForSendTable: */
	if (_sendTable == ordinarySendTrampolines) {
		_annotation = IsSendCall;
		goto l3;
	}
	{
		if (_sendTable == directedSuperSendTrampolines) {
			_annotation = IsDirectedSuperSend;
			goto l3;
		}
		if (_sendTable == directedSuperBindingSendTrampolines) {
			_annotation = IsDirectedSuperBindingSend;
			goto l3;
		}
	}
	assert(_sendTable == superSendTrampolines);
	_annotation = IsSuperSend;
	l3:
	;
	/* end annotationForSendTable: */
	if ((_annotation == IsSuperSend) || ((_annotation >= IsDirectedSuperSend) && (_annotation <= IsDirectedSuperBindingSend))) {
		genEnsureOopInRegNotForwardedscratchReg(ReceiverResultReg, TempReg);
	}
	if (_numArgs >= (NumSendTrampolines - 1)) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, _numArgs, SendNumArgsReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_numArgs));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	if ((_annotation >= IsDirectedSuperSend) && (_annotation <= IsDirectedSuperBindingSend)) {
		/* begin genMoveConstant:R: */
		if (shouldAnnotateObjectReference(tempOop)) {
			annotateobjRef(gMoveCwR(tempOop, TempReg), tempOop);
		} else {
			/* begin checkQuickConstant:forInstruction: */
			_anInstruction2 = genoperandoperand(MoveCqR, tempOop, TempReg);
			if (usesOutOfLineLiteral(_anInstruction2)) {
				(_anInstruction2->dependent = locateLiteral(tempOop));
			}
			/* end checkQuickConstant:forInstruction: */
		}
		/* end genMoveConstant:R: */
	}
	genLoadInlineCacheWithSelector(_selectorIndex);
	((genoperand(Call, _sendTable[((_numArgs < (NumSendTrampolines - 1)) ? _numArgs : NumSendTrampolines - 1)]))->annotation = _annotation);
	/* begin voidReceiverOptStatus */
	((simSelf())->liveRegister = NoReg);
	/* end voidReceiverOptStatus */
	return ssPushRegister(ReceiverResultReg);
}
/*	Generate the abort for a method. This abort performs either a call of 
	ceSICMiss: to handle a single-in-line cache miss or a call of 
	ceStackOverflow: to handle a 
	stack overflow. It distinguishes the two by testing ResultReceiverReg. If 
	the register is zero then this is a stack-overflow because a) the receiver 
	has already 
	been pushed and so can be set to zero before calling the abort, and b) the 
	receiver must always contain an object (and hence be non-zero) on SIC 
	miss.  */
/* StackToRegisterMappingCogit>>#genMethodAbortTrampolineFor: */
static sqInt NoDbgRegParms
genMethodAbortTrampolineFor(sqInt _numArgs)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_jumpSICMiss;

	zeroOpcodeIndex();
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(CmpCqR, 0, ReceiverResultReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(0));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin JumpNonZero: */
	_jumpSICMiss = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
	/* end JumpNonZero: */
	{
		/* begin MoveR:Mw:r: */
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveRMwr, LinkReg, 0, SPReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(0));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveR:Mw:r: */
	}
	compileTrampolineFornumArgsargargargargregsToSavepushLinkRegresultReg(ceStackOverflow, 1, SendNumArgsReg, null, null, null, 0, 0, NoReg);
	jmpTarget(_jumpSICMiss, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	genPushRegisterArgsForAbortMissNumArgs(backEnd, _numArgs);
	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(ceSICMiss, trampolineNamenumRegArgs("ceMethodAbort", _numArgs), 1, ReceiverResultReg, null, null, null, 0, 0, NoReg, 1);
}
/*	Generate the abort for a PIC. This abort performs either a call of 
	ceInterpretMethodFromPIC:receiver: to handle invoking an uncogged 
	target or a call of ceMNUFromPICMNUMethod:receiver: to handle an 
	MNU dispatch in a closed PIC. It distinguishes the two by testing 
	ClassReg. If the register is zero then this is an MNU. */
/* StackToRegisterMappingCogit>>#genPICAbortTrampolineFor: */
static sqInt NoDbgRegParms
genPICAbortTrampolineFor(sqInt _numArgs)
{
	zeroOpcodeIndex();
	genPushRegisterArgsForAbortMissNumArgs(backEnd, _numArgs);
	return genInnerPICAbortTrampoline(trampolineNamenumRegArgs("cePICAbort", _numArgs));
}
/* StackToRegisterMappingCogit>>#genPICMissTrampolineFor: */
static sqInt NoDbgRegParms
genPICMissTrampolineFor(sqInt _numArgs)
{
	sqInt _startAddress;

	_startAddress = methodZoneBase;
	zeroOpcodeIndex();
	genPushRegisterArgsForNumArgsscratchReg(backEnd, _numArgs, SendNumArgsReg);
	genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(ceCPICMissreceiver, trampolineNamenumRegArgs("cePICMiss", _numArgs), 2, ClassReg, ReceiverResultReg, null, null, 0, 1, NoReg, 1);
	return _startAddress;
}
/* StackToRegisterMappingCogit>>#genPopStackBytecode */
static sqInt
genPopStackBytecode(void)
{
	ssPop(1);
	return 0;
}
/*	Check the argument count. Fail if wrong. 
	Get the method from the outerContext and see if it is cogged. If so, jump 
	to the 
	block entry or the no-context-switch entry, as appropriate, and we're 
	done. If not, 
	invoke the interpreter primitive.Override to push the register args first. */
/* StackToRegisterMappingCogit>>#genPrimitiveFullClosureValue */
static sqInt
genPrimitiveFullClosureValue(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	sqInt _literal;
	sqInt _quickConstant;
	sqInt _quickConstant2;

	genPushRegisterArgs();
	{
		AbstractInstruction *_jumpBCMethod;
		AbstractInstruction *_jumpFail4;
		AbstractInstruction *_jumpFailImmediateMethod;
		AbstractInstruction *_jumpFailNArgs;
		void (*_primitiveRoutine)(void);
		sqInt _result;

		genLoadSlotsourceRegdestReg(FullClosureNumArgsIndex, ReceiverResultReg, TempReg);
		/* begin checkQuickConstant:forInstruction: */
		_literal = ((((usqInt) methodOrBlockNumArgs ) << 3) | 1);
		_anInstruction = genoperandoperand(CmpCqR, ((((usqInt) methodOrBlockNumArgs ) << 3) | 1), TempReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_literal));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin JumpNonZero: */
		_jumpFailNArgs = genConditionalBranchoperand(JumpNonZero, ((sqInt) 0 ));
		/* end JumpNonZero: */
		genLoadSlotsourceRegdestReg(FullClosureCompiledBlockIndex, ReceiverResultReg, SendNumArgsReg);
		_jumpFailImmediateMethod = genJumpImmediate(SendNumArgsReg);
		genGetFormatOfinto(SendNumArgsReg, TempReg);
		/* begin CmpCq:R: */
		_quickConstant = firstCompiledMethodFormat();
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(CmpCqR, _quickConstant, TempReg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(_quickConstant));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end CmpCq:R: */
		/* begin JumpLess: */
		_jumpFail4 = genConditionalBranchoperand(JumpLess, ((sqInt) 0 ));
		/* end JumpLess: */
		genLoadSlotsourceRegdestReg(HeaderIndex, SendNumArgsReg, ClassReg);
		_jumpBCMethod = genJumpImmediate(ClassReg);
		_primitiveRoutine = functionPointerForCompiledMethodprimitiveIndex(methodObj, primitiveIndex);
		/* begin AddCq:R: */
		_quickConstant2 = ((_primitiveRoutine == primitiveFullClosureValueNoContextSwitch)
			 ? fullBlockNoContextSwitchEntryOffset()
			 : fullBlockEntryOffset());
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction3 = genoperandoperand(AddCqR, _quickConstant2, ClassReg);
		if (usesOutOfLineLiteral(_anInstruction3)) {
			(_anInstruction3->dependent = locateLiteral(_quickConstant2));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end AddCq:R: */
		/* begin JumpR: */
		genoperand(JumpR, ClassReg);
		/* end JumpR: */
		jmpTarget(_jumpBCMethod, jmpTarget(_jumpFailImmediateMethod, jmpTarget(_jumpFail4, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
		if (((_result = compileInterpreterPrimitiveflags(_primitiveRoutine, primitivePropertyFlagsprimitiveDescriptor(primitiveIndex, primitiveDescriptor())))) < 0) {
			return _result;
		}
		jmpTarget(_jumpFailNArgs, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
		return CompletePrimitive;
	}
	return 0;
}
/*	Generate an in-line perform primitive. The lookup code requires the 
	selector to be in Arg0Reg. 
	adjustArgumentsForPerform: adjusts the arguments once 
	genLookupForPerformNumArgs: has generated the code for the lookup. */
/* StackToRegisterMappingCogit>>#genPrimitivePerform */
static sqInt
genPrimitivePerform(void)
{
	AbstractInstruction *_anInstruction;
	sqInt _offset;

	if (methodOrBlockNumArgs > 2) {
		/* begin MoveMw:r:R: */
		_offset = (methodOrBlockNumArgs - 1) * BytesPerWord;
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperandoperand(MoveMwrR, _offset, SPReg, Arg0Reg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_offset));
		}
		/* end checkQuickConstant:forInstruction: */
		/* end MoveMw:r:R: */
	}
	return genLookupForPerformNumArgs(methodOrBlockNumArgs);
}
/* StackToRegisterMappingCogit>>#genPushActiveContextBytecode */
static sqInt
genPushActiveContextBytecode(void)
{
	assert(needsFrame);
	voidReceiverResultRegContainsSelf();
	{
		/* begin ssAllocateCallReg:and:and: */
		ssAllocateRequiredRegMaskupThrough(CallerSavedRegisterMask | (((1U << ReceiverResultReg) | (1U << SendNumArgsReg)) | (1U << ClassReg)), simStackPtr);
		/* end ssAllocateCallReg:and:and: */
	}
	genGetActiveContextNumArgslargeinBlock(methodOrBlockNumArgs, methodNeedsLargeContext(methodObj), inBlock);
	return ssPushRegister(ReceiverResultReg);
}
/* StackToRegisterMappingCogit>>#genPushFloat32ArrayToRegister */

#if FEATURE_JIT_SIMD
static sqInt
genPushFloat32ArrayToRegister(void)
{
	AbstractInstruction *_anInstruction;
	signed char _arrayReg;
	signed char _indexReg;
	sqInt _vectorReg;

	_arrayReg = allocateRegForStackEntryAtnotConflictingWith(0, 0);
	_indexReg = allocateRegForStackEntryAtnotConflictingWith(1, 1ULL << _arrayReg);
	ssPopTopToReg(_arrayReg);
	ssPopTopToReg(_indexReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(AddCqR, BaseHeaderSize, _arrayReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	assert(BytesPerWord == 8);
	/* begin LogicalShiftRightCq:R: */
	genoperandoperand(LogicalShiftRightCqR, 1, _indexReg);
	/* end LogicalShiftRightCq:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, _indexReg, _arrayReg);
	/* end AddR:R: */
	_vectorReg = allocateVectorRegNotConflictingWith(0);
	gLd1SVrRMw(32, _vectorReg, _arrayReg, 0);
	ssPushVectorRegister(_vectorReg);
	return 0;
}
#endif /* FEATURE_JIT_SIMD */
/* StackToRegisterMappingCogit>>#genPushFloat64ArrayToRegister */

#if FEATURE_JIT_SIMD
static sqInt
genPushFloat64ArrayToRegister(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	signed char _arrayReg;
	signed char _indexReg;
	sqInt _vectorReg;

	_arrayReg = allocateRegForStackEntryAtnotConflictingWith(0, 0);
	_indexReg = allocateRegForStackEntryAtnotConflictingWith(1, 1ULL << _arrayReg);
	ssPopTopToReg(_arrayReg);
	ssPopTopToReg(_indexReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(AddCqR, BaseHeaderSize, _arrayReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	assert(BytesPerWord == 8);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(SubCqR, 1, _indexReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, _indexReg, _arrayReg);
	/* end AddR:R: */
	_vectorReg = allocateVectorRegNotConflictingWith(0);
	gLd1SVrRMw(64, _vectorReg, _arrayReg, 0);
	ssPushVectorRegister(_vectorReg);
	return 0;
}
#endif /* FEATURE_JIT_SIMD */
/*	<SmallInteger>Override to avoid the BytecodeSetHasDirectedSuperSend check, which is 
	unnecessary here given the simulation stack. */
/* StackToRegisterMappingCogit>>#genPushLiteralIndex: */
static sqInt NoDbgRegParms
genPushLiteralIndex(sqInt _literalIndex)
{
	sqInt _literal;

	_literal = getLiteral(_literalIndex);
	return genPushLiteral(_literal);
}
/* StackToRegisterMappingCogit>>#genPushLiteralVariable: */
static sqInt NoDbgRegParms
genPushLiteralVariable(sqInt _literalIndex)
{
	AbstractInstruction *_anInstruction;
	sqInt _association;
	sqInt _bcpc;
	BytecodeDescriptor *_descriptor2;
	sqInt _eB;
	sqInt _freeReg;
	sqInt _savedB0;
	sqInt _savedB1;
	sqInt _savedB2;
	sqInt _savedB3;
	sqInt _savedEA;
	sqInt _savedEB;
	sqInt _savedNEB;

	_association = getLiteral(_literalIndex);
	{
		assert(!directedSendUsesBinding);
		/* begin nextDescriptorExtensionsAndNextPCInto: */
		_descriptor2 = generatorAt(byte0);
		_savedB0 = byte0;
		_savedB1 = byte1;
		_savedB2 = byte2;
		_savedB3 = byte3;
		_savedEA = extA;
		_savedEB = extB;
		_savedNEB = numExtB;
		_bcpc = bytecodePC + ((_descriptor2->numBytes));
		do {
			if (_bcpc > endPC) {
				{
				}
				goto l2;
			}
			byte0 = fetchByteofObject(_bcpc, methodObj);
			_descriptor2 = generatorAt(byte0);
			loadSubsequentBytesForDescriptorat(_descriptor2, _bcpc);
			if (!((_descriptor2->isExtension))) {
				_eB = extB;
				extA = _savedEA;
				extB = _savedEB;
				numExtB = _savedNEB;
				byte0 = _savedB0;
				byte1 = _savedB1;
				byte2 = _savedB2;
				byte3 = _savedB3;
				{
					if ((_descriptor2 != null) && ((((_descriptor2->generator)) == genExtSendSuperBytecode) && (_eB >= 64))) {
						ssPushConstant(_association);
						directedSendUsesBinding = 1;
						return 0;
					}
				}
				goto l2;
			}
			((_descriptor2->generator))();
			_bcpc += (_descriptor2->numBytes);
		} while (1);
		l2:
		;
		/* end nextDescriptorExtensionsAndNextPCInto: */
	}
	_freeReg = allocateRegNotConflictingWith(0);
	/* begin genMoveConstant:R: */
	if (shouldAnnotateObjectReference(_association)) {
		annotateobjRef(gMoveCwR(_association, TempReg), _association);
	} else {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, _association, TempReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_association));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* end genMoveConstant:R: */
	genEnsureObjInRegNotForwardedscratchReg(TempReg, _freeReg);
	genLoadSlotsourceRegdestReg(ValueIndex, TempReg, _freeReg);
	ssPushRegister(_freeReg);
	return 0;
}
/* StackToRegisterMappingCogit>>#genPushLiteral: */
static sqInt NoDbgRegParms
genPushLiteral(sqInt _literal)
{
	return ssPushConstant(_literal);
}
/* StackToRegisterMappingCogit>>#genPushMaybeContextReceiverVariable: */
static sqInt NoDbgRegParms
genPushMaybeContextReceiverVariable(sqInt _slotIndex)
{
	AbstractInstruction *_abstractInstruction;
	AbstractInstruction *_abstractInstruction2;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_jmpDone;
	AbstractInstruction *_jmpSingle;

	/* begin ssAllocateCallReg:and: */
	ssAllocateRequiredRegMaskupThrough(CallerSavedRegisterMask | ((1U << ReceiverResultReg) | (1U << SendNumArgsReg)), simStackPtr);
	/* end ssAllocateCallReg:and: */
	ensureReceiverResultRegContainsSelf();
	/* begin genPushMaybeContextSlotIndex: */
	assert(needsFrame);
	if (CallerSavedRegisterMask & (1U << ReceiverResultReg)) {
		voidReceiverResultRegContainsSelf();
	}
	if (_slotIndex == InstructionPointerIndex) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, _slotIndex, SendNumArgsReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_slotIndex));
		}
		/* end checkQuickConstant:forInstruction: */
		/* begin CallRT: */
		/* begin annotateCall: */
		_abstractInstruction = genoperand(Call, ceFetchContextInstVarTrampoline);
		(_abstractInstruction->annotation = IsRelativeCall);
		/* end annotateCall: */
		/* end CallRT: */
		return ssPushRegister(SendNumArgsReg);
	}
	genLoadSlotsourceRegdestReg(SenderIndex, ReceiverResultReg, TempReg);
	/* begin genJumpNotSmallIntegerInScratchReg: */
	_jmpSingle = genJumpNotSmallInteger(TempReg);
	/* end genJumpNotSmallIntegerInScratchReg: */
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(MoveCqR, _slotIndex, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_slotIndex));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin CallRT: */
	/* begin annotateCall: */
	_abstractInstruction2 = genoperand(Call, ceFetchContextInstVarTrampoline);
	(_abstractInstruction2->annotation = IsRelativeCall);
	/* end annotateCall: */
	/* end CallRT: */
	/* begin Jump: */
	_jmpDone = genoperand(Jump, ((sqInt) 0 ));
	/* end Jump: */
	jmpTarget(_jmpSingle, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	genLoadSlotsourceRegdestReg(_slotIndex, ReceiverResultReg, SendNumArgsReg);
	jmpTarget(_jmpDone, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return ssPushRegister(SendNumArgsReg);
	/* end genPushMaybeContextSlotIndex: */
}
/* StackToRegisterMappingCogit>>#genPushNewArrayBytecode */
static sqInt
genPushNewArrayBytecode(void)
{
	sqInt _i;
	int _popValues;
	sqInt _size;

	assert(needsFrame);
	voidReceiverResultRegContainsSelf();
	if ((_popValues = byte1 > 0x7F)) {
		ssFlushStack();
	} else {
		/* begin ssAllocateCallReg:and: */
		ssAllocateRequiredRegMaskupThrough(CallerSavedRegisterMask | ((1U << SendNumArgsReg) | (1U << ReceiverResultReg)), simStackPtr);
		/* end ssAllocateCallReg:and: */
	}
	_size = byte1 & 0x7F;
	if (!_popValues) {
		if (tryCollapseTempVectorInitializationOfSize(_size)) {
			return 0;
		}
	}
	genNewArrayOfSizeinitialized(_size, !_popValues);
	if (_popValues) {
		for (_i = _size - 1; _i >= 0; _i += -1) {
			ssPopTopToReg(TempReg);
			genStoreSourceRegslotIndexintoNewObjectInDestReg(TempReg, _i, ReceiverResultReg);
		}
	}
	return ssPushRegister(ReceiverResultReg);
}
/* StackToRegisterMappingCogit>>#genPushReceiverBytecode */
static sqInt
genPushReceiverBytecode(void)
{
	if ((((simSelf())->liveRegister)) == ReceiverResultReg) {
		return ssPushRegister(ReceiverResultReg);
	}
	return ssPushDesc(ssSelfDescriptor());
}
/* StackToRegisterMappingCogit>>#genPushReceiverVariable: */
static sqInt NoDbgRegParms
genPushReceiverVariable(sqInt _index)
{
	ensureReceiverResultRegContainsSelf();
	return ssPushBaseoffset(ReceiverResultReg, slotOffsetOfInstVarIndex(_index));
}
/*	Ensure that the register args are pushed before the retpc for methods with 
	arity <= self numRegArgs.This won't be as clumsy on a RISC. But putting the receiver and 
	args above the return address means the CoInterpreter has a 
	single machine-code frame format which saves us a lot of work. */
/* StackToRegisterMappingCogit>>#genPushRegisterArgs */
static void
genPushRegisterArgs(void)
{
	if (!(regArgsHaveBeenPushed || (methodOrBlockNumArgs > 2))) {
		genPushRegisterArgsForNumArgsscratchReg(backEnd, methodOrBlockNumArgs, SendNumArgsReg);
		regArgsHaveBeenPushed = 1;
	}
}
/* StackToRegisterMappingCogit>>#genPushRemoteTempLongBytecode */
static sqInt
genPushRemoteTempLongBytecode(void)
{
	AbstractInstruction *_anInstruction;
	sqInt _offset;
	sqInt _regMask;
	sqInt _remoteTempReg;
	sqInt _tempVectReg;

	_tempVectReg = allocateRegNotConflictingWith(0);
	/* begin MoveMw:r:R: */
	_offset = frameOffsetOfTemporary(byte2);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveMwrR, _offset, FPReg, _tempVectReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_offset));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end MoveMw:r:R: */
	/* begin availableRegOrNoneNotConflictingWith: */
	_regMask = 1ULL << _tempVectReg;
	_remoteTempReg = availableRegisterOrNoneFor(backEnd, (liveRegisters()) | _regMask);
	/* end availableRegOrNoneNotConflictingWith: */
	if (_remoteTempReg == NoReg) {
		_remoteTempReg = _tempVectReg;
	}
	genLoadSlotsourceRegdestReg(byte1, _tempVectReg, _remoteTempReg);
	return ssPushRegister(_remoteTempReg);
}
/*	If a frameless method (not a block), only argument temps can be accessed. 
	This is assured by the use of needsFrameIfMod16GENumArgs: in pushTemp. */
/* StackToRegisterMappingCogit>>#genPushTemporaryVariable: */
static sqInt NoDbgRegParms
genPushTemporaryVariable(sqInt _index)
{
	assert((inBlock > 0) || (needsFrame || (_index < methodOrBlockNumArgs)));
	return ssPushDesc(simStack[_index + 1]);
}
/*	In a frameless method ReceiverResultReg already contains self. 
	In a frameful method, ReceiverResultReg /may/ contain self. */
/* StackToRegisterMappingCogit>>#genReturnReceiver */
static sqInt
genReturnReceiver(void)
{
	if (needsFrame) {
		if (!((((simSelf())->liveRegister)) == ReceiverResultReg)) {
			/* begin putSelfInReceiverResultReg */
			copyToReg(simSelf(), ReceiverResultReg);
			/* end putSelfInReceiverResultReg */
		}
	}
	return genUpArrowReturn();
}
/* StackToRegisterMappingCogit>>#genReturnTopFromBlock */
static sqInt
genReturnTopFromBlock(void)
{
	assert(inBlock > 0);
	ssPopTopToReg(ReceiverResultReg);
	return genBlockReturn();
}
/* StackToRegisterMappingCogit>>#genReturnTopFromMethod */
static sqInt
genReturnTopFromMethod(void)
{
	ssPopTopToReg(ReceiverResultReg);
	return genUpArrowReturn();
}
/* StackToRegisterMappingCogit>>#genSendDirectedSuper:numArgs: */
static sqInt NoDbgRegParms
genSendDirectedSupernumArgs(sqInt _selectorIndex, sqInt _numArgs)
{
	sqInt _result;

	assert((((ssTop())->type)) == SSConstant);
	tempOop = ((ssTop())->constant);
	ssPop(1);
	marshallSendArguments(_numArgs);
	_result = genMarshalledSendnumArgssendTable(_selectorIndex, _numArgs, ((directedSendUsesBinding)
		 ? directedSuperBindingSendTrampolines
		 : directedSuperSendTrampolines));
	directedSendUsesBinding = 0;
	return _result;
}
/* StackToRegisterMappingCogit>>#genSendSuper:numArgs: */
static sqInt NoDbgRegParms
genSendSupernumArgs(sqInt _selectorIndex, sqInt _numArgs)
{
	marshallSendArguments(_numArgs);
	return genMarshalledSendnumArgssendTable(_selectorIndex, _numArgs, superSendTrampolines);
}
/*	Generate a trampoline with four arguments. 
	Hack: a negative value indicates an abstract register, a non-negative 
	value indicates a constant. */
/* StackToRegisterMappingCogit>>#genSendTrampolineFor:numArgs:called:arg:arg:arg:arg: */
static sqInt NoDbgRegParms
genSendTrampolineFornumArgscalledargargargarg(void *_aRoutine, sqInt _numArgs, char *_aString, sqInt _regOrConst0, sqInt _regOrConst1, sqInt _regOrConst2, sqInt _regOrConst3)
{
	sqInt _routine;
	sqInt _startAddress;

	_startAddress = methodZoneBase;
	zeroOpcodeIndex();
	genPushRegisterArgsForNumArgsscratchReg(backEnd, _numArgs, SendNumArgsReg);
	{
		/* begin selectorIndexDereferenceRoutine */
		_routine = ceDereferenceSelectorIndex;
		/* end selectorIndexDereferenceRoutine */
		if (!(_routine == null)) {
			{
				/* begin PushR: */
				genoperand(PushR, LinkReg);
				/* end PushR: */
			}
			/* begin Call: */
			genoperand(Call, _routine);
			/* end Call: */
			{
				/* begin PopR: */
				genoperand(PopR, LinkReg);
				/* end PopR: */
			}
		}
	}
	genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(_aRoutine, _aString, 4, _regOrConst0, _regOrConst1, _regOrConst2, _regOrConst3, 0, 1, NoReg, 1);
	return _startAddress;
}
/* StackToRegisterMappingCogit>>#genSend:numArgs: */
static sqInt NoDbgRegParms
genSendnumArgs(sqInt _selectorIndex, sqInt _numArgs)
{
	marshallSendArguments(_numArgs);
	return genMarshalledSendnumArgssendTable(_selectorIndex, _numArgs, ordinarySendTrampolines);
}
/* StackToRegisterMappingCogit>>#genSpecialSelectorArithmetic */
static sqInt
genSpecialSelectorArithmetic(void)
{
	AbstractInstruction *_abstractInstruction;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_anInstruction3;
	AbstractInstruction *_anInstruction4;
	AbstractInstruction *_anInstruction5;
	AbstractInstruction *_anInstruction6;
	AbstractInstruction *_anInstruction7;
	AbstractInstruction *_anInstruction8;
	sqInt _argInt;
	int _argIsConst;
	sqInt _argIsInt;
	sqInt _index;
	AbstractInstruction *_jumpContinue;
	AbstractInstruction *_jumpNotSmallInts;
	BytecodeDescriptor *_primDescriptor;
	sqInt _rcvrInt;
	int _rcvrIsConst;
	sqInt _rcvrIsInt;
	sqInt _result;

	_primDescriptor = generatorAt(byte0);
	_argIsInt = (((_argIsConst = (((ssTop())->type)) == SSConstant)) && (((((_argInt = ((ssTop())->constant))) & 7) == 1))) || ((mclassIsSmallInteger()) && (isSameEntryAs(ssTop(), simSelf())));
	_rcvrIsInt = (((_rcvrIsConst = (((ssValue(1))->type)) == SSConstant)) && (((((_rcvrInt = ((ssValue(1))->constant))) & 7) == 1))) || ((mclassIsSmallInteger()) && (isSameEntryAs(ssValue(1), simSelf())));
	if (_argIsInt && (_argIsConst && (_rcvrIsInt && _rcvrIsConst))) {
		_rcvrInt = _rcvrInt >> 3;
		_argInt = _argInt >> 3;
		switch ((_primDescriptor->opcode)) {
			case AddRR:
			{
				_result = _rcvrInt + _argInt;
			}
			break;
			case SubRR:
			{
				_result = _rcvrInt - _argInt;
			}
			break;
			case AndRR:
			{
				_result = _rcvrInt & _argInt;
			}
			break;
			case OrRR:
			{
				_result = _rcvrInt | _argInt;
			}
			break;
			default:
			error("Case not found and no otherwise clause");
		}
		if (isIntegerValue(_result)) {
			return (ssPop(2), ssPushAnnotatedConstant(((((usqInt) _result ) << 3) | 1)));
		}
		return genSpecialSelectorSend();
	}
	if ((_rcvrIsConst && !_rcvrIsInt) || (_argIsConst && !_argIsInt)) {
		return genSpecialSelectorSend();
	}
	if (!(_argIsInt || _rcvrIsInt)) {
		return genSpecialSelectorSend();
	}
	if (_argIsConst) {
		ssFlushStackExceptTop(2);
		ssPop(1);
		ssPopTopToReg(ReceiverResultReg);
	} else {
		marshallSendArguments(1);
	}
	_jumpNotSmallInts = ((!(_rcvrIsInt && _argIsInt))
		 ? ((_argIsInt)
			 ? genJumpNotSmallInteger(ReceiverResultReg)
			 : ((_rcvrIsInt)
				 ? genJumpNotSmallInteger(Arg0Reg)
				 : (/* begin genJumpNotSmallIntegersIn:and:scratch: */ (/* begin MoveR:R: */ genoperandoperand(MoveRR, ReceiverResultReg, TempReg) /* end MoveR:R: */, /* begin AndR:R: */ genoperandoperand(AndRR, Arg0Reg, TempReg) /* end AndR:R: */), genJumpNotSmallInteger(TempReg) /* end genJumpNotSmallIntegersIn:and:scratch: */)))
		 : 0);
	switch ((_primDescriptor->opcode)) {
		case AddRR:
		{
			if (_argIsConst) {
				/* begin checkQuickConstant:forInstruction: */
				_anInstruction = genoperandoperand(AddCqR, _argInt - ConstZero, ReceiverResultReg);
				if (usesOutOfLineLiteral(_anInstruction)) {
					(_anInstruction->dependent = locateLiteral(_argInt - ConstZero));
				}
				/* end checkQuickConstant:forInstruction: */
				/* begin JumpNoOverflow: */
				_jumpContinue = genConditionalBranchoperand(JumpNoOverflow, ((sqInt) 0 ));
				/* end JumpNoOverflow: */
				/* begin checkQuickConstant:forInstruction: */
				_anInstruction2 = genoperandoperand(SubCqR, _argInt - ConstZero, ReceiverResultReg);
				if (usesOutOfLineLiteral(_anInstruction2)) {
					(_anInstruction2->dependent = locateLiteral(_argInt - ConstZero));
				}
				/* end checkQuickConstant:forInstruction: */
			} else {
				genRemoveSmallIntegerTagsInScratchReg(ReceiverResultReg);
				/* begin AddR:R: */
				genoperandoperand(AddRR, Arg0Reg, ReceiverResultReg);
				/* end AddR:R: */
				/* begin JumpNoOverflow: */
				_jumpContinue = genConditionalBranchoperand(JumpNoOverflow, ((sqInt) 0 ));
				/* end JumpNoOverflow: */
				if (_rcvrIsInt && _rcvrIsConst) {
					/* begin checkQuickConstant:forInstruction: */
					_anInstruction3 = genoperandoperand(MoveCqR, _rcvrInt, ReceiverResultReg);
					if (usesOutOfLineLiteral(_anInstruction3)) {
						(_anInstruction3->dependent = locateLiteral(_rcvrInt));
					}
					/* end checkQuickConstant:forInstruction: */
				} else {
					/* begin SubR:R: */
					genoperandoperand(SubRR, Arg0Reg, ReceiverResultReg);
					/* end SubR:R: */
					genSetSmallIntegerTagsIn(ReceiverResultReg);
				}
			}
		}
		break;
		case SubRR:
		{
			if (_argIsConst) {
				/* begin checkQuickConstant:forInstruction: */
				_anInstruction4 = genoperandoperand(SubCqR, _argInt - ConstZero, ReceiverResultReg);
				if (usesOutOfLineLiteral(_anInstruction4)) {
					(_anInstruction4->dependent = locateLiteral(_argInt - ConstZero));
				}
				/* end checkQuickConstant:forInstruction: */
				/* begin JumpNoOverflow: */
				_jumpContinue = genConditionalBranchoperand(JumpNoOverflow, ((sqInt) 0 ));
				/* end JumpNoOverflow: */
				/* begin checkQuickConstant:forInstruction: */
				_anInstruction5 = genoperandoperand(AddCqR, _argInt - ConstZero, ReceiverResultReg);
				if (usesOutOfLineLiteral(_anInstruction5)) {
					(_anInstruction5->dependent = locateLiteral(_argInt - ConstZero));
				}
				/* end checkQuickConstant:forInstruction: */
			} else {
				genRemoveSmallIntegerTagsInScratchReg(Arg0Reg);
				/* begin SubR:R: */
				genoperandoperand(SubRR, Arg0Reg, ReceiverResultReg);
				/* end SubR:R: */
				/* begin JumpNoOverflow: */
				_jumpContinue = genConditionalBranchoperand(JumpNoOverflow, ((sqInt) 0 ));
				/* end JumpNoOverflow: */
				/* begin AddR:R: */
				genoperandoperand(AddRR, Arg0Reg, ReceiverResultReg);
				/* end AddR:R: */
				genSetSmallIntegerTagsIn(Arg0Reg);
			}
		}
		break;
		case AndRR:
		{
			if (_argIsConst) {
				/* begin checkQuickConstant:forInstruction: */
				_anInstruction6 = genoperandoperand(AndCqR, _argInt, ReceiverResultReg);
				if (usesOutOfLineLiteral(_anInstruction6)) {
					(_anInstruction6->dependent = locateLiteral(_argInt));
				}
				/* end checkQuickConstant:forInstruction: */
			} else {
				/* begin AndR:R: */
				genoperandoperand(AndRR, Arg0Reg, ReceiverResultReg);
				/* end AndR:R: */
			}
			_jumpContinue = ((_jumpNotSmallInts)
				 ? (/* begin Jump: */ genoperand(Jump, ((sqInt) 0 )) /* end Jump: */)
				 : 0);
		}
		break;
		case OrRR:
		{
			if (_argIsConst) {
				/* begin checkQuickConstant:forInstruction: */
				_anInstruction7 = genoperandoperand(OrCqR, _argInt, ReceiverResultReg);
				if (usesOutOfLineLiteral(_anInstruction7)) {
					(_anInstruction7->dependent = locateLiteral(_argInt));
				}
				/* end checkQuickConstant:forInstruction: */
			} else {
				/* begin OrR:R: */
				genoperandoperand(OrRR, Arg0Reg, ReceiverResultReg);
				/* end OrR:R: */
			}
			_jumpContinue = ((_jumpNotSmallInts)
				 ? (/* begin Jump: */ genoperand(Jump, ((sqInt) 0 )) /* end Jump: */)
				 : 0);
		}
		break;
		default:
		error("Case not found and no otherwise clause");
	}
	if (_jumpNotSmallInts == null) {
		if (!_jumpContinue) {
			/* begin annotateInstructionForBytecode */
			/* begin annotateBytecode: */
			_abstractInstruction = ((AbstractInstruction *) (((prevInstIsPCAnnotated())
				 ? (/* begin Nop */ gen(Nop) /* end Nop */)
				 : (/* begin Label */ genoperandoperand(Label, (labelCounter += 1), bytecodePC) /* end Label */))) );
			(_abstractInstruction->annotation = HasBytecodePC);
			/* end annotateBytecode: */
			/* end annotateInstructionForBytecode */
			ssPushRegister(ReceiverResultReg);
			return 0;
		}
	} else {
		jmpTarget(_jumpNotSmallInts, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	}
	if (_argIsConst) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction8 = genoperandoperand(MoveCqR, _argInt, Arg0Reg);
		if (usesOutOfLineLiteral(_anInstruction8)) {
			(_anInstruction8->dependent = locateLiteral(_argInt));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	_index = byte0 - FirstSpecialSelector;
	genMarshalledSendnumArgssendTable(-_index - 1, 1, ordinarySendTrampolines);
	jmpTarget(_jumpContinue, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	return 0;
}
/* StackToRegisterMappingCogit>>#genSpecialSelectorClass */
static sqInt
genSpecialSelectorClass(void)
{
	sqInt _requiredReg1;
	sqInt _topReg;

	_topReg = registerOrNone(ssTop());
	if ((_topReg == NoReg) || (_topReg == ClassReg)) {
		/* begin ssAllocateRequiredReg:and:upThrough: */
		_requiredReg1 = (_topReg = SendNumArgsReg);
		ssAllocateRequiredRegMaskupThrough((1ULL << _requiredReg1) | (1U << ClassReg), simStackPtr - 1);
		/* end ssAllocateRequiredReg:and:upThrough: */
	} else {
		/* begin ssAllocateRequiredReg:upThrough: */
		ssAllocateRequiredRegMaskupThrough(1U << ClassReg, simStackPtr - 1);
		/* end ssAllocateRequiredReg:upThrough: */
	}
	ssPopTopToReg(_topReg);
	genGetClassObjectOfintoscratchReginstRegIsReceiver(_topReg, ClassReg, TempReg, 0);
	return ssPushRegister(ClassReg);
}
/* StackToRegisterMappingCogit>>#genSpecialSelectorComparison */
static sqInt
genSpecialSelectorComparison(void)
{
	AbstractInstruction *_abstractInstruction;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	sqInt _argInt;
	sqInt _argIsIntConst;
	BytecodeDescriptor *_branchDescriptor;
	BytecodeDescriptor *_branchDescriptor2;
	sqInt _index;
	sqInt _inlineCAB;
	AbstractInstruction *_jumpNotSmallInts;
	void *_jumpTarget;
	int _nExts;
	sqInt _nextPC2;
	sqInt _postBranchPC;
	sqInt _postBranchPC2;
	BytecodeDescriptor *_primDescriptor;
	BytecodeDescriptor *_primDescriptor2;
	int _rcvrIsConst;
	sqInt _rcvrIsInt;
	sqInt _targetBytecodePC;
	sqInt _targetPC;

	ssFlushStackExceptTop(2);
	_primDescriptor = generatorAt(byte0);
	_argIsIntConst = ((((ssTop())->type)) == SSConstant) && (((((_argInt = ((ssTop())->constant))) & 7) == 1));
	_rcvrIsInt = (((_rcvrIsConst = (((ssValue(1))->type)) == SSConstant)) && ((((((ssValue(1))->constant)) & 7) == 1))) || ((mclassIsSmallInteger()) && (isSameEntryAs(ssValue(1), simSelf())));
	if (_argIsIntConst && (_rcvrIsInt && _rcvrIsConst)) {
		return genStaticallyResolvedSpecialSelectorComparison();
	}
	/* begin extractMaybeBranchDescriptorInto: */
	_primDescriptor2 = generatorAt(byte0);
	_nextPC2 = bytecodePC + ((_primDescriptor2->numBytes));
	_nExts = 0;
	while (1) {
		while (1) {
			/* begin generatorForPC: */
			_branchDescriptor2 = generatorAt(fetchByteofObject(_nextPC2, methodObj));
			/* end generatorForPC: */
			if (!((_branchDescriptor2->isExtension))) 
				break;
			_nExts += 1;
			_nextPC2 += (_branchDescriptor2->numBytes);
		}
		/* begin isUnconditionalBranch */
		/* end isUnconditionalBranch */
		if (!((isBranch(_branchDescriptor2)) && (!(((_branchDescriptor2->isBranchTrue)) || ((_branchDescriptor2->isBranchFalse)))))) 
			break;
		_nextPC2 = eventualTargetOf((_nextPC2 + ((_branchDescriptor2->numBytes))) + (((_branchDescriptor2->spanFunction))(_branchDescriptor2, _nextPC2, _nExts, methodObj)));
	}
	_targetBytecodePC = (_postBranchPC2 = 0);
	if (((_branchDescriptor2->isBranchTrue)) || ((_branchDescriptor2->isBranchFalse))) {
		_targetBytecodePC = eventualTargetOf((_nextPC2 + ((_branchDescriptor2->numBytes))) + (((_branchDescriptor2->spanFunction))(_branchDescriptor2, _nextPC2, _nExts, methodObj)));
		_postBranchPC2 = eventualTargetOf(_nextPC2 + ((_branchDescriptor2->numBytes)));
	} else {
		_nextPC2 = bytecodePC + ((_primDescriptor2->numBytes));
	}
	{
		_branchDescriptor = _branchDescriptor2;
		_postBranchPC = _postBranchPC2;
		_targetPC = _targetBytecodePC;
	}
	/* end extractMaybeBranchDescriptorInto: */
	_inlineCAB = ((_branchDescriptor->isBranchTrue)) || ((_branchDescriptor->isBranchFalse));
	if (_inlineCAB && ((((_primDescriptor->opcode)) == JumpZero) || (((_primDescriptor->opcode)) == JumpNonZero))) {
		_inlineCAB = _argIsIntConst || _rcvrIsInt;
	}
	if (!_inlineCAB) {
		return genSpecialSelectorSend();
	}
	if (_argIsIntConst) {
		ssPop(1);
		ssPopTopToReg(ReceiverResultReg);
	} else {
		marshallSendArguments(1);
	}
	_jumpNotSmallInts = null;
	if (!(_rcvrIsInt && _argIsIntConst)) {
		if (_argIsIntConst) {
			_jumpNotSmallInts = genJumpNotSmallInteger(ReceiverResultReg);
		} else {
			if (_rcvrIsInt) {
				_jumpNotSmallInts = genJumpNotSmallInteger(Arg0Reg);
			} else {
				/* begin genJumpNotSmallIntegersIn:and:scratch: */
				{
					/* begin MoveR:R: */
					genoperandoperand(MoveRR, ReceiverResultReg, TempReg);
					/* end MoveR:R: */
					/* begin AndR:R: */
					genoperandoperand(AndRR, Arg0Reg, TempReg);
					/* end AndR:R: */
				}
				_jumpNotSmallInts = genJumpNotSmallInteger(TempReg);
				/* end genJumpNotSmallIntegersIn:and:scratch: */
			}
		}
	}
	if (_argIsIntConst) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(CmpCqR, _argInt, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_argInt));
		}
		/* end checkQuickConstant:forInstruction: */
	} else {
		/* begin CmpR:R: */
		genoperandoperand(CmpRR, Arg0Reg, ReceiverResultReg);
		/* end CmpR:R: */
	}
	genConditionalBranchoperand((((_branchDescriptor->isBranchTrue))
		 ? (_primDescriptor->opcode)
		 : inverseBranchFor((_primDescriptor->opcode))), ((usqInt) (ensureNonMergeFixupAt(_targetPC)) ));
	/* begin Jump: */
	_jumpTarget = ensureNonMergeFixupAt(_postBranchPC);
	genoperand(Jump, ((sqInt) _jumpTarget ));
	/* end Jump: */
	if (!_jumpNotSmallInts) {
		/* begin annotateInstructionForBytecode */
		/* begin annotateBytecode: */
		_abstractInstruction = ((AbstractInstruction *) (((prevInstIsPCAnnotated())
			 ? (/* begin Nop */ gen(Nop) /* end Nop */)
			 : (/* begin Label */ genoperandoperand(Label, (labelCounter += 1), bytecodePC) /* end Label */))) );
		(_abstractInstruction->annotation = HasBytecodePC);
		/* end annotateBytecode: */
		/* end annotateInstructionForBytecode */
		ensureFixupAt(_postBranchPC);
		ensureFixupAt(_targetPC);
		deadCode = 1;
		return 0;
	}
	jmpTarget(_jumpNotSmallInts, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	if (_argIsIntConst) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction2 = genoperandoperand(MoveCqR, _argInt, Arg0Reg);
		if (usesOutOfLineLiteral(_anInstruction2)) {
			(_anInstruction2->dependent = locateLiteral(_argInt));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	_index = byte0 - FirstSpecialSelector;
	return genMarshalledSendnumArgssendTable(-_index - 1, 1, ordinarySendTrampolines);
}
/*	Assumes both operands are ints */
/* StackToRegisterMappingCogit>>#genStaticallyResolvedSpecialSelectorComparison */
static sqInt
genStaticallyResolvedSpecialSelectorComparison(void)
{
	sqInt _argInt;
	BytecodeDescriptor *_primDescriptor;
	sqInt _rcvrInt;
	int _result;

	_primDescriptor = generatorAt(byte0);
	_argInt = ((ssTop())->constant);
	_rcvrInt = ((ssValue(1))->constant);
	switch ((_primDescriptor->opcode)) {
		case JumpLess:
		{
			_result = _rcvrInt < _argInt;
		}
		break;
		case JumpLessOrEqual:
		{
			_result = _rcvrInt <= _argInt;
		}
		break;
		case JumpGreater:
		{
			_result = _rcvrInt > _argInt;
		}
		break;
		case JumpGreaterOrEqual:
		{
			_result = _rcvrInt >= _argInt;
		}
		break;
		case JumpZero:
		{
			_result = _rcvrInt == _argInt;
		}
		break;
		case JumpNonZero:
		{
			_result = _rcvrInt != _argInt;
		}
		break;
		default:
		error("Case not found and no otherwise clause");
	}
	ssPop(2);
	return ssPushAnnotatedConstant(((_result)
		 ? trueObject()
		 : falseObject()));
}
/* StackToRegisterMappingCogit>>#genStoreFloat32RegisterIntoArray */

#if FEATURE_JIT_SIMD
static sqInt
genStoreFloat32RegisterIntoArray(void)
{
	AbstractInstruction *_anInstruction;
	signed char _arrayReg;
	signed char _indexReg;
	signed char _vectorReg;

	_arrayReg = allocateRegForStackEntryAtnotConflictingWith(0, 0);
	_indexReg = allocateRegForStackEntryAtnotConflictingWith(1, 1ULL << _arrayReg);
	ssPopTopToReg(_arrayReg);
	ssPopTopToReg(_indexReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(AddCqR, BaseHeaderSize, _arrayReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	assert(BytesPerWord == 8);
	/* begin LogicalShiftRightCq:R: */
	genoperandoperand(LogicalShiftRightCqR, 1, _indexReg);
	/* end LogicalShiftRightCq:R: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, _indexReg, _arrayReg);
	/* end AddR:R: */
	_vectorReg = allocateVectorRegForStackEntryAtnotConflictingWith(0, 0);
	ssPopTopToVectorReg(_vectorReg);
	gSt1SVrRMw(32, _vectorReg, _arrayReg, 0);
	ssPushRegister(_arrayReg);
	return 0;
}
#endif /* FEATURE_JIT_SIMD */
/* StackToRegisterMappingCogit>>#genStoreFloat64RegisterIntoArray */

#if FEATURE_JIT_SIMD
static sqInt
genStoreFloat64RegisterIntoArray(void)
{
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	signed char _arrayReg;
	signed char _indexReg;
	signed char _vectorReg;

	_arrayReg = allocateRegForStackEntryAtnotConflictingWith(0, 0);
	_indexReg = allocateRegForStackEntryAtnotConflictingWith(1, 1ULL << _arrayReg);
	ssPopTopToReg(_arrayReg);
	ssPopTopToReg(_indexReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperand(AddCqR, BaseHeaderSize, _arrayReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(BaseHeaderSize));
	}
	/* end checkQuickConstant:forInstruction: */
	assert(BytesPerWord == 8);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(SubCqR, 1, _indexReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(1));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin AddR:R: */
	genoperandoperand(AddRR, _indexReg, _arrayReg);
	/* end AddR:R: */
	_vectorReg = allocateVectorRegForStackEntryAtnotConflictingWith(0, 0);
	ssPopTopToVectorReg(_vectorReg);
	gSt1SVrRMw(64, _vectorReg, _arrayReg, 0);
	ssPushRegister(_arrayReg);
	return 0;
}
#endif /* FEATURE_JIT_SIMD */
/*	We need a frame because the association has to be in ReceiverResultReg for 
	the various trampolines 
	and ReceiverResultReg holds only the receiver in frameless methods. */
/* StackToRegisterMappingCogit>>#genStorePop:LiteralVariable:needsStoreCheck:needsImmutabilityCheck: */
static sqInt NoDbgRegParms
genStorePopLiteralVariableneedsStoreCheckneedsImmutabilityCheck(sqInt _popBoolean, sqInt _litVarIndex, sqInt _needsStoreCheck, sqInt _needsImmCheck)
{
	AbstractInstruction *_anInstruction;
	sqInt _association;
	signed char _topReg;

	assert(needsFrame);
	/* begin genLoadLiteralVariable:in: */
	_association = getLiteral(_litVarIndex);
	{
		voidReceiverResultRegContainsSelf();
	}
	/* begin ssAllocateRequiredReg: */
	ssAllocateRequiredRegMaskupThrough(1U << ReceiverResultReg, simStackPtr);
	/* end ssAllocateRequiredReg: */
	/* begin genMoveConstant:R: */
	if (shouldAnnotateObjectReference(_association)) {
		annotateobjRef(gMoveCwR(_association, ReceiverResultReg), _association);
	} else {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(MoveCqR, _association, ReceiverResultReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_association));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* end genMoveConstant:R: */
	genEnsureObjInRegNotForwardedscratchReg(ReceiverResultReg, TempReg);
	/* end genLoadLiteralVariable:in: */
	/* begin genGenericStorePop:slotIndex:destReg:needsStoreCheck:needsRestoreRcvr:needsImmutabilityCheck: */
	
#  if IMMUTABILITY
	{
		if (_needsImmCheck) {
			/* begin ssAllocateRequiredReg:upThrough: */
			ssAllocateRequiredRegMaskupThrough(1U << ClassReg, simStackPtr - 1);
			/* end ssAllocateRequiredReg:upThrough: */
			ssStoreAndReplacePoptoReg(_popBoolean, ClassReg);
			ssFlushStack();
			return genStoreWithImmutabilityCheckSourceRegslotIndexdestRegscratchRegneedsStoreCheckneedRestoreRcvr(ClassReg, ValueIndex, ReceiverResultReg, TempReg, _needsStoreCheck, 0);
		}
	}
#  endif /* IMMUTABILITY */
	_topReg = allocateRegForStackEntryAtnotConflictingWith(0, 1U << ReceiverResultReg);
	ssPopandCopyReg(_popBoolean, _topReg);
	return genStoreSourceRegslotIndexdestRegscratchReginFrameneedsStoreCheck(_topReg, ValueIndex, ReceiverResultReg, TempReg, needsFrame, _needsStoreCheck);
	/* end genGenericStorePop:slotIndex:destReg:needsStoreCheck:needsRestoreRcvr:needsImmutabilityCheck: */
}
/*	The reason we need a frame here is that assigning to an inst var of a 
	context may 
	involve wholesale reorganization of stack pages, and the only way to 
	preserve the 
	execution state of an activation in that case is if it has a frame. */
/* StackToRegisterMappingCogit>>#genStorePop:MaybeContextReceiverVariable:needsStoreCheck:needsImmutabilityCheck: */
static sqInt NoDbgRegParms
genStorePopMaybeContextReceiverVariableneedsStoreCheckneedsImmutabilityCheck(sqInt _popBoolean, sqInt _slotIndex, sqInt _needsStoreCheck, sqInt _needsImmCheck)
{
	AbstractInstruction *_abstractInstruction;
	AbstractInstruction *_abstractInstruction2;
	AbstractInstruction *_abstractInstruction3;
	AbstractInstruction *_abstractInstruction4;
	AbstractInstruction *_anInstruction;
	AbstractInstruction *_anInstruction2;
	AbstractInstruction *_immutabilityFailure;
	AbstractInstruction *_mutableJump;

	_immutabilityFailure = ((AbstractInstruction *) 0 );
	assert(needsFrame);
	ssFlushUpThroughReceiverVariable(_slotIndex);
	ensureReceiverResultRegContainsSelf();
	/* begin genGenericStorePop:MaybeContextSlotIndex:needsStoreCheck:needsRestoreRcvr:needsImmutabilityCheck: */
	assert(needsFrame);
	/* begin ssAllocateCallReg: */
	ssAllocateRequiredRegMaskupThrough(CallerSavedRegisterMask | (1U << SendNumArgsReg), simStackPtr);
	/* end ssAllocateCallReg: */
	/* begin ssAllocateCallReg:upThrough: */
	ssAllocateRequiredRegMaskupThrough(CallerSavedRegisterMask | (1U << ClassReg), simStackPtr - 1);
	/* end ssAllocateCallReg:upThrough: */
	ssStoreAndReplacePoptoReg(_popBoolean, ClassReg);
	ssFlushStack();
	
#  if IMMUTABILITY
	{
		if (_needsImmCheck) {
			_mutableJump = genJumpMutablescratchReg(ReceiverResultReg, TempReg);
			/* begin genStoreTrampolineCall: */
			assert(IMMUTABILITY);
			if (_slotIndex >= (NumStoreTrampolines - 1)) {
				/* begin checkQuickConstant:forInstruction: */
				_anInstruction = genoperandoperand(MoveCqR, _slotIndex, TempReg);
				if (usesOutOfLineLiteral(_anInstruction)) {
					(_anInstruction->dependent = locateLiteral(_slotIndex));
				}
				/* end checkQuickConstant:forInstruction: */
				/* begin CallRT: */
				/* begin annotateCall: */
				_abstractInstruction4 = genoperand(Call, ceStoreTrampolines[NumStoreTrampolines - 1]);
				(_abstractInstruction4->annotation = IsRelativeCall);
				/* end annotateCall: */
				/* end CallRT: */
			} else {
				/* begin CallRT: */
				/* begin annotateCall: */
				_abstractInstruction2 = genoperand(Call, ceStoreTrampolines[_slotIndex]);
				(_abstractInstruction2->annotation = IsRelativeCall);
				/* end annotateCall: */
				/* end CallRT: */
			}
			/* begin annotateBytecode: */
			_abstractInstruction3 = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
			(_abstractInstruction3->annotation = HasBytecodePC);
			/* end annotateBytecode: */
			/* end genStoreTrampolineCall: */
			{
				/* begin putSelfInReceiverResultReg */
				copyToReg(simSelf(), ReceiverResultReg);
				/* end putSelfInReceiverResultReg */
			}
			/* begin Jump: */
			_immutabilityFailure = genoperand(Jump, ((sqInt) 0 ));
			/* end Jump: */
			jmpTarget(_mutableJump, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
		}
	}
#  endif /* IMMUTABILITY */
	genLoadSlotsourceRegdestReg(SenderIndex, ReceiverResultReg, TempReg);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction2 = genoperandoperand(MoveCqR, _slotIndex, SendNumArgsReg);
	if (usesOutOfLineLiteral(_anInstruction2)) {
		(_anInstruction2->dependent = locateLiteral(_slotIndex));
	}
	/* end checkQuickConstant:forInstruction: */
	/* begin CallRT: */
	/* begin annotateCall: */
	_abstractInstruction = genoperand(Call, ceStoreContextInstVarTrampoline);
	(_abstractInstruction->annotation = IsRelativeCall);
	/* end annotateCall: */
	/* end CallRT: */
	
#  if IMMUTABILITY
	{
		if (_needsImmCheck) {
			jmpTarget(_immutabilityFailure, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
		}
	}
#  endif /* IMMUTABILITY */
	return 0;
	/* end genGenericStorePop:MaybeContextSlotIndex:needsStoreCheck:needsRestoreRcvr:needsImmutabilityCheck: */
}
/* StackToRegisterMappingCogit>>#genStorePop:ReceiverVariable:needsStoreCheck:needsImmutabilityCheck: */
static sqInt NoDbgRegParms
genStorePopReceiverVariableneedsStoreCheckneedsImmutabilityCheck(sqInt _popBoolean, sqInt _slotIndex, sqInt _needsStoreCheck, sqInt _needsImmCheck)
{
	sqInt _needsImmCheck2;
	sqInt _needsStoreCheck2;
	signed char _topReg;

	ssFlushUpThroughReceiverVariable(_slotIndex);
	ensureReceiverResultRegContainsSelf();
	/* begin genGenericStorePop:slotIndex:destReg:needsStoreCheck:needsRestoreRcvr:needsImmutabilityCheck: */
	_needsStoreCheck2 = !useTwoPaths && _needsStoreCheck;
	_needsImmCheck2 = _needsImmCheck && !useTwoPaths;
	
#  if IMMUTABILITY
	{
		if (_needsImmCheck2) {
			/* begin ssAllocateRequiredReg:upThrough: */
			ssAllocateRequiredRegMaskupThrough(1U << ClassReg, simStackPtr - 1);
			/* end ssAllocateRequiredReg:upThrough: */
			ssStoreAndReplacePoptoReg(_popBoolean, ClassReg);
			ssFlushStack();
			return genStoreWithImmutabilityCheckSourceRegslotIndexdestRegscratchRegneedsStoreCheckneedRestoreRcvr(ClassReg, _slotIndex, ReceiverResultReg, TempReg, _needsStoreCheck2, 1);
		}
	}
#  endif /* IMMUTABILITY */
	_topReg = allocateRegForStackEntryAtnotConflictingWith(0, 1U << ReceiverResultReg);
	ssPopandCopyReg(_popBoolean, _topReg);
	return genStoreSourceRegslotIndexdestRegscratchReginFrameneedsStoreCheck(_topReg, _slotIndex, ReceiverResultReg, TempReg, needsFrame, _needsStoreCheck2);
	/* end genGenericStorePop:slotIndex:destReg:needsStoreCheck:needsRestoreRcvr:needsImmutabilityCheck: */
}
/*	The only reason we assert needsFrame here is that in a frameless method 
	ReceiverResultReg must and does contain only self, but the ceStoreCheck 
	trampoline expects the target of the store to be in ReceiverResultReg. So 
	in a frameless method we would have a conflict between the receiver and 
	the temote temp store, unless we we smart enough to realise that 
	ReceiverResultReg was unused after the literal variable store, unlikely 
	given that methods return self by default. */
/* StackToRegisterMappingCogit>>#genStorePop:RemoteTemp:At:needsStoreCheck: */
static sqInt NoDbgRegParms
genStorePopRemoteTempAtneedsStoreCheck(sqInt _popBoolean, sqInt _slotIndex, sqInt _remoteTempIndex, sqInt _needsStoreCheck)
{
	AbstractInstruction *_anInstruction;
	sqInt _offset;
	signed char _topReg;

	assert(needsFrame);
	/* begin ssAllocateRequiredReg: */
	ssAllocateRequiredRegMaskupThrough(1U << ReceiverResultReg, simStackPtr);
	/* end ssAllocateRequiredReg: */
	voidReceiverResultRegContainsSelf();
	/* begin MoveMw:r:R: */
	_offset = frameOffsetOfTemporary(_remoteTempIndex);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveMwrR, _offset, FPReg, ReceiverResultReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_offset));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end MoveMw:r:R: */
	/* begin genGenericStorePop:slotIndex:destReg:needsStoreCheck:needsRestoreRcvr:needsImmutabilityCheck: */
	
#  if IMMUTABILITY
	{
	}
#  endif /* IMMUTABILITY */
	_topReg = allocateRegForStackEntryAtnotConflictingWith(0, 1U << ReceiverResultReg);
	ssPopandCopyReg(_popBoolean, _topReg);
	return genStoreSourceRegslotIndexdestRegscratchReginFrameneedsStoreCheck(_topReg, _slotIndex, ReceiverResultReg, TempReg, needsFrame, _needsStoreCheck);
	/* end genGenericStorePop:slotIndex:destReg:needsStoreCheck:needsRestoreRcvr:needsImmutabilityCheck: */
}
/* StackToRegisterMappingCogit>>#genStorePop:TemporaryVariable: */
static sqInt NoDbgRegParms
genStorePopTemporaryVariable(sqInt _popBoolean, sqInt _tempIndex)
{
	AbstractInstruction *_anInstruction;
	sqInt _offset;
	sqInt _reg;

	ssFlushUpThroughTemporaryVariable(_tempIndex);
	_reg = ssStorePoptoPreferredReg(_popBoolean, TempReg);
	/* begin MoveR:Mw:r: */
	_offset = frameOffsetOfTemporary(_tempIndex);
	/* begin checkQuickConstant:forInstruction: */
	_anInstruction = genoperandoperandoperand(MoveRMwr, _reg, _offset, FPReg);
	if (usesOutOfLineLiteral(_anInstruction)) {
		(_anInstruction->dependent = locateLiteral(_offset));
	}
	/* end checkQuickConstant:forInstruction: */
	/* end MoveR:Mw:r: */
	((simStackAt(_tempIndex + 1))->bcptr = bytecodePC);
	return 0;
}
/* StackToRegisterMappingCogit>>#genSubFloat64Vector */

#if FEATURE_JIT_SIMD
static sqInt
genSubFloat64Vector(void)
{
	signed char _array1Reg;
	signed char _array2Reg;
	sqInt _subReg;

	_array1Reg = allocateVectorRegForStackEntryAtnotConflictingWith(0, 0);
	_array2Reg = allocateVectorRegForStackEntryAtnotConflictingWith(1, 1ULL << _array1Reg);
	_subReg = _array2Reg;
	ssPopTopToVectorReg(_array1Reg);
	ssPopTopToVectorReg(_array2Reg);
	gFsubSRvRvRv(64, _array2Reg, _array1Reg, _subReg);
	ssPushVectorRegister(_subReg);
	return 0;
}
#endif /* FEATURE_JIT_SIMD */
/*	Generate a method return from within a method or a block. 
	Frameless method activation looks like 
	CISCs (x86): 
	receiver 
	args 
	sp->	ret pc. 
	RISCs (ARM): 
	receiver 
	args 
	ret pc in LR. 
	A fully framed activation is described in CoInterpreter 
	class>initializeFrameIndices. Return pops receiver and arguments off the 
	stack. Callee pushes the result. */
/* StackToRegisterMappingCogit>>#genUpArrowReturn */
static sqInt
genUpArrowReturn(void)
{
	AbstractInstruction *_abstractInstruction;
	AbstractInstruction *_abstractInstruction2;
	sqInt _offset;

	deadCode = 1;
	if (inBlock > 0) {
		assert(needsFrame);
		ssFlushStack();
		/* begin CallRT: */
		/* begin annotateCall: */
		_abstractInstruction = genoperand(Call, ceNonLocalReturnTrampoline);
		(_abstractInstruction->annotation = IsRelativeCall);
		/* end annotateCall: */
		/* end CallRT: */
		/* begin annotateBytecode: */
		_abstractInstruction2 = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
		(_abstractInstruction2->annotation = HasBytecodePC);
		/* end annotateBytecode: */
		return 0;
	}
	if (
#    if IMMUTABILITY
			needsFrame && !useTwoPaths
#    else /* IMMUTABILITY */
			needsFrame
#    endif /* IMMUTABILITY */
			) {
		/* begin MoveR:R: */
		genoperandoperand(MoveRR, FPReg, SPReg);
		/* end MoveR:R: */
		/* begin PopR: */
		genoperand(PopR, FPReg);
		/* end PopR: */
		{
			/* begin PopR: */
			genoperand(PopR, LinkReg);
			/* end PopR: */
		}
		/* begin RetN: */
		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
		/* end RetN: */
	} else {
		/* begin RetN: */
		_offset = (((methodOrBlockNumArgs > 2) || regArgsHaveBeenPushed)
			 ? (methodOrBlockNumArgs + 1) * BytesPerWord
			 : 0);
		genoperand(RetN, _offset);
		/* end RetN: */
	}
	return 0;
}
/* StackToRegisterMappingCogit>>#initSimStackForFramefulMethod: */
static void NoDbgRegParms
initSimStackForFramefulMethod(sqInt _startpc)
{
	CogSimStackEntry * cascade0;
	CogSimStackEntry *_desc;
	sqInt _i;

	simStackPtr = methodOrBlockNumTemps;
	simSpillBase = methodOrBlockNumTemps + 1;
	{
		cascade0 = simSelf();
		(cascade0->type = SSBaseOffset);
		(cascade0->spilled = 1);
		(cascade0->registerr = FPReg);
		(cascade0->offset = FoxMFReceiver);
		(cascade0->liveRegister = NoReg);
	}
	for (_i = 1; _i <= methodOrBlockNumArgs; _i += 1) {
		_desc = simStackAt(_i);
		{
			(_desc->type = SSBaseOffset);
			(_desc->spilled = 1);
			(_desc->registerr = FPReg);
			(_desc->offset = FoxCallerSavedIP + (((methodOrBlockNumArgs - _i) + 1) * BytesPerWord));
			(_desc->bcptr = _startpc);
		}
	}
	for (_i = methodOrBlockNumArgs + 1; _i <= simStackPtr; _i += 1) {
		_desc = simStackAt(_i);
		{
			(_desc->type = SSBaseOffset);
			(_desc->spilled = 1);
			(_desc->registerr = FPReg);
			(_desc->offset = FoxMFReceiver - ((_i - methodOrBlockNumArgs) * BytesPerWord));
			(_desc->bcptr = _startpc);
		}
	}
}
/*	The register receiver (the closure itself) and args are pushed by the 
	closure value primitive(s) 
	and hence a frameless block has all arguments and copied values pushed to 
	the stack. However, 
	the method receiver (self) is put in the ReceiverResultReg by the block 
	entry.  */
/* StackToRegisterMappingCogit>>#initSimStackForFramelessBlock: */
static void NoDbgRegParms
initSimStackForFramelessBlock(sqInt _startpc)
{
	CogSimStackEntry * cascade0;
	CogSimStackEntry *_desc;
	sqInt _i;

	{
		cascade0 = simSelf();
		(cascade0->type = SSRegister);
		(cascade0->spilled = 0);
		(cascade0->registerr = ReceiverResultReg);
		(cascade0->liveRegister = ReceiverResultReg);
	}
	assert(methodOrBlockNumTemps >= methodOrBlockNumArgs);
	for (_i = 1; _i <= methodOrBlockNumTemps; _i += 1) {
		_desc = simStackAt(_i);
		{
			(_desc->type = SSBaseOffset);
			(_desc->spilled = 1);
			(_desc->registerr = SPReg);
			(_desc->offset = (methodOrBlockNumArgs - _i) * BytesPerWord);
			(_desc->bcptr = _startpc);
		}
	}
	simStackPtr = methodOrBlockNumTemps;
	simSpillBase = methodOrBlockNumTemps + 1;
}
/* StackToRegisterMappingCogit>>#initSimStackForFramelessMethod: */
static void NoDbgRegParms
initSimStackForFramelessMethod(sqInt _startpc)
{
	CogSimStackEntry * cascade0;
	CogSimStackEntry *_desc;
	sqInt _i;

	{
		cascade0 = simSelf();
		(cascade0->type = SSRegister);
		(cascade0->spilled = 0);
		(cascade0->registerr = ReceiverResultReg);
		(cascade0->liveRegister = ReceiverResultReg);
	}
	assert(methodOrBlockNumTemps == methodOrBlockNumArgs);
	assert((numRegArgs()) <= 2);
	if ((methodOrBlockNumArgs >= 1) && (methodOrBlockNumArgs <= 2)) {
		_desc = simStackAt(1);
		{
			(_desc->type = SSRegister);
			(_desc->spilled = 0);
			(_desc->registerr = Arg0Reg);
			(_desc->bcptr = _startpc);
		}
		if (methodOrBlockNumArgs > 1) {
			_desc = simStackAt(2);
			{
				(_desc->type = SSRegister);
				(_desc->spilled = 0);
				(_desc->registerr = Arg1Reg);
				(_desc->bcptr = _startpc);
			}
		}
	} else {
		for (_i = 1; _i <= methodOrBlockNumArgs; _i += 1) {
			_desc = simStackAt(_i);
			{
				(_desc->type = SSBaseOffset);
				(_desc->registerr = SPReg);
				(_desc->spilled = 1);
				(_desc->offset = (methodOrBlockNumArgs - _i) * BytesPerWord);
				(_desc->bcptr = _startpc);
			}
		}
	}
	simStackPtr = methodOrBlockNumArgs;
	simSpillBase = methodOrBlockNumArgs + 1;
}
/* StackToRegisterMappingCogit>>#liveRegisters */
static sqInt
liveRegisters(void)
{
	sqInt _i;
	sqInt _regsSet;

	if (needsFrame) {
		_regsSet = 0;
	} else {
		/* begin registerMaskFor: */
		_regsSet = 1U << ReceiverResultReg;
		/* end registerMaskFor: */
		if ((methodOrBlockNumArgs <= 2) && (methodOrBlockNumArgs > 0)) {
			_regsSet = _regsSet | (1U << Arg0Reg);
			if (methodOrBlockNumArgs > 1) {
				_regsSet = _regsSet | (1U << Arg1Reg);
			}
		}
	}
	for (_i = ((simSpillBase < 0) ? 0 : simSpillBase); _i <= simStackPtr; _i += 1) {
		_regsSet = _regsSet | (registerMask(simStackAt(_i)));
	}
	return _regsSet;
}
/* StackToRegisterMappingCogit>>#liveVectorRegisters */
static sqInt
liveVectorRegisters(void)
{
	sqInt _i;
	int _regsSet;
	CogSimStackEntry * _ssEntry;

	_regsSet = 0;
	for (_i = ((simSpillBase < 0) ? 0 : simSpillBase); _i <= simStackPtr; _i += 1) {
		_ssEntry = simStackAt(_i);
		if (((_ssEntry->type)) == SSVectorRegister) {
			_regsSet = _regsSet | (registerMask(_ssEntry));
		}
	}
	return _regsSet;
}
/*	insert nops for dead code that is mapped so that bc  
	to mc mapping is not many to one */
/* StackToRegisterMappingCogit>>#mapDeadDescriptorIfNeeded: */
static sqInt NoDbgRegParms
mapDeadDescriptorIfNeeded(BytecodeDescriptor *_descriptor)
{
	AbstractInstruction *_abstractInstruction;

	flag("annotateInstruction");
	if (((_descriptor->isMapped)) || ((inBlock > 0) && ((_descriptor->isMappedInBlock)))) {
		/* begin annotateBytecode: */
		_abstractInstruction = gen(Nop);
		(_abstractInstruction->annotation = HasBytecodePC);
		/* end annotateBytecode: */
	}
	return 0;
}
/*	Spill everything on the simulated stack that needs spilling (that below 
	receiver and arguments). 
	Marshall receiver and arguments to stack and/or registers depending on arg 
	count. If the args don't fit in registers push receiver and args (spill 
	everything), but still assign 
	the receiver to ReceiverResultReg. */
/* StackToRegisterMappingCogit>>#marshallSendArguments: */
static void NoDbgRegParms
marshallSendArguments(sqInt _numArgs)
{
	CogSimStackEntry * cascade0;
	sqInt _anyRefs;
	sqInt _numSpilled;

	ssFlushStackExceptTop(_numArgs + 1);
	if (_numArgs > 2) {
		_numSpilled = numberOfSpillsInTopNItems(_numArgs + 1);
		_anyRefs = anyReferencesToRegisterinTopNItems(ReceiverResultReg, _numArgs + 1);
		if ((_numSpilled > 0) || _anyRefs) {
			ssFlushStack();
			copyToReg(simStackAt(simStackPtr - _numArgs), ReceiverResultReg);
		} else {
			{
				cascade0 = simStackAt(simStackPtr - _numArgs);
				copyToReg(cascade0, ReceiverResultReg);
				(cascade0->type = SSRegister);
				(cascade0->registerr = ReceiverResultReg);
			}
			ssFlushStack();
		}
		{
			ssPoppopSpilled(_numArgs + 1, 0);
			return;
		}
	} else {
		if (_numArgs > 0) {
			if (_numArgs > 1) {
				/* begin ssAllocateRequiredReg:upThrough: */
				ssAllocateRequiredRegMaskupThrough(1U << Arg0Reg, simStackPtr - 2);
				/* end ssAllocateRequiredReg:upThrough: */
				/* begin ssAllocateRequiredReg:upThrough: */
				ssAllocateRequiredRegMaskupThrough(1U << Arg1Reg, simStackPtr - 1);
				/* end ssAllocateRequiredReg:upThrough: */
			} else {
				/* begin ssAllocateRequiredReg:upThrough: */
				ssAllocateRequiredRegMaskupThrough(1U << Arg0Reg, simStackPtr - 1);
				/* end ssAllocateRequiredReg:upThrough: */
			}
		}
		if (_numArgs > 1) {
			copyToReg(simStackAt(simStackPtr), Arg1Reg);
		}
		if (_numArgs > 0) {
			copyToReg(simStackAt((simStackPtr - _numArgs) + 1), Arg0Reg);
		}
		copyToReg(simStackAt(simStackPtr - _numArgs), ReceiverResultReg);
		ssPop(_numArgs + 1);
	}
}
/*	If this bytecode has a fixup, some kind of merge needs to be done. There 
	are 4 cases: 
	1) the bytecode has no fixup (fixup isNotAFixup) 
	do nothing 
	2) the bytecode has a non merge fixup 
	the fixup has needsNonMergeFixup. 
	The code generating non merge fixup (currently only special selector code) 
	is responsible 
	for the merge so no need to do it. 
	We set deadCode to false as the instruction can be reached from jumps. 
	3) the bytecode has a merge fixup, but execution flow *cannot* fall 
	through to the merge point. 
	the fixup has needsMergeFixup and deadCode = true. 
	ignores the current simStack as it does not mean anything  
	restores the simStack to the state the jumps to the merge point expects it 
	to be. 
	4) the bytecode has a merge fixup and execution flow *can* fall through to 
	the merge point. 
	the fixup has needsMergeFixup and deadCode = false. 
	flushes the stack to the stack pointer so the fall through execution path 
	simStack is  
	in the state the merge point expects it to be.  
	restores the simStack to the state the jumps to the merge point expects it 
	to be. 
	 
	In addition, if this is a backjump merge point, we patch the fixup to hold 
	the current simStackPtr  
	for later assertions. */
/* StackToRegisterMappingCogit>>#mergeWithFixupIfRequired: */
static sqInt NoDbgRegParms
mergeWithFixupIfRequired(BytecodeFixup *_fixup)
{
	CogSimStackEntry * cascade0;
	sqInt _i;

	/* begin assertCorrectSimStackPtr */
	assert(simSpillBase >= methodOrBlockNumTemps);
	if (needsFrame && (simSpillBase > 0)) {
		assert((((simStackAt(simSpillBase - 1))->spilled)) == 1);
		assert((simSpillBase > simStackPtr) || ((((simStackAt(simSpillBase))->spilled)) == 0));
	}
	/* end assertCorrectSimStackPtr */
	if (((_fixup->targetInstruction)) == 0) {
		return 0;
	}
	if (((usqInt) ((_fixup->targetInstruction)) ) == NeedsNonMergeFixupFlag) {
		deadCode = 0;
		return 0;
	}
	assert(isMergeFixup(_fixup));
	if (deadCode) {
		assert(((_fixup->simStackPtr)) >= methodOrBlockNumTemps);
		simStackPtr = (_fixup->simStackPtr);
	} else {
		ssFlushStack();
	}
	deadCode = 0;
	if ((_fixup->isTargetOfBackwardBranch)) {
		(_fixup->simStackPtr = simStackPtr);
	}
	(_fixup->targetInstruction = genoperandoperand(Label, (labelCounter += 1), bytecodePC));
	assert(simStackPtr == ((_fixup->simStackPtr)));
	/* begin restoreSimStackAtMergePoint: */
	/* begin voidReceiverOptStatus */
	((simSelf())->liveRegister = NoReg);
	/* end voidReceiverOptStatus */
	for (_i = methodOrBlockNumTemps + 1; _i <= simStackPtr; _i += 1) {
		cascade0 = simStackAt(_i);
		(cascade0->type = SSSpill);
		(cascade0->offset = FoxMFReceiver - ((_i - methodOrBlockNumArgs) * BytesPerOop));
		(cascade0->registerr = FPReg);
		(cascade0->spilled = 1);
	}
	simSpillBase = simStackPtr + 1;
	/* end restoreSimStackAtMergePoint: */
	return 0;
}
/* StackToRegisterMappingCogit>>#methodAbortTrampolineFor: */
static sqInt NoDbgRegParms
methodAbortTrampolineFor(sqInt _numArgs)
{
	return methodAbortTrampolines[((_numArgs < (2 + 1)) ? _numArgs : 2 + 1)];
}
/*	This is a hook for subclasses to filter out methods they can't deal with.Frameless methods with local temporaries cause problems, 
	mostly in asserts, and yet they matter not at all for performance. 
	Shun them. */
/* StackToRegisterMappingCogit>>#methodFoundInvalidPostScan */
static sqInt
methodFoundInvalidPostScan(void)
{
	if (!needsFrame) {
		return methodOrBlockNumTemps > methodOrBlockNumArgs;
	}
	{
		return 0;
	}
	return 0;
}
/* StackToRegisterMappingCogit>>#needsFrameIfMod16GENumArgs: */
static sqInt NoDbgRegParms
needsFrameIfMod16GENumArgs(sqInt stackDelta)
{
	return (byte0 % 16) >= methodOrBlockNumArgs;
}
/*	As of August 2013, the code generator can't deal with spills in frameless 
	methods (the 
	issue is to do with the stack offset to get at an argument, which is 
	changed when there's a spill). 
	In e.g. TextColor>>#dominates: other ^other class == self class the second 
	send of class 
	needs also rto allocate a register that the first one used, but the first 
	one's register can't be 
	spilled. So avoid this by only allowing class to be sent if the stack 
	contains a single element. */
/* StackToRegisterMappingCogit>>#needsFrameIfStackGreaterThanOne: */
static sqInt NoDbgRegParms
needsFrameIfStackGreaterThanOne(sqInt _stackDelta)
{
	return _stackDelta > 1;
}
/* StackToRegisterMappingCogit>>#numberOfSpillsInTopNItems: */
static sqInt NoDbgRegParms
numberOfSpillsInTopNItems(sqInt _n)
{
	sqInt _i;

	for (_i = simStackPtr; _i >= ((simStackPtr - _n) + 1); _i += -1) {
		if ((((simStackAt(_i))->type)) == SSSpill) {
			return _n - (simStackPtr - _i);
		}
	}
	return 0;
}
/* StackToRegisterMappingCogit>>#picAbortTrampolineFor: */
static sqInt NoDbgRegParms
picAbortTrampolineFor(sqInt _numArgs)
{
	return picAbortTrampolines[((_numArgs < (2 + 1)) ? _numArgs : 2 + 1)];
}
/*	Populate tuple (which must be large enough) with the ClosedPIC's target 
	method class pairs. 
	The first entry in tuple contains the bytecode pc for the send, so skip 
	the tuple's first field. */
/* StackToRegisterMappingCogit>>#populate:withPICInfoFor:firstCacheTag: */
static void NoDbgRegParms
populatewithPICInfoForfirstCacheTag(sqInt _tuple, CogMethod *_cPIC, sqInt _firstCacheTag)
{
	sqInt _cacheTag;
	sqInt _classOop;
	sqInt _entryPoint;
	sqInt _followingAddress;
	sqInt _i;
	sqInt _picCaseMachineCodePC;
	CogMethod *_targetMethod;
	sqInt _value;

	for (_i = 1; _i <= ((_cPIC->cPICNumCases)); _i += 1) {
		_picCaseMachineCodePC = addressOfEndOfCaseinCPIC(_i, _cPIC);
		if (_i == 1) {
			_cacheTag = _firstCacheTag;
		} else {
			/* begin literal32BeforeFollowingAddress: */
			_followingAddress = _picCaseMachineCodePC - (jumpLongConditionalByteSize(backEnd));
			_cacheTag = literalBeforeFollowingAddress(((AbstractInstruction *) backEnd ), _followingAddress);
			/* end literal32BeforeFollowingAddress: */
		}
		_classOop = classForInlineCacheTag(_cacheTag);
		storePointerofObjectwithValue((_i * 2) - 1, _tuple, _classOop);
		if (_i == 1) {
			_entryPoint = jumpLongTargetBeforeFollowingAddress(backEnd, _picCaseMachineCodePC);
		} else {
			/* begin jumpLongConditionalTargetBeforeFollowingAddress: */
			_entryPoint = jumpLongTargetBeforeFollowingAddress(((AbstractInstruction *) backEnd ), _picCaseMachineCodePC);
			/* end jumpLongConditionalTargetBeforeFollowingAddress: */
		}
		if ((((usqInt) _cPIC ) <= ((usqInt) _entryPoint )) && ((((usqInt) _cPIC ) + ((_cPIC->blockSize))) >= ((usqInt) _entryPoint ))) {
			_value = splObj(SelectorDoesNotUnderstand);
		} else {
			_targetMethod = ((CogMethod *) (_entryPoint - cmNoCheckEntryOffset) );
			assert(((_targetMethod->cmType)) == CMMethod);
			_value = (_targetMethod->methodObject);
		}
		storePointerofObjectwithValue(_i * 2, _tuple, _value);
	}
}
/* StackToRegisterMappingCogit>>#prevInstIsPCAnnotated */
static sqInt
prevInstIsPCAnnotated(void)
{
	sqInt _prevIndex;
	AbstractInstruction *_prevInst;

	if (!(opcodeIndex > 0)) {
		return 0;
	}
	_prevIndex = opcodeIndex - 1;
	while (1) {
		if (_prevIndex <= 0) {
			return 0;
		}
		_prevInst = abstractInstructionAt(_prevIndex);
		if (isPCMappedAnnotation(((!((_prevInst->annotation)))
			 ? 0
			 : (_prevInst->annotation)))) {
			return 1;
		}
		if (!(((_prevInst->opcode)) == Label)) 
			break;
		_prevIndex -= 1;
	}
	return 0;
}
/*	Undefined by now, do nothing */
/* StackToRegisterMappingCogit>>#profilingDataForCounter:at: */
static sqInt NoDbgRegParms
profilingDataForCounterat(sqInt counter, sqInt bcpc)
{
	return 0;
}
/*	Answer a tuple with the send data for a linked send to cogMethod. 
	If the target is a CogMethod (monomorphic send) answer 
	{ bytecode pc, inline cache class, target method } 
	If the target is an open PIC (megamorphic send) answer 
	{ bytecode pc, nil, send selector } 
	If the target is a closed PIC (polymorphic send) answer 
	{ bytecode pc, first class, target method, second class, second target 
	method, ... } */
/* StackToRegisterMappingCogit>>#profilingDataForSendTo:methodClassIfSuper:at:bcpc: */
static sqInt NoDbgRegParms
profilingDataForSendTomethodClassIfSuperatbcpc(CogMethod *_cogCodeSendTarget, sqInt _methodClassOrNil, char *_sendMcpc, sqInt _sendBcpc)
{
	sqInt _class;
	sqInt _tuple;

	_tuple = eeInstantiateClassIndexformatnumSlots(ClassArrayCompactIndex, arrayFormat(), ((((_cogCodeSendTarget->cmType)) == CMPolymorphicIC)
		 ? (2 * ((_cogCodeSendTarget->cPICNumCases))) + 1
		 : 3));
	if (_tuple == 0) {
		return 0;
	}
	storePointerUncheckedofObjectwithValue(0, _tuple, ((((usqInt) _sendBcpc ) << 3) | 1));
	if (((_cogCodeSendTarget->cmType)) == CMMethod) {
		_class = ((!_methodClassOrNil)
			 ? classForInlineCacheTag(inlineCacheTagAt(backEnd, ((usqInt) _sendMcpc )))
			 : _methodClassOrNil);
		{
			storePointerofObjectwithValue(1, _tuple, _class);
			storePointerofObjectwithValue(2, _tuple, (_cogCodeSendTarget->methodObject));
		}
		return _tuple;
	}
	if (((_cogCodeSendTarget->cmType)) == CMPolymorphicIC) {
		populatewithPICInfoForfirstCacheTag(_tuple, _cogCodeSendTarget, inlineCacheTagAt(backEnd, ((usqInt) _sendMcpc )));
		return _tuple;
	}
	if (((_cogCodeSendTarget->cmType)) == CMMegamorphicIC) {
		{
			storePointerUncheckedofObjectwithValue(1, _tuple, nilObject());
			storePointerofObjectwithValue(2, _tuple, (_cogCodeSendTarget->selector));
		}
		return _tuple;
	}
	error("invalid method type");
	return 0;
}
/*	N.B. Counters are always 32-bits, having two 16-bit halves for the reached 
	and taken counts. */
/* StackToRegisterMappingCogit>>#profilingDataFor:Annotation:Mcpc:Bcpc:Method: */
static sqInt NoDbgRegParms
profilingDataForAnnotationMcpcBcpcMethod(BytecodeDescriptor *_descriptor, sqInt _isBackwardBranchAndAnnotation, char *_mcpc, sqInt _bcpc, void *_cogMethodArg)
{
	sqInt _annotation;
	sqInt _association;
	unsigned int _counter;
	usqInt * _counters;
	sqInt _entryPoint;
	sqInt _methodClassIfSuper;
	sqInt _offset2;
	sqInt *_sendTable2;
	CogMethod * _targetCogCode2;
	sqInt _tuple;

	if (!_descriptor) {
		return 0;
	}
	if (isBranch(_descriptor)) {
		if (((_descriptor->isBranchTrue)) || ((_descriptor->isBranchFalse))) {
			_counters = ((usqInt *) 0 );
			if (_counters == 0) {
				return 0;
			}
			_counter = _counters[counterIndex];
			_tuple = profilingDataForCounterat(_counter, _bcpc + 1);
			if (_tuple == 0) {
				return PrimErrNoMemory;
			}
			storePointerofObjectwithValue(introspectionDataIndex, introspectionData, _tuple);
			introspectionDataIndex += 1;
			counterIndex += 1;
		}
		return 0;
	}
	_annotation = ((usqInt) _isBackwardBranchAndAnnotation ) >> 1;
	if (!((_annotation >= IsSendCall) && (((_entryPoint = callTargetFromReturnAddress(backEnd, ((usqInt) _mcpc ))), _entryPoint > methodZoneBase)))) {
		return 0;
	}
	/* begin targetMethodAndSendTableFor:annotation:into: */
	/* begin offsetAndSendTableFor:annotation:into: */
	if (_annotation == IsSendCall) {
		_offset2 = cmEntryOffset;
		_sendTable2 = ordinarySendTrampolines;
	} else {
		if (_annotation == IsDirectedSuperSend) {
			_offset2 = cmNoCheckEntryOffset;
			_sendTable2 = directedSuperSendTrampolines;
		} else {
			if (_annotation == IsDirectedSuperBindingSend) {
				_offset2 = cmNoCheckEntryOffset;
				_sendTable2 = directedSuperBindingSendTrampolines;
			} else {
				assert(_annotation == IsSuperSend);
				_offset2 = cmNoCheckEntryOffset;
				_sendTable2 = superSendTrampolines;
			}
		}
	}
	{
		_targetCogCode2 = ((CogMethod *) (_entryPoint - _offset2) );
		{
			_methodClassIfSuper = null;
			if (_sendTable2 == superSendTrampolines) {
				_methodClassIfSuper = methodClassOf(((((CogMethod *) _cogMethodArg ))->methodObject));
			}
			if (_sendTable2 == directedSuperSendTrampolines) {
				_association = literalBeforeInlineCacheTagAt(backEnd, ((usqInt) _mcpc ));
				_methodClassIfSuper = valueOfAssociation(_association);
			}
			_tuple = profilingDataForSendTomethodClassIfSuperatbcpc(_targetCogCode2, _methodClassIfSuper, _mcpc, _bcpc + 1);
		}
	}
	/* end offsetAndSendTableFor:annotation:into: */
	/* end targetMethodAndSendTableFor:annotation:into: */
	if (_tuple == 0) {
		return PrimErrNoMemory;
	}
	storePointerofObjectwithValue(introspectionDataIndex, introspectionData, _tuple);
	introspectionDataIndex += 1;
	return 0;
}
/*	Collect the branch and send data for cogMethod, storing it into arrayObj.If the method is frameless, it has no message sends. No need to continue. */
/* StackToRegisterMappingCogit>>#profilingDataFor:into: */
sqInt
profilingDataForinto(CogMethod *_cogMethod, sqInt _arrayObj)
{
	sqInt _aMethodObj;
	sqInt _annotation;
	sqInt _bcpc;
	sqInt _byte;
	CogMethod *_cogMethod2;
	BytecodeDescriptor *_descriptor;
	sqInt _distance;
	sqInt _endbcpc;
	sqInt _errCode;
	CogMethod *_homeMethod;
	sqInt _isBackwardBranch;
	usqInt _isInBlock;
	sqInt _latestContinuation;
	usqInt _map;
	sqInt _mapByte;
	usqInt _mcpc;
	sqInt _nExts;
	sqInt _nextBcpc;
	sqInt _result;
	sqInt _startbcpc;
	sqInt _targetPC;

	if (((_cogMethod->stackCheckOffset)) == 0) {
		return 0;
	}
	introspectionDataIndex = (counterIndex = 0);
	introspectionData = _arrayObj;
	/* begin mapFor:bcpc:performUntil:arg: */
	_cogMethod2 = ((CogMethod *) _cogMethod );
	_startbcpc = startPCOfMethod((_cogMethod->methodObject));
	assert(((_cogMethod2->stackCheckOffset)) > 0);
	_mcpc = ((usqInt) _cogMethod2 ) + ((_cogMethod2->stackCheckOffset));
	_result = profilingDataForAnnotationMcpcBcpcMethod(null, 0 + ((sqInt) (((usqInt) HasBytecodePC ) << 1) ), ((char *) _mcpc ), _startbcpc, ((void *) _cogMethod ));
	if (_result != 0) {
		_errCode = _result;
		goto l3;
	}
	_bcpc = _startbcpc;
	_isInBlock = (_cogMethod2->cpicHasMNUCaseOrCMIsFullBlock);
	_homeMethod = ((CogMethod *) _cogMethod2 );
	assert(_startbcpc == (startPCOfMethodHeader((_homeMethod->methodHeader))));
	_map = (((usqInt) _homeMethod ) + ((_homeMethod->blockSize))) - 1;
	_annotation = ((usqInt) (byteAt(_map)) ) >> AnnotationShift;
	assert((_annotation == IsAbsPCReference) || ((_annotation == IsObjectReference) || ((_annotation == IsRelativeCall) || (_annotation == IsDisplacementX2N))));
	_latestContinuation = _startbcpc;
	_aMethodObj = (_homeMethod->methodObject);
	_endbcpc = (numBytesOf(_aMethodObj)) - 1;
	_bcpc += deltaToSkipPrimAndErrorStoreInheader(_aMethodObj, (_homeMethod->methodHeader));
	_nExts = 0;
	{
		enumeratingCogMethod = _homeMethod;
	}
	while ((((usqInt) (byteAt(_map)) ) >> AnnotationShift) != HasBytecodePC) {
		_map -= 1;
	}
	_map -= 1;
	while (((_mapByte = byteAt(_map))) != MapEnd) {
		if (_mapByte >= FirstAnnotation) {
			_annotation = ((usqInt) _mapByte ) >> AnnotationShift;
			_mcpc += (_mapByte & DisplacementMask) * 4;
			if (_annotation >= HasBytecodePC) {
				if ((_annotation == IsSendCall) && ((((usqInt) ((_mapByte = byteAt(_map - 1))) ) >> AnnotationShift) == IsAnnotationExtension)) {
					_annotation += _mapByte & DisplacementMask;
					_map -= 1;
				}
				while (1) {
					_byte = fetchByteofObject(_bcpc, _aMethodObj);
					_descriptor = generatorAt(_byte);
					if (_isInBlock) {
						if (_bcpc >= _endbcpc) {
							_errCode = 0;
							goto l3;
						}
					} else {
						if (((_descriptor->isReturn)) && (_bcpc >= _latestContinuation)) {
							_errCode = 0;
							goto l3;
						}
						if (isBranch(_descriptor)) {
							/* begin latestContinuationPCFor:at:exts:in: */
							_distance = ((_descriptor->spanFunction))(_descriptor, _bcpc, _nExts, _aMethodObj);
							_targetPC = (_bcpc + ((_descriptor->numBytes))) + (((_distance < 0) ? 0 : _distance));
							/* end latestContinuationPCFor:at:exts:in: */
							_latestContinuation = ((_latestContinuation < _targetPC) ? _targetPC : _latestContinuation);
						}
					}
					_nextBcpc = _bcpc + ((_descriptor->numBytes));
					if (((_descriptor->isMapped)) || (_isInBlock && ((_descriptor->isMappedInBlock)))) 
						break;
					_bcpc = _nextBcpc;
					_nExts = (((_descriptor->isExtension))
						 ? _nExts + 1
						 : 0);
				}
				_isBackwardBranch = (isBranch(_descriptor)) && ((assert(((_descriptor->spanFunction)) != null), (((_descriptor->spanFunction))(_descriptor, _bcpc, _nExts, _aMethodObj)) < 0));
				_result = profilingDataForAnnotationMcpcBcpcMethod(_descriptor, ((_isBackwardBranch)
					 ? ((sqInt) (((usqInt) _annotation ) << 1) ) + 1
					 : ((sqInt) (((usqInt) _annotation ) << 1) )), ((char *) _mcpc ), ((_isBackwardBranch)
					 ? _bcpc - (2 * _nExts)
					 : _bcpc), ((void *) _cogMethod ));
				if (_result != 0) {
					_errCode = _result;
					goto l3;
				}
				_bcpc = _nextBcpc;
				_nExts = (((_descriptor->isExtension))
					 ? _nExts + 1
					 : 0);
			}
		} else {
			assert(((((usqInt) _mapByte ) >> AnnotationShift) == IsDisplacementX2N) || ((((usqInt) _mapByte ) >> AnnotationShift) == IsAnnotationExtension));
			if (_mapByte < ((sqInt) (((usqInt) IsAnnotationExtension ) << AnnotationShift) )) {
				_mcpc += ((sqInt) (((usqInt) (_mapByte - DisplacementX2N) ) << AnnotationShift) ) * 4;
			}
		}
		_map -= 1;
	}
	_errCode = 0;
	l3:
	;
	/* end mapFor:bcpc:performUntil:arg: */
	if (_errCode != 0) {
		assert(_errCode == PrimErrNoMemory);
		return -1;
	}
	return introspectionDataIndex;
}
/*	Used to mark ReceiverResultReg as dead or not containing simSelf. 
	Used when the simStack has already been flushed, e.g. for sends. */
/* StackToRegisterMappingCogit>>#receiverIsInReceiverResultReg */
static sqInt
receiverIsInReceiverResultReg(void)
{
	return (((simSelf())->liveRegister)) == ReceiverResultReg;
}
/*	Scan the method (and all embedded blocks) to determine 
	- what the last bytecode is; extra bytes at the end of a method are used 
	to encode things like source pointers or temp names 
	- if the method needs a frame or not 
	- what are the targets of any backward branches */
/* StackToRegisterMappingCogit>>#scanMethod */
static sqInt
scanMethod(void)
{
	BytecodeDescriptor *_descriptor;
	sqInt _distance;
	BytecodeFixup * _fixup;
	sqInt _framelessStackDelta;
	sqInt _latestContinuation;
	sqInt _nExts;
	sqInt _pc;
	int _seenInstVarStore;
	sqInt _targetPC;

	needsFrame = (useTwoPaths = (_seenInstVarStore = 0));
	if ((primitiveIndex > 0) && (isQuickPrimitiveIndex(primitiveIndex))) {
		return 0;
	}
	_pc = (_latestContinuation = initialPC);
	_framelessStackDelta = (_nExts = (extA = (numExtB = (extB = 0))));
	while (_pc <= endPC) {
		byte0 = fetchByteofObject(_pc, methodObj);
		_descriptor = generatorAt(byte0);
		if ((_descriptor->isExtension)) {
			if (((_descriptor->opcode)) == Nop) {
				return EncounteredUnknownBytecode;
			}
			loadSubsequentBytesForDescriptorat(_descriptor, _pc);
			((_descriptor->generator))();
		}
		if (((_descriptor->isReturn)) && (_pc >= _latestContinuation)) {
			endPC = _pc;
		}
		if (!needsFrame) {
			if ((((_descriptor->needsFrameFunction)) == null) || (((_descriptor->needsFrameFunction))(_framelessStackDelta))) {
				
#        if IMMUTABILITY
				{
					if ((_descriptor->is1ByteInstVarStore)) {
						useTwoPaths = 1;
					} else {
						needsFrame = 1;
						useTwoPaths = 0;
					}
				}
#        else /* IMMUTABILITY */
				{
					needsFrame = 1;
					useTwoPaths = 0;
				}
#        endif /* IMMUTABILITY */
			} else {
				_framelessStackDelta += (_descriptor->stackDelta);
				
#        if IMMUTABILITY
				{
				}
#        else /* IMMUTABILITY */
				{
					if ((_descriptor->is1ByteInstVarStore)) {
						if (_seenInstVarStore) {
							useTwoPaths = 1;
						} else {
							_seenInstVarStore = 1;
						}
					}
				}
#        endif /* IMMUTABILITY */
			}
		}
		if (isBranch(_descriptor)) {
			/* begin spanFor:at:exts:in: */
			_distance = ((_descriptor->spanFunction))(_descriptor, _pc, _nExts, methodObj);
			/* end spanFor:at:exts:in: */
			_targetPC = (_pc + ((_descriptor->numBytes))) + _distance;
			if ((assert(((_descriptor->spanFunction)) != null), (((_descriptor->spanFunction))(_descriptor, _pc, _nExts, methodObj)) < 0)) {
				/* begin initializeFixupAt: */
				/* begin fixupAt: */
				_fixup = fixupAtIndex(_targetPC - initialPC);
				/* end fixupAt: */
				/* begin initializeFixup: */
				{
					(_fixup->simStackPtr = simStackPtr);
					/* begin becomeMergeFixup */
					(_fixup->targetInstruction) = ((AbstractInstruction *) NeedsMergeFixupFlag );
					/* end becomeMergeFixup */
					/* begin setIsBackwardBranchFixup */
					(_fixup->isTargetOfBackwardBranch) = 1;
					/* end setIsBackwardBranchFixup */
				}
				/* end initializeFixup: */
				/* end initializeFixupAt: */
			} else {
				_latestContinuation = ((_latestContinuation < _targetPC) ? _targetPC : _latestContinuation);
			}
		}
		/* begin maybeDealWithUnsafeJumpForDescriptor:pc:latestContinuation: */
		/* end maybeDealWithUnsafeJumpForDescriptor:pc:latestContinuation: */
		_pc += (_descriptor->numBytes);
		_nExts = (((_descriptor->isExtension))
			 ? _nExts + 1
			 : (extA = (numExtB = (extB = 0))));
	}
	return 0;
}
/*	230		11100110	iiiiiiii		PushNClosureTemps iiiiiiii */
/* StackToRegisterMappingCogit>>#sistaV1PushNilSize:numInitialNils: */
static sqInt NoDbgRegParms
sistaV1PushNilSizenumInitialNils(sqInt aMethodObj, sqInt _numInitialNils)
{
	return _numInitialNils;
}
/* StackToRegisterMappingCogit>>#sistaV1:Num:Push:Nils: */
static sqInt NoDbgRegParms
sistaV1NumPushNils(BytecodeDescriptor *_descriptor, sqInt pc, sqInt nExts, sqInt aMethodObj)
{
	return ((((_descriptor->generator)) == genPushConstantNilBytecode)
		 ? 1
		 : 0);
}
/* StackToRegisterMappingCogit>>#ssAllocateRequiredRegMask:upThrough: */
static void NoDbgRegParms
ssAllocateRequiredRegMaskupThrough(sqInt _requiredRegsMask, sqInt _stackPtr)
{
	sqInt _i;
	sqInt _i2;
	sqInt _lastRequired;
	sqInt _liveRegs;

	_lastRequired = -1;
	/* begin registerMaskFor:and: */
	_liveRegs = (1U << FPReg) | (1U << SPReg);
	/* end registerMaskFor:and: */
	for (_i = ((simSpillBase < 0) ? 0 : simSpillBase); _i <= _stackPtr; _i += 1) {
		_liveRegs = _liveRegs | (registerMask(simStackAt(_i)));
		if ((registerMask(simStackAt(_i))) & _requiredRegsMask) {
			_lastRequired = _i;
		}
	}
	if (_liveRegs & _requiredRegsMask) {
		/* begin ssFlushTo: */
		assert(tempsValidAndVolatileEntriesSpilled());
		if (simSpillBase <= _lastRequired) {
			for (_i2 = ((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase)) < simStackPtr) ? ((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase) : simStackPtr)) < _lastRequired) ? (((((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase)) < simStackPtr) ? ((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase) : simStackPtr) : _lastRequired); _i2 <= _lastRequired; _i2 += 1) {
				assert(needsFrame);
				ensureSpilledAtfrom(simStackAt(_i2), frameOffsetOfTemporary(_i2 - 1), FPReg);
			}
			simSpillBase = _lastRequired + 1;
		}
		/* end ssFlushTo: */
		assert(!((liveRegisters()) & _requiredRegsMask));
	}
}
/* StackToRegisterMappingCogit>>#ssFlushStack */
static void
ssFlushStack(void)
{
	ssFlushStackExceptTop(0);
}
/* StackToRegisterMappingCogit>>#ssFlushStackExceptTop: */
static void NoDbgRegParms
ssFlushStackExceptTop(sqInt _n)
{
	sqInt _i;

	/* begin ssFlushTo: */
	assert(tempsValidAndVolatileEntriesSpilled());
	if (simSpillBase <= (simStackPtr - _n)) {
		for (_i = ((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase)) < simStackPtr) ? ((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase) : simStackPtr)) < (simStackPtr - _n)) ? (((((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase)) < simStackPtr) ? ((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase) : simStackPtr) : simStackPtr - _n); _i <= (simStackPtr - _n); _i += 1) {
			assert(needsFrame);
			ensureSpilledAtfrom(simStackAt(_i), frameOffsetOfTemporary(_i - 1), FPReg);
		}
		simSpillBase = (simStackPtr - _n) + 1;
	}
	/* end ssFlushTo: */
}
/*	Any occurrences on the stack of the value being stored (which is the top 
	of stack) 
	must be flushed, and hence any values colder than them stack. */
/* StackToRegisterMappingCogit>>#ssFlushUpThroughReceiverVariable: */
static void NoDbgRegParms
ssFlushUpThroughReceiverVariable(sqInt _slotIndex)
{
	sqInt _i;
	sqInt _index;

	/* begin ssFlushUpThrough: */
	assert(simSpillBase >= 0);
	for (_index = simStackPtr - 1; _index >= simSpillBase; _index += -1) {
		if (((((simStackAt(_index))->type)) == SSBaseOffset) && (((((simStackAt(_index))->registerr)) == ReceiverResultReg) && ((((simStackAt(_index))->offset)) == (slotOffsetOfInstVarIndex(_slotIndex))))) {
			/* begin ssFlushTo: */
			assert(tempsValidAndVolatileEntriesSpilled());
			if (simSpillBase <= _index) {
				for (_i = ((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase)) < simStackPtr) ? ((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase) : simStackPtr)) < _index) ? (((((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase)) < simStackPtr) ? ((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase) : simStackPtr) : _index); _i <= _index; _i += 1) {
					assert(needsFrame);
					ensureSpilledAtfrom(simStackAt(_i), frameOffsetOfTemporary(_i - 1), FPReg);
				}
				simSpillBase = _index + 1;
			}
			/* end ssFlushTo: */
			goto l2;
		}
	}
	l2:
	;
	/* end ssFlushUpThrough: */
}
/*	Any occurrences on the stack of the value being stored (which is the top 
	of stack) 
	must be flushed, and hence any values colder than them stack. */
/* StackToRegisterMappingCogit>>#ssFlushUpThroughTemporaryVariable: */
static void NoDbgRegParms
ssFlushUpThroughTemporaryVariable(sqInt _tempIndex)
{
	sqInt _i;
	sqInt _index;
	sqInt _offset;

	_offset = ((simStackAt(_tempIndex + 1))->offset);
	assert(_offset == (frameOffsetOfTemporary(_tempIndex)));
	/* begin ssFlushUpThrough: */
	assert(simSpillBase >= 0);
	for (_index = simStackPtr - 1; _index >= simSpillBase; _index += -1) {
		if (((((simStackAt(_index))->type)) == SSBaseOffset) && (((((simStackAt(_index))->registerr)) == FPReg) && ((((simStackAt(_index))->offset)) == _offset))) {
			/* begin ssFlushTo: */
			assert(tempsValidAndVolatileEntriesSpilled());
			if (simSpillBase <= _index) {
				for (_i = ((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase)) < simStackPtr) ? ((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase) : simStackPtr)) < _index) ? (((((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase)) < simStackPtr) ? ((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase) : simStackPtr) : _index); _i <= _index; _i += 1) {
					assert(needsFrame);
					ensureSpilledAtfrom(simStackAt(_i), frameOffsetOfTemporary(_i - 1), FPReg);
				}
				simSpillBase = _index + 1;
			}
			/* end ssFlushTo: */
			goto l2;
		}
	}
	l2:
	;
	/* end ssFlushUpThrough: */
}
/*	Peephole optimisation: generate always a single instruction. 
	If the top is spilled, generate just a pop instruction. Otherwise a 
	copy/load  */
/* StackToRegisterMappingCogit>>#ssPopTopToReg: */
static void NoDbgRegParms
ssPopTopToReg(sqInt _aRegister)
{
	if (((ssTop())->spilled)) {
		/* begin PopR: */
		genoperand(PopR, _aRegister);
		/* end PopR: */
	} else {
		copyToReg(ssTop(), _aRegister);
	}
	ssPoppopSpilled(1, 0);
}
/* StackToRegisterMappingCogit>>#ssPopTopToVectorReg: */
static void NoDbgRegParms
ssPopTopToVectorReg(sqInt _aVectorRegister)
{
	moveToVectorReg(ssTop(), _aVectorRegister);
	ssPop(1);
}
/* StackToRegisterMappingCogit>>#ssPop: */
static void NoDbgRegParms
ssPop(sqInt _n)
{
	ssPoppopSpilled(_n, 1);
}
/*	Store or pop the top simulated stack entry to a register. 
	N.B.: popToReg: and storeToReg: does not generate anything if  
	it moves a register to the same register. */
/* StackToRegisterMappingCogit>>#ssPop:andCopyReg: */
static void NoDbgRegParms
ssPopandCopyReg(sqInt _popBoolean, sqInt _reg)
{
	if (_popBoolean) {
		ssPopTopToReg(_reg);
	}
 else {
		copyToReg(ssTop(), _reg);
	}
}
/* StackToRegisterMappingCogit>>#ssPop:popSpilled: */
static void NoDbgRegParms
ssPoppopSpilled(sqInt _n, sqInt _popSpilled)
{
	AbstractInstruction *_anInstruction;
	sqInt _i;
	sqInt _spilledToPop;

	assert(((simStackPtr - _n) >= methodOrBlockNumTemps) || (!needsFrame && ((simStackPtr - _n) >= 0)));
	simStackPtr -= _n;
	_spilledToPop = (simSpillBase - 1) - simStackPtr;
	if (_popSpilled && (_spilledToPop > 0)) {
		/* begin checkQuickConstant:forInstruction: */
		_anInstruction = genoperandoperand(AddCqR, _spilledToPop * BytesPerWord, SPReg);
		if (usesOutOfLineLiteral(_anInstruction)) {
			(_anInstruction->dependent = locateLiteral(_spilledToPop * BytesPerWord));
		}
		/* end checkQuickConstant:forInstruction: */
	}
	/* begin updateSimSpillBase */
	assert((simSpillBase > methodOrBlockNumTemps) && (simStackPtr >= methodOrBlockNumTemps));
	if (simSpillBase > simStackPtr) {
		simSpillBase = simStackPtr + 1;
		while (((simSpillBase - 1) > methodOrBlockNumTemps) && (!(((simStackAt(simSpillBase - 1))->spilled)))) {
			simSpillBase -= 1;
		}
	} else {
		while ((((simStackAt(simSpillBase))->spilled)) && (simSpillBase <= simStackPtr)) {
			simSpillBase += 1;
		}
	}
	for (_i = methodOrBlockNumTemps + 1; _i <= ((((simSpillBase - 1) < simStackPtr) ? simSpillBase - 1 : simStackPtr)); _i += 1) {
		assert((((simStackAt(_i))->spilled)) == 1);
	}
	assert((simSpillBase > simStackPtr) || ((((simStackAt(simSpillBase))->spilled)) == 0));
	/* end updateSimSpillBase */
}
/* StackToRegisterMappingCogit>>#ssPushAnnotatedConstant: */
static sqInt NoDbgRegParms
ssPushAnnotatedConstant(sqInt _literal)
{
	AbstractInstruction *_abstractInstruction;

	ssPushConstant(_literal);
	/* begin annotateInstructionForBytecode */
	/* begin annotateBytecode: */
	_abstractInstruction = ((AbstractInstruction *) (((prevInstIsPCAnnotated())
		 ? (/* begin Nop */ gen(Nop) /* end Nop */)
		 : (/* begin Label */ genoperandoperand(Label, (labelCounter += 1), bytecodePC) /* end Label */))) );
	(_abstractInstruction->annotation = HasBytecodePC);
	/* end annotateBytecode: */
	/* end annotateInstructionForBytecode */
	return 0;
}
/* StackToRegisterMappingCogit>>#ssPushBase:offset: */
static sqInt NoDbgRegParms
ssPushBaseoffset(sqInt _reg, sqInt _offset)
{
	CogSimStackEntry * cascade0;
	sqInt _i;

	ssPush(1);
	{
		cascade0 = ssTop();
		(cascade0->type = SSBaseOffset);
		(cascade0->spilled = 0);
		(cascade0->registerr = _reg);
		(cascade0->offset = _offset);
		(cascade0->bcptr = bytecodePC);
	}
	/* begin updateSimSpillBase */
	assert((simSpillBase > methodOrBlockNumTemps) && (simStackPtr >= methodOrBlockNumTemps));
	if (simSpillBase > simStackPtr) {
		simSpillBase = simStackPtr + 1;
		while (((simSpillBase - 1) > methodOrBlockNumTemps) && (!(((simStackAt(simSpillBase - 1))->spilled)))) {
			simSpillBase -= 1;
		}
	} else {
		while ((((simStackAt(simSpillBase))->spilled)) && (simSpillBase <= simStackPtr)) {
			simSpillBase += 1;
		}
	}
	for (_i = methodOrBlockNumTemps + 1; _i <= ((((simSpillBase - 1) < simStackPtr) ? simSpillBase - 1 : simStackPtr)); _i += 1) {
		assert((((simStackAt(_i))->spilled)) == 1);
	}
	assert((simSpillBase > simStackPtr) || ((((simStackAt(simSpillBase))->spilled)) == 0));
	/* end updateSimSpillBase */
	return 0;
}
/* StackToRegisterMappingCogit>>#ssPushConstant: */
static sqInt NoDbgRegParms
ssPushConstant(sqInt _literal)
{
	CogSimStackEntry * cascade0;
	sqInt _i;

	ssPush(1);
	{
		cascade0 = ssTop();
		(cascade0->type = SSConstant);
		(cascade0->spilled = 0);
		(cascade0->constant = _literal);
		(cascade0->bcptr = bytecodePC);
	}
	/* begin updateSimSpillBase */
	assert((simSpillBase > methodOrBlockNumTemps) && (simStackPtr >= methodOrBlockNumTemps));
	if (simSpillBase > simStackPtr) {
		simSpillBase = simStackPtr + 1;
		while (((simSpillBase - 1) > methodOrBlockNumTemps) && (!(((simStackAt(simSpillBase - 1))->spilled)))) {
			simSpillBase -= 1;
		}
	} else {
		while ((((simStackAt(simSpillBase))->spilled)) && (simSpillBase <= simStackPtr)) {
			simSpillBase += 1;
		}
	}
	for (_i = methodOrBlockNumTemps + 1; _i <= ((((simSpillBase - 1) < simStackPtr) ? simSpillBase - 1 : simStackPtr)); _i += 1) {
		assert((((simStackAt(_i))->spilled)) == 1);
	}
	assert((simSpillBase > simStackPtr) || ((((simStackAt(simSpillBase))->spilled)) == 0));
	/* end updateSimSpillBase */
	return 0;
}
/* StackToRegisterMappingCogit>>#ssPushDesc: */
static sqInt NoDbgRegParms
ssPushDesc(SimStackEntry _simStackEntry)
{
	sqInt _i;

	{
		if (((_simStackEntry.type)) == SSSpill) {
			(_simStackEntry.type = SSBaseOffset);
		}
		{
			(_simStackEntry.spilled = 0);
			(_simStackEntry.bcptr = bytecodePC);
		}
		simStack[(simStackPtr += 1)] = _simStackEntry;
	}
	/* begin updateSimSpillBase */
	assert((simSpillBase > methodOrBlockNumTemps) && (simStackPtr >= methodOrBlockNumTemps));
	if (simSpillBase > simStackPtr) {
		simSpillBase = simStackPtr + 1;
		while (((simSpillBase - 1) > methodOrBlockNumTemps) && (!(((simStackAt(simSpillBase - 1))->spilled)))) {
			simSpillBase -= 1;
		}
	} else {
		while ((((simStackAt(simSpillBase))->spilled)) && (simSpillBase <= simStackPtr)) {
			simSpillBase += 1;
		}
	}
	for (_i = methodOrBlockNumTemps + 1; _i <= ((((simSpillBase - 1) < simStackPtr) ? simSpillBase - 1 : simStackPtr)); _i += 1) {
		assert((((simStackAt(_i))->spilled)) == 1);
	}
	assert((simSpillBase > simStackPtr) || ((((simStackAt(simSpillBase))->spilled)) == 0));
	/* end updateSimSpillBase */
	return 0;
}
/* StackToRegisterMappingCogit>>#ssPushRegister: */
static sqInt NoDbgRegParms
ssPushRegister(sqInt _reg)
{
	CogSimStackEntry * cascade0;
	sqInt _i;

	ssPush(1);
	{
		cascade0 = ssTop();
		(cascade0->type = SSRegister);
		(cascade0->spilled = 0);
		(cascade0->registerr = _reg);
		(cascade0->bcptr = bytecodePC);
	}
	/* begin updateSimSpillBase */
	assert((simSpillBase > methodOrBlockNumTemps) && (simStackPtr >= methodOrBlockNumTemps));
	if (simSpillBase > simStackPtr) {
		simSpillBase = simStackPtr + 1;
		while (((simSpillBase - 1) > methodOrBlockNumTemps) && (!(((simStackAt(simSpillBase - 1))->spilled)))) {
			simSpillBase -= 1;
		}
	} else {
		while ((((simStackAt(simSpillBase))->spilled)) && (simSpillBase <= simStackPtr)) {
			simSpillBase += 1;
		}
	}
	for (_i = methodOrBlockNumTemps + 1; _i <= ((((simSpillBase - 1) < simStackPtr) ? simSpillBase - 1 : simStackPtr)); _i += 1) {
		assert((((simStackAt(_i))->spilled)) == 1);
	}
	assert((simSpillBase > simStackPtr) || ((((simStackAt(simSpillBase))->spilled)) == 0));
	/* end updateSimSpillBase */
	return 0;
}
/* StackToRegisterMappingCogit>>#ssPushVectorRegister: */
static sqInt NoDbgRegParms
ssPushVectorRegister(sqInt _reg)
{
	CogSimStackEntry * cascade0;
	sqInt _i;

	ssPush(1);
	{
		cascade0 = ssTop();
		(cascade0->type = SSVectorRegister);
		(cascade0->spilled = 0);
		(cascade0->registerr = _reg);
		(cascade0->bcptr = bytecodePC);
	}
	ssTop();
	/* begin updateSimSpillBase */
	assert((simSpillBase > methodOrBlockNumTemps) && (simStackPtr >= methodOrBlockNumTemps));
	if (simSpillBase > simStackPtr) {
		simSpillBase = simStackPtr + 1;
		while (((simSpillBase - 1) > methodOrBlockNumTemps) && (!(((simStackAt(simSpillBase - 1))->spilled)))) {
			simSpillBase -= 1;
		}
	} else {
		while ((((simStackAt(simSpillBase))->spilled)) && (simSpillBase <= simStackPtr)) {
			simSpillBase += 1;
		}
	}
	for (_i = methodOrBlockNumTemps + 1; _i <= ((((simSpillBase - 1) < simStackPtr) ? simSpillBase - 1 : simStackPtr)); _i += 1) {
		assert((((simStackAt(_i))->spilled)) == 1);
	}
	assert((simSpillBase > simStackPtr) || ((((simStackAt(simSpillBase))->spilled)) == 0));
	/* end updateSimSpillBase */
	return 0;
}
/* StackToRegisterMappingCogit>>#ssPush: */
static void NoDbgRegParms
ssPush(sqInt _n)
{
	simStackPtr += _n;
}
/* StackToRegisterMappingCogit>>#ssSelfDescriptor */
static SimStackEntry
ssSelfDescriptor(void)
{
	return simStack[0];
}
/*	In addition to ssStorePop:toReg:, if this is a store and not 
	a popInto I change the simulated stack to use the register  
	for the top value */
/* StackToRegisterMappingCogit>>#ssStoreAndReplacePop:toReg: */
static void NoDbgRegParms
ssStoreAndReplacePoptoReg(sqInt _popBoolean, sqInt _reg)
{
	char _topSpilled;

	_topSpilled = ((ssTop())->spilled);
	ssPopandCopyReg(_popBoolean || _topSpilled, _reg);
	if (!_popBoolean) {
		if (!_topSpilled) {
			ssPoppopSpilled(1, 0);
		}
		ssPushRegister(_reg);
	}
}
/*	Store or pop the top simulated stack entry to a register. 
	Use preferredReg if the entry is not itself a register. 
	Answer the actual register the result ends up in. */
/* StackToRegisterMappingCogit>>#ssStorePop:toPreferredReg: */
static sqInt NoDbgRegParms
ssStorePoptoPreferredReg(sqInt _popBoolean, sqInt _preferredReg)
{
	sqInt _actualReg;

	_actualReg = _preferredReg;
	if ((((ssTop())->type)) == SSRegister) {
		assert(!(((ssTop())->spilled)));
		_actualReg = ((ssTop())->registerr);
	}
	ssPopandCopyReg(_popBoolean, _actualReg);
	return _actualReg;
}
/* StackToRegisterMappingCogit>>#ssTop */
static CogSimStackEntry *
ssTop(void)
{
	return simStackAt(simStackPtr);
}
/* StackToRegisterMappingCogit>>#ssValue: */
static CogSimStackEntry * NoDbgRegParms
ssValue(sqInt _n)
{
	return simStackAt(simStackPtr - _n);
}
/* StackToRegisterMappingCogit>>#stackEntryIsBoolean: */
static sqInt NoDbgRegParms
stackEntryIsBoolean(CogSimStackEntry *_simStackEntry)
{
	return (((_simStackEntry->type)) == SSConstant) && ((((_simStackEntry->constant)) == (trueObject())) || (((_simStackEntry->constant)) == (falseObject())));
}
/*	Answer if the stack is valid up to, but not including, simSpillBase. */
/* StackToRegisterMappingCogit>>#tempsValidAndVolatileEntriesSpilled */
static sqInt
tempsValidAndVolatileEntriesSpilled(void)
{
	sqInt _i;

	for (_i = 1; _i <= methodOrBlockNumTemps; _i += 1) {
		if (!((((simStackAt(_i))->type)) == SSBaseOffset)) {
			return 0;
		}
	}
	for (_i = methodOrBlockNumTemps + 1; _i < simSpillBase; _i += 1) {
		if (!(((simStackAt(_i))->spilled))) {
			return 0;
		}
	}
	return 1;
}
/*	If the sequence of bytecodes is 
	push: (Array new: 1) 
	popIntoTemp: tempIndex 
	pushConstant: const or pushTemp: n 
	popIntoTemp: 0 inVectorAt: tempIndex 
	collapse this into 
	tempAt: tempIndex put: {const or temp} 
	and answer true, otherwise answer false. 
	One might think that we should look for a sequence of more than 
	one pushes and pops but this is extremely rare. 
	Exclude pushRcvr: n to avoid potential complications with context inst 
	vars.  */
/* StackToRegisterMappingCogit>>#tryCollapseTempVectorInitializationOfSize: */
static sqInt NoDbgRegParms
tryCollapseTempVectorInitializationOfSize(sqInt _slots)
{
	sqInt _pc;
	sqInt _pc2;
	sqInt _pc3;
	BytecodeDescriptor *_pushArrayDesc;
	BytecodeDescriptor *_pushValueDesc;
	sqInt _reg;
	sqInt _remoteTempIndex;
	BytecodeDescriptor *_storeArrayDesc;
	BytecodeDescriptor *_storeValueDesc;
	sqInt _tempIndex;

	if (_slots != 1) {
		return 0;
	}
	/* begin generatorForPC: */
	_pushArrayDesc = generatorAt(fetchByteofObject(bytecodePC, methodObj));
	/* end generatorForPC: */
	assert(((_pushArrayDesc->generator)) == genPushNewArrayBytecode);
	/* begin generatorForPC: */
	_pc = bytecodePC + ((_pushArrayDesc->numBytes));
	_storeArrayDesc = generatorAt(fetchByteofObject(_pc, methodObj));
	/* end generatorForPC: */
	if (((_storeArrayDesc->generator)) == genStoreAndPopTemporaryVariableBytecode) {
		_tempIndex = (fetchByteofObject(bytecodePC + ((_pushArrayDesc->numBytes)), methodObj)) & 7;
	} else {
		if (!(((_storeArrayDesc->generator)) == genLongStoreAndPopTemporaryVariableBytecode)) {
			return 0;
		}
		_tempIndex = fetchByteofObject((bytecodePC + ((_pushArrayDesc->numBytes))) + 1, methodObj);
	}
	/* begin generatorForPC: */
	_pc2 = (bytecodePC + ((_pushArrayDesc->numBytes))) + ((_storeArrayDesc->numBytes));
	_pushValueDesc = generatorAt(fetchByteofObject(_pc2, methodObj));
	/* end generatorForPC: */
	if (!((((_pushValueDesc->generator)) == genPushLiteralConstantBytecode) || ((((_pushValueDesc->generator)) == genPushQuickIntegerConstantBytecode) || (((_pushValueDesc->generator)) == genPushTemporaryVariableBytecode)))) {
		return 0;
	}
	/* begin generatorForPC: */
	_pc3 = ((bytecodePC + ((_pushArrayDesc->numBytes))) + ((_storeArrayDesc->numBytes))) + ((_pushValueDesc->numBytes));
	_storeValueDesc = generatorAt(fetchByteofObject(_pc3, methodObj));
	/* end generatorForPC: */
	_remoteTempIndex = fetchByteofObject((((bytecodePC + ((_pushArrayDesc->numBytes))) + ((_storeArrayDesc->numBytes))) + ((_pushValueDesc->numBytes))) + 2, methodObj);
	if (!((((_storeValueDesc->generator)) == genStoreAndPopRemoteTempLongBytecode) && (_tempIndex == _remoteTempIndex))) {
		return 0;
	}
	genNewArrayOfSizeinitialized(1, 0);
	evaluateat(_pushValueDesc, (bytecodePC + ((_pushArrayDesc->numBytes))) + ((_storeArrayDesc->numBytes)));
	_reg = ssStorePoptoPreferredReg(1, TempReg);
	genStoreSourceRegslotIndexintoNewObjectInDestReg(_reg, 0, ReceiverResultReg);
	ssPushRegister(ReceiverResultReg);
	evaluateat(_storeArrayDesc, bytecodePC + ((_pushArrayDesc->numBytes)));
	bytecodePC = ((bytecodePC + ((_storeArrayDesc->numBytes))) + ((_pushValueDesc->numBytes))) + ((_storeValueDesc->numBytes));
	return 1;
}
/* StackToRegisterMappingCogit>>#violatesEnsureSpilledSpillAssert */
static sqInt
violatesEnsureSpilledSpillAssert(void)
{
	return 1;
}
/*	Used when ReceiverResultReg is allocated for other than simSelf, and 
	there may be references to ReceiverResultReg which need to be spilled. */
/* StackToRegisterMappingCogit>>#voidReceiverResultRegContainsSelf */
static void
voidReceiverResultRegContainsSelf(void)
{
	sqInt _i;
	sqInt _i2;
	sqInt _spillIndex;

	/* begin voidReceiverOptStatus */
	((simSelf())->liveRegister = NoReg);
	/* end voidReceiverOptStatus */
	_spillIndex = 0;
	for (_i = (((methodOrBlockNumTemps + 1) < simSpillBase) ? simSpillBase : methodOrBlockNumTemps + 1); _i <= simStackPtr; _i += 1) {
		if ((registerOrNone(simStackAt(_i))) == ReceiverResultReg) {
			_spillIndex = _i;
		}
	}
	if (_spillIndex > 0) {
		/* begin ssFlushTo: */
		assert(tempsValidAndVolatileEntriesSpilled());
		if (simSpillBase <= _spillIndex) {
			for (_i2 = ((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase)) < simStackPtr) ? ((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase) : simStackPtr)) < _spillIndex) ? (((((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase)) < simStackPtr) ? ((simSpillBase < (methodOrBlockNumTemps + 1)) ? methodOrBlockNumTemps + 1 : simSpillBase) : simStackPtr) : _spillIndex); _i2 <= _spillIndex; _i2 += 1) {
				assert(needsFrame);
				ensureSpilledAtfrom(simStackAt(_i2), frameOffsetOfTemporary(_i2 - 1), FPReg);
			}
			simSpillBase = _spillIndex + 1;
		}
		/* end ssFlushTo: */
	}
}
