text: /* Automatically generated by
  	CCodeGenerator VMMaker.oscog-eem.2743 uuid: 6fa490eb-27b9-471e-9e46-6aa4ce54e382
     from
  	StackToRegisterMappingCogit VMMaker.oscog-eem.2743 uuid: 6fa490eb-27b9-471e-9e46-6aa4ce54e382
   */
  static char __buildInfo[] = "StackToRegisterMappingCogit VMMaker.oscog-eem.2743 uuid: 6fa490eb-27b9-471e-9e46-6aa4ce54e382 " __DATE__ ;
  char *__cogitBuildInfo = __buildInfo;
  
  
  
  #include <stddef.h>
  #include "sq.h"
  #include "sqCogStackAlignment.h"
  #include "dispdbg.h"
  #include "cogmethod.h"
  #if COGMTVM
  #include "cointerpmt.h"
  #else
  #include "cointerp.h"
  #endif
  #include "cogit.h"
  
  
  /*** Constants ***/
  #define ABICallerSavedRegisterMask 0x120F
  #define ABIResultReg 0
  #define AddCqR 104
  #define AddCqRR 121
  #define AddCwR 112
  #define AddOpcode 4
  #define AddRdRd 130
  #define AddRR 98
  #define AddRRR 124
  #define AL 14
  #define AlignmentNops 3
  #define AllButTypeMask 0xFFFFFFFCU
  #define AltBlockCreationBytecodeSize 3
  #define AltFirstSpecialSelector 80
  #define AltNumSpecialSelectors 32
  #define AndCqR 106
  #define AndCqRR 122
  #define AndCwR 114
  #define AndOpcode 0
  #define AndRR 100
  #define AnnotationShift 5
  #define Arg0Reg 3
  #define Arg1Reg 4
  #define ArithmeticShiftRightCqR 89
  #define ArithmeticShiftRightCqRR 126
  #define ArithmeticShiftRightRR 90
  #define BadRegisterSet 1
  #define BicOpcode 14
  #define BlockCreationBytecodeSize 4
  #define BytecodeSetHasDirectedSuperSend 0
  #define CArg0Reg 0
  #define CArg1Reg 1
  #define CArg2Reg 2
  #define CArg3Reg 3
  #define Call 6
  #define CallerSavedRegisterMask 0xC
  #define CallFull 7
  #define CC 3
  #define ClassArray 7
  #define ClassFloatCompactIndex 6
  #define ClassLargePositiveIntegerCompactIndex 5
  #define ClassMethodContextCompactIndex 14
  #define ClassReg 2
  #define ClosureFirstCopiedValueIndex 3
  #define ClosureNumArgsIndex 2
  #define ClosureOuterContextIndex 0
  #define ClosureStartPCIndex 1
  #define ClzRR 155
  #define CMBlock 3
  #define CMClosedPIC 4
  #define CMFree 1
  #define CMMaxUsageCount 7
  #define CMMethod 2
  #define CMOpenPIC 5
  #define CMPSMULL 163
  #define CmpC32R 111
  #define CmpCqR 103
  #define CmpCwR 110
  #define CmpNotOpcode 11
  #define CmpOpcode 10
  #define CmpRdRd 129
  #define CmpRR 97
  #define CompactClasses 28
  #define CompletePrimitive 4
  #define ConcreteIPReg 12
  #define ConcreteVarBaseReg 10
  #define ConstZero 1
  #define ConvertRRd 143
  #define CS 2
  #define Debug DEBUGVM
  #define DisplacementMask 0x1F
  #define DisplacementX2N 0
  #define DivRdRd 133
  #define DPFPReg0 0
  #define DPFPReg1 1
  #define DPFPReg2 2
  #define DPFPReg3 3
  #define DPFPReg4 4
  #define DPFPReg5 5
  #define DPFPReg6 6
  #define DPFPReg7 7
  #define EncounteredUnknownBytecode -6
  #define EQ 0
  #define Extra0Reg 7
  #define Extra1Reg 8
  #define Extra2Reg 9
  #define Fill32 4
  #define FirstAnnotation 64
  #define FirstJump 12
  #define FirstSpecialSelector 176
  #define FoxCallerSavedIP 4
  #define FoxMethod -4
  #define FoxMFReceiver -12
  #define FoxThisContext -8
  #define FPReg 11
  #define GCModeBecome 8
  #define GCModeFull 1
  #define GCModeNewSpace 2
  #define GE 10
  #define GT 12
  #define HasBytecodePC 5
  #define HashBitsOffset 17
  #define HashMaskUnshifted 0xFFF
  #define HashMultiplyConstant 1664525
  #define HashMultiplyMask 0xFFFFFFF
  #define HeaderIndex 0
  #define HeaderTypeShort 3
  #define HeaderTypeSizeAndClass 0
  #define HI 8
  #if !defined(IMMUTABILITY) /* Allow this to be overridden on the compiler command line */
  # define IMMUTABILITY 0
  #endif
  #define InstanceSpecificationIndex 2
  #define InstructionPointerIndex 1
  #define InsufficientCodeSpace -2
  #define InVanillaBlock 1
  #define IsAbsPCReference 3
  #define IsAnnotationExtension 1
  #define IsDirectedSuperBindingSend null
  #define IsDirectedSuperSend null
  #define IsDisplacementX2N 0
  #define IsNSDynamicSuperSend null
  #define IsNSSelfSend null
  #define IsNSSendCall null
  #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 LastJump 40
  #define LE 13
  #define LinkReg 14
  #define Literal 2
  #define LoadEffectiveAddressMwrR 86
  #define LogicalShiftLeftCqR 93
  #define LogicalShiftLeftCqRR 127
  #define LogicalShiftLeftRR 94
  #define LogicalShiftRightCqR 91
  #define LogicalShiftRightCqRR 128
  #define LogicalShiftRightRR 92
  #define LongSizeMask 0xFFFFFFFCU
  #define LowcodeVM 0
  #define LR 14
  #define LS 9
  #define LT 11
  #define MapEnd 0
  #define MaxCompiledPrimitiveIndex 575
  #define MaxCPICCases 6
  #define MaxMethodSize 65535
  #define MaxNegativeErrorCode -8
  #define MaxNumArgs 15
  #define MaxStackAllocSize 1572864
  #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 MoveM64rRd 73
  #define MoveMbrR 63
  #define MoveMwrR 48
  #define MoveNotOpcode 15
  #define MoveOpcode 13
  #define MoveRAb 47
  #define MoveRAw 44
  #define MoveRdM64r 74
  #define MoveRdRd 72
  #define MoveRM16r 56
  #define MoveRMbr 64
  #define MoveRMwr 49
  #define MoveRR 41
  #define MoveRXbrR 66
  #define MoveRXwrR 51
  #define MoveXbrRR 65
  #define MoveXwrRR 50
  #define MSR 157
  #define MULTIPLEBYTECODESETS 0
  #define MulRdRd 132
  #define NativePopR 82
  #define NativePushR 83
  #define NativeRetN 84
  #define NativeSPReg 13
  #define NE 1
  #define NeedsMergeFixupFlag 2
  #define NeedsNonMergeFixupFlag 1
  #define NegateR 87
  #define NewspeakVM 0
  #define Nop 5
  #define NoReg -1
  #define NotFullyInitialized -1
  #define NumObjRefsInRuntime 0
  #define NumOopsPerNSC 6
  #define NumSendTrampolines 4
  #define NumSpecialSelectors 32
  #define NumTrampolines 54
  #define OrCqR 107
  #define OrCqRR 123
  #define OrCwR 115
  #define OrOpcode 12
  #define OrRR 101
  #define PC 15
  #define PCReg 15
  #define PL 5
  #define PopLDM 159
  #define PopR 78
  #define PrefetchAw 85
  #define PrimCallCollectsProfileSamples 16
  #define PrimCallDoNotJIT 64
  #define PrimCallMayCallBack 4
  #define PrimCallNeedsNewMethod 1
  #define PrimCallNeedsPrimitiveFunction 2
  #define PrimCallOnSmalltalkStack 8
  #define PrimErrNoMemory 9
  #define PushCq 80
  #define PushCw 81
  #define PushR 79
  #define PushSTM 160
  #define ReceiverIndex 5
  #define ReceiverResultReg 5
  #define RetN 9
  #define RISCTempReg 12
  #define RootBit 0x40000000
  #define RootBitDigitLength 4
  #define RsbOpcode 3
  #define SelectorCannotInterpret 34
  #define SelectorDoesNotUnderstand 20
  #define SenderIndex 0
  #define SendNumArgsReg 6
  #define ShouldNotJIT -8
  #define SistaV1BytecodeSet 0
  #define SistaVM 0
  #define Size4Bit 0
  #define SizeMask 0xFC
  #define SMULL 156
  #define SP 13
  #define SPReg 13
  #define SPURVM 0
  #define SqrtRd 134
  #define SSBaseOffset 1
  #define SSConstant 2
  #define SSRegister 3
  #define SSSpill 4
  #define Stop 11
  #define SubCqR 105
  #define SubCwR 113
  #define SubOpcode 2
  #define SubRdRd 131
  #define SubRR 99
  #define SubRRR 125
  #define TempReg 0
  #define TempVectReadBarrier 0
  #define TstCqR 108
  #define TstOpcode 8
  #define TypeMask 0x3
  #define UnfailingPrimitive 3
  #define UnimplementedPrimitive -7
  #define ValueIndex 1
  #define VarBaseReg 10
  #define VC 7
  #define VS 6
  #define XorCqR 109
  #define XorCwR 116
  #define XorOpcode 1
  #define XorRR 102
  #define YoungSelectorInPIC -5
  
  typedef struct _AbstractInstruction {
  	unsigned char	opcode;
  	unsigned char	machineCodeSize;
  	unsigned char	maxSize;
  	unsigned char	annotation;
  	unsigned char	conditionOrNil;
  	usqInt		operands [3];
  	usqInt	address;
  	struct _AbstractInstruction *dependent;
  	unsigned int		machineCode [2];
   } AbstractInstruction;
  
  #define CogOutOfLineLiteralsARMCompiler AbstractInstruction
  #define CogARMCompiler AbstractInstruction
  #define CogAbstractInstruction AbstractInstruction
  
  
  typedef struct {
  	AbstractInstruction *fakeHeader;
  	AbstractInstruction *fillInstruction;
  	sqInt	numArgs;
  	sqInt	numCopied;
  	sqInt	numInitialNils;
  	sqInt	startpc;
  	AbstractInstruction *entryLabel;
  	AbstractInstruction *stackCheckLabel;
  	sqInt	span;
  	sqInt	hasInstVarRef;
   } BlockStart;
  
  #define CogBlockStart BlockStart
  
  
  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		isBlockCreation : 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;
   } PrimitiveDescriptor;
  
  #define CogPrimitiveDescriptor PrimitiveDescriptor
  
  
  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;
  #if LowcodeVM
  	short	simNativeStackPtr;
  	unsigned short	simNativeStackSize;
  #endif
   } 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 availableFloatRegisterOrNoneFor(AbstractInstruction * self_in_availableFloatRegisterOrNoneFor, sqInt liveRegsMask);
  static AbstractInstruction * NoDbgRegParms cloneLiteralFrom(AbstractInstruction * self_in_cloneLiteralFrom, AbstractInstruction *existingLiteral);
  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 sqInt NoDbgRegParms genSaveStackPointers(AbstractInstruction * self_in_genSaveStackPointers);
  static AbstractInstruction * NoDbgRegParms genSwapRRScratch(AbstractInstruction * self_in_genSwapRRScratch, sqInt regA, sqInt regB, sqInt regTmp);
  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 isAnInstruction(AbstractInstruction * self_in_isAnInstruction, AbstractInstruction *addressOrInstruction);
  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 rewriteConditionalJumpLongAttarget(AbstractInstruction * self_in_rewriteConditionalJumpLongAttarget, sqInt callSiteReturnAddress, sqInt callTargetAddress);
  static sqInt NoDbgRegParms wantsNearAddressFor(AbstractInstruction * self_in_wantsNearAddressFor, sqInt anObject);
  static sqInt NoDbgRegParms addsrnimmror(AbstractInstruction * self_in_addsrnimmror, sqInt destReg, sqInt srcReg, sqInt immediate, sqInt rot);
  static sqInt NoDbgRegParms addrnimmror(AbstractInstruction * self_in_addrnimmror, sqInt destReg, sqInt srcReg, sqInt immediate, sqInt rot);
  static sqInt NoDbgRegParms addrnrm(AbstractInstruction * self_in_addrnrm, sqInt destReg, sqInt srcReg, sqInt addReg);
  static usqInt NoDbgRegParms aeabiDivModFunctionAddr(AbstractInstruction * self_in_aeabiDivModFunctionAddr);
  static sqInt NoDbgRegParms andsrnimmror(AbstractInstruction * self_in_andsrnimmror, sqInt destReg, sqInt srcReg, sqInt immediate, sqInt rot);
  static sqInt NoDbgRegParms andrnimmror(AbstractInstruction * self_in_andrnimmror, sqInt destReg, sqInt srcReg, sqInt immediate, sqInt rot);
  static sqInt NoDbgRegParms availableRegisterOrNoneFor(AbstractInstruction * self_in_availableRegisterOrNoneFor, sqInt liveRegsMask);
  static sqInt NoDbgRegParms bicsrnimmror(AbstractInstruction * self_in_bicsrnimmror, sqInt destReg, sqInt srcReg, sqInt immediate, sqInt rot);
  static sqInt NoDbgRegParms bl(AbstractInstruction * self_in_bl, sqInt offset);
  static sqInt NoDbgRegParms b(AbstractInstruction * self_in_b, sqInt offset);
  static sqInt NoDbgRegParms callInstructionByteSize(AbstractInstruction * self_in_callInstructionByteSize);
  static sqInt NoDbgRegParms callTargetFromReturnAddress(AbstractInstruction * self_in_callTargetFromReturnAddress, sqInt callSiteReturnAddress);
  static sqInt NoDbgRegParms computeMaximumSize(AbstractInstruction * self_in_computeMaximumSize);
  static sqInt NoDbgRegParms concretizeAt(AbstractInstruction * self_in_concretizeAt, sqInt actualAddress);
  static sqInt NoDbgRegParms concretizeCMPSMULL(AbstractInstruction * self_in_concretizeCMPSMULL);
  static usqInt NoDbgRegParms concretizeConditionalInstruction(AbstractInstruction * self_in_concretizeConditionalInstruction);
  static sqInt NoDbgRegParms concretizeFill32(AbstractInstruction * self_in_concretizeFill32);
  static sqInt NoDbgRegParms concretizeMSR(AbstractInstruction * self_in_concretizeMSR);
  static sqInt NoDbgRegParms concretizePushOrPopMultipleRegisters(AbstractInstruction * self_in_concretizePushOrPopMultipleRegisters, sqInt doPush);
  static sqInt NoDbgRegParms concretizeSMULL(AbstractInstruction * self_in_concretizeSMULL);
  static sqInt NoDbgRegParms conditionIsNotNever(AbstractInstruction * self_in_conditionIsNotNever, sqInt instr);
  static sqInt NoDbgRegParms dataOpTyperdrnrmlsr(AbstractInstruction * self_in_dataOpTyperdrnrmlsr, sqInt armOpcode, sqInt destReg, sqInt srcReg, sqInt addReg, sqInt shft);
  static sqInt NoDbgRegParms dispatchConcretize(AbstractInstruction * self_in_dispatchConcretize);
  static usqInt NoDbgRegParms fmsrFromto(AbstractInstruction * self_in_fmsrFromto, sqInt regA, sqInt regB);
  static usqInt NoDbgRegParms fsitodFromto(AbstractInstruction * self_in_fsitodFromto, sqInt regA, sqInt regB);
  static sqInt NoDbgRegParms fullCallsAreRelative(AbstractInstruction * self_in_fullCallsAreRelative);
  static AbstractInstruction * NoDbgRegParms genDivRRQuoRem(AbstractInstruction * self_in_genDivRRQuoRem, sqInt abstractRegDivisor, sqInt abstractRegDividend, sqInt abstractRegQuotient, sqInt abstractRegRemainder);
  static AbstractInstruction * NoDbgRegParms genMarshallNArgsargargargarg(AbstractInstruction * self_in_genMarshallNArgsargargargarg, sqInt numArgs, sqInt regOrConst0, sqInt regOrConst1, sqInt regOrConst2, sqInt regOrConst3);
  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 genRemoveNArgsFromStack(AbstractInstruction * self_in_genRemoveNArgsFromStack, sqInt n);
  static AbstractInstruction * NoDbgRegParms genRestoreRegs(AbstractInstruction * self_in_genRestoreRegs, sqInt regMask);
  static AbstractInstruction * NoDbgRegParms genSaveRegs(AbstractInstruction * self_in_genSaveRegs, sqInt regMask);
  static AbstractInstruction * NoDbgRegParms genSubstituteReturnAddress(AbstractInstruction * self_in_genSubstituteReturnAddress, sqInt retpc);
  static sqInt 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 instructionIsBX(AbstractInstruction * self_in_instructionIsBX, sqInt instr);
  static sqInt NoDbgRegParms instructionIsB(AbstractInstruction * self_in_instructionIsB, sqInt instr);
  static sqInt NoDbgRegParms instructionIsCMP(AbstractInstruction * self_in_instructionIsCMP, sqInt instr);
  static sqInt NoDbgRegParms instructionIsLDR(AbstractInstruction * self_in_instructionIsLDR, sqInt instr);
  static sqInt NoDbgRegParms instructionIsOR(AbstractInstruction * self_in_instructionIsOR, sqInt instr);
  static sqInt NoDbgRegParms instructionIsPush(AbstractInstruction * self_in_instructionIsPush, sqInt instr);
  static sqInt NoDbgRegParms instructionSizeAt(AbstractInstruction * self_in_instructionSizeAt, sqInt pc);
  static sqInt NoDbgRegParms inverseOpcodeFor(AbstractInstruction * self_in_inverseOpcodeFor, sqInt armOpcode);
  static sqInt NoDbgRegParms isCallPrecedingReturnPC(AbstractInstruction * self_in_isCallPrecedingReturnPC, sqInt mcpc);
  static sqInt NoDbgRegParms isInImmediateJumpRange(AbstractInstruction * self_in_isInImmediateJumpRange, usqIntptr_t operand);
  static sqInt NoDbgRegParms isJumpAt(AbstractInstruction * self_in_isJumpAt, sqInt pc);
  static sqInt NoDbgRegParms isPCRelativeValueLoad(AbstractInstruction * self_in_isPCRelativeValueLoad, unsigned int instr);
  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 usqInt NoDbgRegParms jumpTargetPCAt(AbstractInstruction * self_in_jumpTargetPCAt, sqInt pc);
  static sqInt NoDbgRegParms ldrbrnplusimm(AbstractInstruction * self_in_ldrbrnplusimm, sqInt destReg, sqInt baseReg, sqInt u, sqInt immediate12bitValue);
  static sqInt NoDbgRegParms ldrbrnrm(AbstractInstruction * self_in_ldrbrnrm, sqInt destReg, sqInt baseReg, sqInt offsetReg);
  static sqInt NoDbgRegParms ldrhrnplusimm(AbstractInstruction * self_in_ldrhrnplusimm, sqInt destReg, sqInt baseReg, sqInt u, sqInt immediate8bitValue);
  static sqInt NoDbgRegParms ldrhrnrm(AbstractInstruction * self_in_ldrhrnrm, sqInt destReg, sqInt baseReg, sqInt offsetReg);
  static sqInt NoDbgRegParms ldrrnplusImm(AbstractInstruction * self_in_ldrrnplusImm, sqInt destReg, sqInt baseReg, sqInt immediate12bitValue);
  static sqInt NoDbgRegParms ldrrnplusimm(AbstractInstruction * self_in_ldrrnplusimm, sqInt destReg, sqInt baseReg, sqInt u, sqInt immediate12bitValue);
  static sqInt NoDbgRegParms ldrrnrm(AbstractInstruction * self_in_ldrrnrm, sqInt destReg, sqInt baseReg, sqInt offsetReg);
  static sqInt NoDbgRegParms loadCwInto(AbstractInstruction * self_in_loadCwInto, sqInt destReg);
  static sqInt NoDbgRegParms loadPICLiteralByteSize(AbstractInstruction * self_in_loadPICLiteralByteSize);
  static sqInt NoDbgRegParms machineCodeWords(AbstractInstruction * self_in_machineCodeWords);
  static sqInt NoDbgRegParms memM16xrregbasepuwloffset(AbstractInstruction * self_in_memM16xrregbasepuwloffset, sqInt cond, sqInt destReg, sqInt baseReg, sqInt postpreoffset, sqInt updown, sqInt weirdstuff, sqInt loadstore, sqInt offset8);
  static sqInt NoDbgRegParms memM16xrregbasepuwlrm(AbstractInstruction * self_in_memM16xrregbasepuwlrm, sqInt cond, sqInt destReg, sqInt baseReg, sqInt postpreoffset, sqInt updown, sqInt weirdstuff, sqInt loadstore, sqInt offsetReg);
  static sqInt NoDbgRegParms memMxrregbasepubwlimm(AbstractInstruction * self_in_memMxrregbasepubwlimm, sqInt cond, sqInt destReg, sqInt baseReg, sqInt postpreoffset, sqInt updown, sqInt byteword, sqInt weirdstuff, sqInt loadstore, sqInt offset);
  static sqInt NoDbgRegParms memMxrregbasepubwlrmLsl2(AbstractInstruction * self_in_memMxrregbasepubwlrmLsl2, sqInt cond, sqInt destReg, sqInt baseReg, sqInt postpreoffset, sqInt updown, sqInt byteword, sqInt weirdstuff, sqInt loadstore, sqInt offsetReg);
  static sqInt NoDbgRegParms memMxrregbasepubwlrm(AbstractInstruction * self_in_memMxrregbasepubwlrm, sqInt cond, sqInt destReg, sqInt baseReg, sqInt postpreoffset, sqInt updown, sqInt byteword, sqInt weirdstuff, sqInt loadstore, sqInt offsetReg);
  static sqInt NoDbgRegParms memMxrregbaseublimm(AbstractInstruction * self_in_memMxrregbaseublimm, sqInt cond, sqInt destReg, sqInt baseReg, sqInt updown, sqInt byteword, sqInt loadstore, sqInt immediate12bitValue);
  static sqInt NoDbgRegParms movsrn(AbstractInstruction * self_in_movsrn, sqInt destReg, sqInt srcReg);
  static sqInt NoDbgRegParms movimmror(AbstractInstruction * self_in_movimmror, sqInt destReg, sqInt immediate8bitValue, sqInt rot);
  static sqInt NoDbgRegParms movrn(AbstractInstruction * self_in_movrn, sqInt destReg, sqInt srcReg);
  static sqInt NoDbgRegParms msr(AbstractInstruction * self_in_msr, sqInt flags);
  static sqInt NoDbgRegParms mvnimmror(AbstractInstruction * self_in_mvnimmror, sqInt destReg, sqInt immediate8bitValue, sqInt rot);
  static sqInt NoDbgRegParms numIntRegArgs(AbstractInstruction * self_in_numIntRegArgs);
  static sqInt NoDbgRegParms orrimmror(AbstractInstruction * self_in_orrimmror, sqInt destReg, sqInt immediate8bitValue, sqInt rot);
  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 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 rewriteCallAttarget(AbstractInstruction * self_in_rewriteCallAttarget, usqInt callSiteReturnAddress, usqInt callTargetAddress);
  static sqInt NoDbgRegParms rewriteCallFullAttarget(AbstractInstruction * self_in_rewriteCallFullAttarget, sqInt callSiteReturnAddress, sqInt callTargetAddress);
  static sqInt NoDbgRegParms rewriteJumpFullAttarget(AbstractInstruction * self_in_rewriteJumpFullAttarget, sqInt callSiteReturnAddress, sqInt 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 setsConditionCodesFor(AbstractInstruction * self_in_setsConditionCodesFor, sqInt aConditionalJumpOpcode);
  static sqInt NoDbgRegParms shiftSetsConditionCodesFor(AbstractInstruction * self_in_shiftSetsConditionCodesFor, sqInt aConditionalJumpOpcode);
  static sqInt NoDbgRegParms stackPageInterruptHeadroomBytes(AbstractInstruction * self_in_stackPageInterruptHeadroomBytes);
  static AbstractInstruction * NoDbgRegParms stopsFromto(AbstractInstruction * self_in_stopsFromto, sqInt startAddr, sqInt endAddr);
  static sqInt NoDbgRegParms strbrnplusimm(AbstractInstruction * self_in_strbrnplusimm, sqInt destReg, sqInt baseReg, sqInt u, sqInt immediate12bitValue);
  static sqInt NoDbgRegParms strbrnrm(AbstractInstruction * self_in_strbrnrm, sqInt srcReg, sqInt baseReg, sqInt offsetReg);
  static sqInt NoDbgRegParms strhrnplusimm(AbstractInstruction * self_in_strhrnplusimm, sqInt destReg, sqInt baseReg, sqInt u, sqInt immediate8bitValue);
  static sqInt NoDbgRegParms strhrnrm(AbstractInstruction * self_in_strhrnrm, sqInt srcReg, sqInt baseReg, sqInt offsetReg);
  static sqInt NoDbgRegParms strrnplusImm(AbstractInstruction * self_in_strrnplusImm, sqInt srcReg, sqInt baseReg, sqInt immediate12bitValue);
  static sqInt NoDbgRegParms strrnplusimm(AbstractInstruction * self_in_strrnplusimm, sqInt destReg, sqInt baseReg, sqInt u, sqInt immediate12bitValue);
  static sqInt NoDbgRegParms strrnrm(AbstractInstruction * self_in_strrnrm, sqInt srcReg, sqInt baseReg, sqInt offsetReg);
  static sqInt NoDbgRegParms subsrnimmror(AbstractInstruction * self_in_subsrnimmror, sqInt destReg, sqInt srcReg, sqInt immediate, sqInt rot);
  static sqInt NoDbgRegParms subrnimmror(AbstractInstruction * self_in_subrnimmror, sqInt destReg, sqInt srcReg, sqInt immediate, sqInt rot);
  static sqInt NoDbgRegParms tstrnimmror(AbstractInstruction * self_in_tstrnimmror, sqInt ignored, sqInt srcReg, sqInt immediate, sqInt rot);
  static sqInt NoDbgRegParms zoneCallsAreRelative(AbstractInstruction * self_in_zoneCallsAreRelative);
  static CogMethod * NoDbgRegParms cmHomeMethod(CogBlockMethod * self_in_cmHomeMethod);
  static sqInt NoDbgRegParms isBranch(BytecodeDescriptor * self_in_isBranch);
  static AbstractInstruction * NoDbgRegParms gArithmeticShiftRightCqRR(sqInt quickConstant, sqInt srcReg, sqInt destReg);
  extern sqInt abortOffset(void);
  static void addCleanBlockStarts(void);
  extern void addCogMethodsToHeapMap(void);
  static sqInt NoDbgRegParms addressIsInCurrentCompilation(sqInt address);
  static sqInt NoDbgRegParms addressIsInFixups(BytecodeFixup *address);
  static sqInt NoDbgRegParms addressOfEndOfCaseinCPIC(sqInt n, CogMethod *cPIC);
  static void alignMethodZoneBase(void);
  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);
  static void assertValidDualZone(void);
  static sqInt NoDbgRegParms availableRegisterOrNoneIn(sqInt liveRegsMask);
  static sqInt NoDbgRegParms blockDispatchTargetsForperformarg(CogMethod *cogMethod, usqInt (*binaryFunction)(sqInt mcpc, sqInt arg), sqInt arg);
  extern sqInt bytecodePCForstartBcpcin(sqInt mcpc, sqInt startbcpc, CogBlockMethod *cogMethod);
  static AbstractInstruction * NoDbgRegParms CallFullRTregistersToBeSavedMask(sqInt callTarget, sqInt registersToBeSaved);
  static AbstractInstruction * NoDbgRegParms CallRT(sqInt callTarget);
  static AbstractInstruction * NoDbgRegParms gCall(sqInt callTarget);
  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 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 void NoDbgRegParms cogExtendPICCaseNMethodtagisMNUCase(CogMethod *cPIC, sqInt caseNMethod, sqInt caseNTag, sqInt isMNUCase);
  extern void cogitPostGCAction(sqInt gcMode);
  extern sqInt cogMethodDoesntLookKosher(CogMethod *cogMethod);
  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 sqInt NoDbgRegParms compileBlockDispatchFromto(sqInt lowBlockStartIndex, sqInt highBlockStartIndex);
  static void NoDbgRegParms compileBlockEntry(BlockStart *blockStart);
  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 void compileEntry(void);
  static sqInt compileMethodBody(void);
  static sqInt NoDbgRegParms compilePICAbort(sqInt numArgs);
  static AbstractInstruction * NoDbgRegParms compileStackOverflowCheck(sqInt canContextSwitch);
  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 configureCPICCase0Case1MethodtagisMNUCasenumArgsdelta(CogMethod *cPIC, CogMethod *case0CogMethod, sqInt case1Method, sqInt case1Tag, sqInt isMNUCase, sqInt numArgs, sqInt addrDelta);
  static sqInt NoDbgRegParms configureMNUCPICmethodOperandnumArgsdelta(CogMethod *cPIC, sqInt methodOperand, sqInt numArgs, sqInt addrDelta);
  static sqInt NoDbgRegParms cPICCompactAndIsNowEmpty(CogMethod *cPIC);
  static sqInt NoDbgRegParms cPICHasFreedTargets(CogMethod *cPIC);
  static usqInt 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);
  extern sqInt defaultCogCodeSize(void);
  static sqInt NoDbgRegParms deltaToSkipPrimAndErrorStoreInheader(sqInt aMethodObj, sqInt aMethodHeader);
  static sqInt NoDbgRegParms endPCOf(sqInt aMethod);
  extern void enterCogCodePopReceiver(void);
  static sqInt NoDbgRegParms entryPointTagIsSelector(sqInt entryPoint);
  static sqInt NoDbgRegParms expectedClosedPICPrototype(CogMethod *cPIC);
  static sqInt NoDbgRegParms fillInBlockHeadersAt(sqInt startAddress);
  static void NoDbgRegParms fillInMethodHeadersizeselector(CogMethod *method, sqInt size, sqInt selector);
  static sqInt NoDbgRegParms findBackwardBranchIsBackwardBranchMcpcBcpcMatchingBcpc(BytecodeDescriptor *descriptor, sqInt isBackwardBranchAndAnnotation, char *mcpc, sqInt bcpc, void *targetBcpc);
  static usqInt NoDbgRegParms findBlockMethodWithEntrystartBcpc(sqInt blockEntryMcpc, sqInt startBcpc);
  static usqInt NoDbgRegParms findMapLocationForMcpcinMethod(usqInt targetMcpc, CogMethod *cogMethod);
  extern CogBlockMethod * findMethodForStartBcpcinHomeMethod(sqInt startbcpc, CogMethod *cogMethod);
  static sqInt NoDbgRegParms findIsBackwardBranchMcpcBcpcMatchingMcpc(BytecodeDescriptor *descriptor, sqInt isBackwardBranchAndAnnotation, char *mcpc, sqInt bcpc, void *targetMcpc);
  static sqInt NoDbgRegParms firstMappedPCFor(CogMethod *cogMethod);
  static sqInt firstPrototypeMethodOop(void);
  static BytecodeFixup * NoDbgRegParms fixupAt(sqInt fixupPC);
  static AbstractInstruction * NoDbgRegParms genCallMustBeBooleanFor(sqInt boolean);
  static usqInt 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 NeverInline generateCaptureCStackPointers(sqInt captureFramePointer);
  static void generateClosedPICPrototype(void);
  static CogMethod * NoDbgRegParms generateCogMethod(sqInt selector);
  static sqInt NoDbgRegParms generateMapAtstart(usqInt addressOrNull, usqInt startAddress);
  static void generateOpenPICPrototype(void);
  static void generateRunTimeTrampolines(void);
  static void generateStackPointerCapture(void);
  static void generateTrampolines(void);
  static BytecodeDescriptor * NoDbgRegParms generatorForPC(sqInt pc);
  static void genGetLeafCallStackPointers(void);
  static usqInt NoDbgRegParms genInnerPICAbortTrampoline(char *name);
  static usqInt genInvokeInterpretTrampoline(void);
  static void NoDbgRegParms genLoadInlineCacheWithSelector(sqInt selectorIndex);
  static usqInt genNonLocalReturnTrampoline(void);
  static usqInt genReturnToInterpreterTrampoline(void);
  static usqInt NoDbgRegParms genReturnTrampolineForcalledarg(void *aRoutine, char *aString, sqInt regOrConst0);
  static sqInt NoDbgRegParms genSmalltalkToCStackSwitch(sqInt pushLinkReg);
  static usqInt NoDbgRegParms genTrampolineForcalled(void *aRoutine, char *aString);
  static usqInt NoDbgRegParms genTrampolineForcalledarg(void *aRoutine, char *aString, sqInt regOrConst0);
  static usqInt NoDbgRegParms genTrampolineForcalledargargargresult(void *aRoutine, char *aString, sqInt regOrConst0, sqInt regOrConst1, sqInt regOrConst2, sqInt resultReg);
  static usqInt NoDbgRegParms genTrampolineForcalledargargregsToSave(void *aRoutine, char *aString, sqInt regOrConst0, sqInt regOrConst1, sqInt regMask);
  static usqInt NoDbgRegParms genTrampolineForcalledargargresult(void *aRoutine, char *aString, sqInt regOrConst0, sqInt regOrConst1, sqInt resultReg);
  static usqInt NoDbgRegParms genTrampolineForcalledargregsToSave(void *aRoutine, char *aString, sqInt regOrConst0, sqInt regMask);
  static usqInt NoDbgRegParms genTrampolineForcalledargregsToSaveresult(void *aRoutine, char *aString, sqInt regOrConst0, sqInt regMask, sqInt resultReg);
  static usqInt NoDbgRegParms genTrampolineForcalledargresult(void *aRoutine, char *aString, sqInt regOrConst0, sqInt resultReg);
  static usqInt 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 usqInt NoDbgRegParms genTrampolineForcalledregsToSave(void *aRoutine, char *aString, sqInt regMask);
  static void NoDbgRegParms genTrampolineReturn(sqInt lnkRegWasPushed);
  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 sqInt NoDbgRegParms getLiteral(sqInt litIndex);
  static sqInt getOpcodeIndex(void);
  static sqInt NoDbgRegParms incrementUsageOfTargetIfLinkedSendmcpcignored(sqInt annotation, char *mcpc, sqInt superfluity);
  static sqInt initialClosedPICUsageCount(void);
  static void initializeBackend(void);
  extern void initializeCodeZoneFromupTo(sqInt startAddress, sqInt endAddress);
  static sqInt initialMethodUsageCount(void);
  static sqInt initialOpenPICUsageCount(void);
  static sqInt NoDbgRegParms inverseBranchFor(sqInt opcode);
  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 gLogicalShiftLeftCqRR(sqInt quickConstant, sqInt srcReg, sqInt destReg);
  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 AbstractInstruction * NoDbgRegParms gMoveMwrR(sqInt offset, sqInt baseReg, sqInt destReg);
  static usqInt NoDbgRegParms mapEndFor(CogMethod *cogMethod);
  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);
  static void markAndTraceMachineCodeForNewSpaceGC(void);
  static void markAndTraceObjectReferencesInGeneratedRuntime(void);
  extern void markAndTraceObjectsOrFreeMachineCode(sqInt inFullGC);
  static sqInt NoDbgRegParms markAndTraceOrFreeCogMethodfirstVisit(CogMethod *cogMethod, sqInt firstVisit);
  static void markAndTraceOrFreeMachineCodeForFullGC(void);
  static sqInt NoDbgRegParms markAndTraceOrFreePICTargetin(sqInt entryPoint, CogMethod *cPIC);
  static sqInt NoDbgRegParms markLiteralsAndUnlinkIfUnmarkedSendpcmethod(sqInt annotation, char *mcpc, sqInt cogMethod);
  extern void markMethodAndReferents(CogBlockMethod *aCogMethod);
  static sqInt NoDbgRegParms markYoungObjectspcmethod(sqInt annotation, char *mcpc, sqInt cogMethod);
  extern usqInt maxCogMethodAddress(void);
  static sqInt maybeAllocAndInitIRCs(void);
  static void NoDbgRegParms maybeFlushWritableZoneFromto(usqInt startAddress, usqInt endAddress);
  static sqInt NoDbgRegParms maybeFreeCogMethodDoesntLookKosher(CogMethod *cogMethod);
  static sqInt mclassIsSmallInteger(void);
  extern usqInt mcPCForBackwardBranchstartBcpcin(sqInt bcpc, sqInt startbcpc, CogBlockMethod *cogMethod);
  static sqInt NoDbgRegParms methodhasSameCodeAscheckPenultimate(sqInt methodA, sqInt methodB, sqInt comparePenultimateLiteral);
  extern usqInt minCogMethodAddress(void);
  extern sqInt mnuOffset(void);
  static AbstractInstruction * NoDbgRegParms gNativePopR(sqInt reg);
  static AbstractInstruction * NoDbgRegParms gNativePushR(sqInt reg);
  static AbstractInstruction * NoDbgRegParms gNativeRetN(sqInt offset);
  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 AbstractInstruction * NoDbgRegParms gOrCqRR(sqInt quickConstant, sqInt srcReg, sqInt destReg);
  static sqInt NoDbgRegParms outputInstructionsAt(sqInt startAddress);
  static sqInt NoDbgRegParms outputInstructionsForGeneratedRuntimeAt(sqInt startAddress);
  static AbstractInstruction * NoDbgRegParms gPushCw(sqInt wordConstant);
  extern sqInt patchToOpenPICFornumArgsreceiver(sqInt selector, sqInt numArgs, sqInt receiver);
  static sqInt picAbortDiscriminatorValue(void);
  static sqInt picInterpretAbortOffset(void);
  extern void printCogMethodFor(void *address);
  extern void printTrampolineTable(void);
  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 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 rewriteCPICCaseAttagobjReftarget(sqInt followingAddress, sqInt newTag, sqInt newObjRef, sqInt newTarget);
  static AbstractInstruction * NoDbgRegParms gSubCwR(sqInt wordConstant, sqInt reg);
  static sqInt scanForCleanBlocks(void);
  extern void setBreakMethod(sqInt anObj);
  extern void setPostCompileHook(void (*aFunction)(CogMethod *));
  extern void setSelectorOfto(CogMethod *cogMethod, sqInt aSelectorOop);
  static sqInt NoDbgRegParms spanForCleanBlockStartingAt(sqInt startPC);
  static sqInt subsequentPrototypeMethodOop(void);
  extern sqInt traceLinkedSendOffset(void);
  static sqInt NoDbgRegParms trampolineArgConstant(sqInt booleanOrInteger);
  static char * NoDbgRegParms trampolineNamenumArgs(char *routinePrefix, sqInt numArgs);
  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 unlinkIfLinkedSendToFreepcignored(sqInt annotation, char *mcpc, sqInt superfluity);
  static sqInt NoDbgRegParms unlinkIfLinkedSendpcignored(sqInt annotation, char *mcpc, sqInt superfluity);
  static sqInt NoDbgRegParms unlinkIfLinkedSendpctoMachineCodePrim(sqInt annotation, char *mcpc, sqInt ignored);
  static sqInt NoDbgRegParms unlinkIfLinkedSendpcto(sqInt annotation, char *mcpc, sqInt theCogMethod);
  extern void unlinkSendsOfisMNUSelector(sqInt selector, sqInt isMNUSelector);
  extern void unlinkSendsToFree(void);
  extern void unlinkSendsToMachineCodePrimitiveMethodsAndFreeIf(sqInt freeIfTrue);
  extern void unlinkSendsToandFreeIf(sqInt targetMethodObject, sqInt freeIfTrue);
  static sqInt varBaseAddress(void);
  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 addToOpenPICList(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);
  extern void freeMethod(CogMethod *cogMethod);
  static void freeOlderMethodsForCompaction(void);
  extern sqInt kosherYoungReferrers(void);
  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);
  extern sqInt pruneYoungReferrers(void);
  static sqInt relocateAndPruneYoungReferrers(void);
  static sqInt relocateMethodsPreCompaction(void);
  static sqInt NoDbgRegParms removeFromOpenPICList(CogMethod *anOpenPIC);
  static sqInt NoDbgRegParms roundUpLength(sqInt numBytes);
  static void voidOpenPICList(void);
  static void voidUnpairedMethodList(void);
  static void voidYoungReferrersPostTenureAll(void);
  extern char * whereIsMaybeCodeThing(sqInt anOop);
  static sqInt NoDbgRegParms checkValidObjectReference(sqInt anOop);
  static AbstractInstruction * NoDbgRegParms genCmpClassFloatCompactIndexR(sqInt reg);
  static AbstractInstruction * NoDbgRegParms genCmpClassMethodContextCompactIndexR(sqInt reg);
  static sqInt NoDbgRegParms genDoubleArithmeticpreOpCheck(sqInt arithmeticOperator, AbstractInstruction *(*preOpCheckOrNil)(int rcvrReg, int argReg));
  static sqInt NoDbgRegParms genDoubleComparisoninvert(AbstractInstruction * NoDbgRegParms (*jumpOpcodeGenerator)(void *), sqInt invertComparison);
  static sqInt NoDbgRegParms genLoadSlotsourceRegdestReg(sqInt index, sqInt sourceReg, sqInt destReg);
  static sqInt genPrimitiveAdd(void);
  static sqInt genPrimitiveAsCharacter(void);
  static sqInt genPrimitiveAsFloat(void);
  static sqInt genPrimitiveAtPut(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 genPrimitiveGreaterOrEqual(void);
  static sqInt genPrimitiveGreaterThan(void);
  static sqInt genPrimitiveHighBit(void);
  static sqInt genPrimitiveIdentical(void);
  static sqInt genPrimitiveImmediateAsInteger(void);
  static sqInt genPrimitiveIntegerAt(void);
  static sqInt genPrimitiveIntegerAtPut(void);
  static sqInt genPrimitiveLessOrEqual(void);
  static sqInt genPrimitiveLessThan(void);
  static sqInt genPrimitiveMod(void);
  static sqInt genPrimitiveMultiply(void);
  static sqInt genPrimitiveNew(void);
  static sqInt genPrimitiveNewMethod(void);
  static sqInt genPrimitiveNewWithArg(void);
  static sqInt genPrimitiveNotEqual(void);
  static sqInt genPrimitiveNotIdentical(void);
  static sqInt genPrimitiveObjectAt(void);
  static sqInt genPrimitiveQuo(void);
  static sqInt genPrimitiveShallowCopy(void);
  static sqInt genPrimitiveStringAtPut(void);
  static sqInt genPrimitiveStringCompareWith(void);
  static sqInt genPrimitiveStringReplace(void);
  static sqInt genPrimitiveSubtract(void);
  static sqInt NoDbgRegParms genPureDoubleArithmeticpreOpCheck(sqInt arithmeticOperator, AbstractInstruction *(*preOpCheckOrNil)(int rcvrReg, int argReg));
  static sqInt NoDbgRegParms genPureDoubleComparisoninvert(AbstractInstruction * NoDbgRegParms (*jumpOpcodeGenerator)(void *), sqInt invertComparison);
  static sqInt NoDbgRegParms genSmallIntegerComparison(sqInt jumpOpcode);
  static sqInt NoDbgRegParms genSmallIntegerComparisonorDoubleComparisoninvert(sqInt jumpOpcode, AbstractInstruction * NoDbgRegParms (*jumpFPOpcodeGenerator)(void *), sqInt invertComparison);
  static sqInt getActiveContextAllocatesInMachineCode(void);
  static sqInt NoDbgRegParms isUnannotatableConstant(CogSimStackEntry *simStackEntry);
  static sqInt NoDbgRegParms cacheTagIsMarked(sqInt cacheTag);
  static sqInt NoDbgRegParms checkValidOopReference(sqInt anOop);
  static sqInt NoDbgRegParms classForInlineCacheTag(sqInt inlineCacheTag);
  static sqInt compactClassFieldMask(void);
  static sqInt NoDbgRegParms couldBeObject(sqInt oop);
  static usqInt genActiveContextTrampoline(void);
  static sqInt NoDbgRegParms genAddSmallIntegerTagsTo(sqInt aRegister);
  static AbstractInstruction * NoDbgRegParms genAllocFloatValueintoscratchRegscratchReg(sqInt dpreg, sqInt resultReg, sqInt scratch1, sqInt scratch2);
  static sqInt NoDbgRegParms genClearAndSetSmallIntegerTagsIn(sqInt scratchReg);
  static sqInt NoDbgRegParms genConvertIntegerInRegtoSmallIntegerInReg(sqInt srcReg, sqInt destReg);
  static sqInt NoDbgRegParms genConvertIntegerToSmallIntegerInReg(sqInt reg);
  static sqInt NoDbgRegParms genConvertSmallIntegerToIntegerInReg(sqInt reg);
  static sqInt NoDbgRegParms genCreateClosureAtnumArgsnumCopiedcontextNumArgslargeinBlock(sqInt bcpc, sqInt numArgs, sqInt numCopied, sqInt ctxtNumArgs, sqInt isLargeCtxt, sqInt isInBlock);
  static void generateObjectRepresentationTrampolines(void);
  static void NoDbgRegParms genGetActiveContextNumArgslargeinBlock(sqInt numArgs, sqInt isLargeContext, sqInt isInBlock);
  static sqInt NoDbgRegParms genGetClassFormatOfNonIntintoscratchReg(sqInt instReg, sqInt destReg, sqInt scratchReg);
  static sqInt NoDbgRegParms genGetClassObjectOfintoscratchRegmayBeAForwarder(sqInt instReg, sqInt destReg, sqInt scratchReg, sqInt mayBeAForwarder);
  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 genGetFixedFieldsOfPointerNonIntintoscratchReg(sqInt instReg, sqInt destReg, sqInt scratchReg);
  static sqInt NoDbgRegParms genGetHashFieldNonImmOfasSmallIntegerInto(sqInt instReg, sqInt destReg);
  static AbstractInstruction * NoDbgRegParms genGetInlineCacheClassTagFromintoforEntry(sqInt sourceReg, sqInt destReg, sqInt forEntry);
  static AbstractInstruction * NoDbgRegParms genJumpImmediate(sqInt aRegister);
  static AbstractInstruction * NoDbgRegParms genJumpIsSmallIntegerValuescratch(sqInt aRegister, sqInt scratchReg);
  static AbstractInstruction * NoDbgRegParms genJumpNotSmallIntegerInScratchReg(sqInt aRegister);
  static AbstractInstruction * NoDbgRegParms genJumpNotSmallIntegerValuescratch(sqInt aRegister, sqInt scratchReg);
  static AbstractInstruction * NoDbgRegParms genJumpNotSmallInteger(sqInt aRegister);
  static AbstractInstruction * NoDbgRegParms genJumpSmallInteger(sqInt aRegister);
  static void NoDbgRegParms genNewArrayOfSizeinitialized(sqInt size, sqInt initialized);
  static sqInt genPrimitiveAt(void);
  static sqInt NoDbgRegParms genPrimitiveIdenticalOrNotIf(sqInt orNot);
  static sqInt genPrimitiveIdentityHash(void);
  static sqInt genPrimitiveSize(void);
  static sqInt genPrimitiveStringAt(void);
  static sqInt NoDbgRegParms genRemoveSmallIntegerTagsInScratchReg(sqInt scratchReg);
  static sqInt NoDbgRegParms genSetSmallIntegerTagsIn(sqInt scratchReg);
  static sqInt NoDbgRegParms genShiftAwaySmallIntegerTagsInScratchReg(sqInt scratchReg);
  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);
  static sqInt NoDbgRegParms inlineCacheTagForInstance(sqInt oop);
  static sqInt NoDbgRegParms inlineCacheTagIsYoung(sqInt cacheTag);
  static void NoDbgRegParms markAndTraceLiteralIfYoung(sqInt literal);
  static void NoDbgRegParms markAndTraceLiteral(sqInt literal);
  extern sqInt numRegArgs(void);
  static sqInt NoDbgRegParms remapObject(sqInt objOop);
  static sqInt NoDbgRegParms remapOop(sqInt oop);
  static sqInt NoDbgRegParms shouldAnnotateObjectReference(sqInt anOop);
  static sqInt NoDbgRegParms slotOffsetOfInstVarIndex(sqInt index);
  static sqInt NoDbgRegParms validInlineCacheTag(sqInt cacheTag);
  static sqInt NoDbgRegParms cmpC32RTempByteSize(AbstractInstruction * self_in_cmpC32RTempByteSize);
  static sqInt NoDbgRegParms concretizeLiteral(AbstractInstruction * self_in_concretizeLiteral);
  static sqInt 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 machineCodeBytes(AbstractInstruction * self_in_machineCodeBytes);
  static sqInt NoDbgRegParms nsSendCacheAt(AbstractInstruction * self_in_nsSendCacheAt, sqInt callSiteReturnAddress);
  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 AbstractInstruction * NoDbgRegParms rewriteInlineCacheTagat(AbstractInstruction * self_in_rewriteInlineCacheTagat, sqInt cacheTag, sqInt callSiteReturnAddress);
  static usqInt NoDbgRegParms sizePCDependentInstructionAt(AbstractInstruction * self_in_sizePCDependentInstructionAt, sqInt eventualAbsoluteAddress);
  static AbstractInstruction * NoDbgRegParms storeLiteralbeforeFollowingAddress(AbstractInstruction * self_in_storeLiteralbeforeFollowingAddress, sqInt literal, sqInt followingAddress);
  static AbstractInstruction * NoDbgRegParms updateLabel(AbstractInstruction * self_in_updateLabel, AbstractInstruction *labelInstruction);
  static sqInt NoDbgRegParms usesOutOfLineLiteral(AbstractInstruction * self_in_usesOutOfLineLiteral);
  static SimStackEntry * NoDbgRegParms ensureSpilledAtfrom(SimStackEntry * self_in_ensureSpilledAtfrom, sqInt baseOffset, sqInt baseRegister);
  static sqInt NoDbgRegParms isSameEntryAs(SimStackEntry * self_in_isSameEntryAs, CogSimStackEntry *ssEntry);
  static sqInt NoDbgRegParms mayBeAForwarder(SimStackEntry * self_in_mayBeAForwarder);
  static SimStackEntry * NoDbgRegParms popToReg(SimStackEntry * self_in_popToReg, sqInt reg);
  static sqInt NoDbgRegParms registerMask(SimStackEntry * self_in_registerMask);
  static sqInt NoDbgRegParms registerMaskOrNone(SimStackEntry * self_in_registerMaskOrNone);
  static sqInt NoDbgRegParms registerOrNone(SimStackEntry * self_in_registerOrNone);
  static SimStackEntry * NoDbgRegParms storeToReg(SimStackEntry * self_in_storeToReg, sqInt reg);
  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 NoDbgRegParms literalInstructionInRange(AbstractInstruction *litInst);
  static AbstractInstruction * NoDbgRegParms locateLiteral(sqInt aLiteral);
  static sqInt NoDbgRegParms mustDumpLiterals(sqInt currentOpcodeIndex);
  static sqInt NoDbgRegParms ceClosureCopyDescriptor(sqInt descriptor);
  extern sqInt cogMethodHasMachineCodePrim(CogMethod *aCogMethod);
  static sqInt compileBlockDispatch(void);
  static void compileGetErrorCode(void);
  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 extendedPushBytecode(void);
  static sqInt extendedStoreAndPopBytecode(void);
  static sqInt extendedStoreBytecode(void);
  static sqInt NoDbgRegParms frameOffsetOfTemporary(sqInt index);
  static AbstractInstruction * NoDbgRegParms genDoubleFailIfZeroArgRcvrarg(int rcvrReg, int argReg);
  static sqInt genExtendedSendBytecode(void);
  static sqInt genExtendedSuperBytecode(void);
  static sqInt genExtSendSuperBytecode(void);
  static sqInt genFastPrimFail(void);
  static void NoDbgRegParms genFastPrimTraceUsingand(sqInt r1, sqInt r2);
  static sqInt genLongJumpIfFalse(void);
  static sqInt genLongJumpIfTrue(void);
  static sqInt genLongStoreAndPopTemporaryVariableBytecode(void);
  static sqInt genLongUnconditionalBackwardJump(void);
  static sqInt genLongUnconditionalForwardJump(void);
  static sqInt NoDbgRegParms genLookupForPerformNumArgs(sqInt numArgs);
  static AbstractInstruction * NoDbgRegParms genMoveConstantR(sqInt constant, sqInt reg);
  static usqInt 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 genPushConstantTrueBytecode(void);
  static sqInt genPushLiteralConstantBytecode(void);
  static sqInt genPushLiteralVariableBytecode(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 genReturnTrue(void);
  static sqInt genSecondExtendedSendBytecode(void);
  static sqInt genSendLiteralSelector0ArgsBytecode(void);
  static sqInt genSendLiteralSelector1ArgBytecode(void);
  static sqInt genSendLiteralSelector2ArgsBytecode(void);
  static sqInt genShortJumpIfFalse(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);
  extern sqInt mapPCDataForinto(CogMethod *cogMethod, sqInt arrayObj);
  static sqInt numSpecialSelectors(void);
  static usqInt NoDbgRegParms pcDataForBlockEntryMethod(sqInt blockEntryMcpc, sqInt cogMethod);
  static sqInt NoDbgRegParms pcDataForAnnotationMcpcBcpcMethod(BytecodeDescriptor *descriptor, sqInt isBackwardBranchAndAnnotation, char *mcpc, sqInt bcpc, void *cogMethodArg);
  static PrimitiveDescriptor * primitiveGeneratorOrNil(void);
  extern void recordCallOffsetIn(CogMethod *cogMethod);
  extern void rewritePrimInvocationInto(CogMethod *cogMethod, void (*primFunctionPointer)(void));
  static sqInt NoDbgRegParms v3BlockCodeSize(BytecodeDescriptor *descriptor, sqInt pc, sqInt nExts, sqInt aMethodObj);
  static sqInt NoDbgRegParms v3LongForwardBranchDistance(BytecodeDescriptor *descriptor, sqInt pc, sqInt nExts, sqInt aMethodObj);
  static sqInt NoDbgRegParms v3LongBranchDistance(BytecodeDescriptor *descriptor, sqInt pc, sqInt nExts, sqInt aMethodObj);
  static sqInt NoDbgRegParms v3ShortForwardBranchDistance(BytecodeDescriptor *descriptor, sqInt pc, sqInt nExts, sqInt aMethodObj);
  extern void voidCogCompiledCode(void);
  static BlockStart * NoDbgRegParms addBlockStartAtnumArgsnumCopiedspan(sqInt bytecodepc, sqInt numArgs, sqInt numCopied, sqInt span);
  static void NoDbgRegParms adjustArgumentsForPerform(sqInt numArgs);
  static sqInt NoDbgRegParms allocateRegForStackEntryAtnotConflictingWith(sqInt index, sqInt regMask);
  static sqInt NoDbgRegParms allocateRegNotConflictingWith(sqInt regMask);
  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 sqInt compileBlockBodies(void);
  static void NoDbgRegParms compileBlockFrameBuild(BlockStart *blockStart);
  static void NoDbgRegParms compileBlockFramelessEntry(BlockStart *blockStart);
  static CogMethod * NoDbgRegParms compileCogMethod(sqInt selector);
  static sqInt compileEntireMethod(void);
  static void compileFrameBuild(void);
  #if IMMUTABILITY
  static void compileTwoPathFrameBuild(void);
  #endif /* IMMUTABILITY */
  static void compileTwoPathFramelessInit(void);
  static sqInt NoDbgRegParms cPICMissTrampolineFor(sqInt numArgs);
  static sqInt doubleExtendedDoAnythingBytecode(void);
  static sqInt duplicateTopBytecode(void);
  static BytecodeFixup * NoDbgRegParms ensureFixupAt(sqInt targetPC);
  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);
  static sqInt genBlockReturn(void);
  static void (*genCallPICEnilopmartNumArgs(sqInt numArgs))(void) ;
  static sqInt genExternalizePointersForPrimitiveCall(void);
  static void generateEnilopmarts(void);
  static sqInt NoDbgRegParms generateInstructionsAt(sqInt eventualAbsoluteAddress);
  static void generateMissAbortTrampolines(void);
  static void generateSendTrampolines(void);
  static void generateTracingTrampolines(void);
  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 genMarshalledSendnumArgssendTable(sqInt selectorIndex, sqInt numArgs, sqInt *sendTable);
  static usqInt NoDbgRegParms genMethodAbortTrampolineFor(sqInt numArgs);
  static usqInt NoDbgRegParms genPICAbortTrampolineFor(sqInt numArgs);
  static usqInt NoDbgRegParms genPICMissTrampolineFor(sqInt numArgs);
  static sqInt genPopStackBytecode(void);
  static sqInt genPrimitiveClosureValue(void);
  static sqInt genPrimitivePerform(void);
  static sqInt genPushActiveContextBytecode(void);
  static sqInt genPushClosureCopyCopiedValuesBytecode(void);
  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 genSendSupernumArgs(sqInt selectorIndex, sqInt numArgs);
  static usqInt 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);
  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);
  static sqInt genUpArrowReturn(void);
  static sqInt NoDbgRegParms genVanillaInlinedIdenticalOrNotIf(sqInt orNot);
  static void NoDbgRegParms initSimStackForFramefulMethod(sqInt startpc);
  static void NoDbgRegParms initSimStackForFramelessBlock(sqInt startpc);
  static void NoDbgRegParms initSimStackForFramelessMethod(sqInt startpc);
  static sqInt NoDbgRegParms isNonForwarderReceiver(sqInt reg);
  static sqInt liveRegisters(void);
  static sqInt NoDbgRegParms mapDeadDescriptorIfNeeded(BytecodeDescriptor *descriptor);
  static void NoDbgRegParms marshallSendArguments(sqInt numArgs);
  static sqInt maybeCompilingFirstPassOfBlockWithInitialPushNil(void);
  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 sqInt prevInstIsPCAnnotated(void);
  static sqInt receiverIsInReceiverResultReg(void);
  static void NoDbgRegParms reinitializeFixupsFromthrough(sqInt start, sqInt end);
  static sqInt NoDbgRegParms scanBlock(BlockStart *blockStart);
  static sqInt scanMethod(void);
  static void NoDbgRegParms ssAllocateRequiredRegMaskupThroughupThroughNative(sqInt requiredRegsMask, sqInt stackPtr, sqInt nativeStackPtr);
  static void NoDbgRegParms ssFlushUpThroughReceiverVariable(sqInt slotIndex);
  static void NoDbgRegParms ssFlushUpThroughTemporaryVariable(sqInt tempIndex);
  static void NoDbgRegParms ssPop(sqInt n);
  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 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 void NoDbgRegParms ssStorePoptoReg(sqInt popBoolean, sqInt reg);
  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 NoDbgRegParms v3PushNilSizenumInitialNils(sqInt aMethodObj, sqInt numInitialNils);
  static sqInt NoDbgRegParms v3NumPushNils(BytecodeDescriptor *descriptor, sqInt pc, sqInt nExts, sqInt aMethodObj);
  static sqInt violatesEnsureSpilledSpillAssert(void);
  static void voidReceiverResultRegContainsSelf(void);
  
  
  /*** Variables ***/
  static AbstractInstruction * abstractOpcodes;
  static usqInt baseAddress;
  static sqInt blockCount;
  static AbstractInstruction * blockEntryLabel;
  static AbstractInstruction * blockEntryNoContextSwitch;
  static BlockStart * blockStarts;
  static sqInt breakBlock;
  static sqInt breakMethod;
  static sqInt byte0;
  static sqInt byte1;
  static sqInt byte2;
  static sqInt byte3;
  static sqInt bytecodePC;
  static sqInt bytecodeSetOffset;
  static sqInt ceActiveContextTrampoline;
  static sqInt ceByteSizeOfTrampoline;
  static sqInt ceCheckFeaturesFunction;
  static sqInt ceCheckLZCNTFunction;
  static sqInt ceClosureCopyTrampoline;
  static sqInt ceCPICMissTrampoline;
  static sqInt ceCreateNewArrayTrampoline;
  static sqInt ceFetchContextInstVarTrampoline;
  static sqInt ceFFICalloutTrampoline;
  static sqInt ceFloatObjectOfTrampoline;
  static sqInt ceFloatValueOfTrampoline;
  static sqInt ceFlushICache;
  static sqInt ceFreeTrampoline;
  static sqInt ceInstantiateClassIndexableSizeTrampoline;
  static sqInt ceInstantiateClassTrampoline;
  static sqInt ceMallocTrampoline;
  static sqInt ceMethodAbortTrampoline;
  static sqInt ceNonLocalReturnTrampoline;
  static sqInt cePICAbortTrampoline;
  static sqInt cePositive32BitIntegerTrampoline;
  static sqInt cePositive32BitValueOfTrampoline;
  static sqInt cePositive64BitIntegerTrampoline;
  static sqInt cePositive64BitValueOfTrampoline;
  static sqInt cePrimReturnEnterCogCode;
  static sqInt cePrimReturnEnterCogCodeProfiling;
  static sqInt ceReapAndResetErrorCodeTrampoline;
  static sqInt ceSendMustBeBooleanAddFalseTrampoline;
  static sqInt ceSendMustBeBooleanAddTrueTrampoline;
  static sqInt ceSigned32BitIntegerTrampoline;
  static sqInt ceSigned32BitValueOfTrampoline;
  static sqInt ceSigned64BitIntegerTrampoline;
  static sqInt ceSigned64BitValueOfTrampoline;
  static sqInt ceStoreCheckTrampoline;
  static sqInt ceStoreContextInstVarTrampoline;
  static sqInt ceTraceBlockActivationTrampoline;
  static sqInt ceTraceLinkedSendTrampoline;
  static sqInt ceTraceStoreTrampoline;
  static sqInt checkedEntryAlignment;
  static sqInt closedPICSize;
  static sqInt codeBase;
  static sqInt cogConstituentIndex;
  static sqInt compactionInProgress;
  static sqInt compilationPass;
  static sqInt compilationTrace;
  static sqInt cPICCaseSize;
  static sqInt cPICEndOfCodeOffset;
  static sqInt cPICEndSize;
  static CogMethod * cPICPrototype;
  static sqInt currentCallCleanUpSize;
  static sqInt debugBytecodePointers;
  static sqInt debugFixupBreaks;
  static sqInt debugOpcodeIndices;
  static sqInt debugPrimCallStackOffset;
  static sqInt debugStackPointers;
  static sqInt directedSuperBindingSendTrampolines;
  static sqInt directedSuperSendTrampolines;
  static sqInt disassemblingMethod;
  static AbstractInstruction * endCPICCase0;
  static sqInt endPC;
  static AbstractInstruction * entry;
  static sqInt entryPointMask;
  static CogMethod * enumeratingCogMethod;
  static sqInt expectedFPAlignment;
  static sqInt expectedSPAlignment;
  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, 0, 1, 0, 0 },
  	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
  	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
  	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
  	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
  	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
  	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
  	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
  	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
  	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
  	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
  	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
  	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
  	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
  	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
  	{ genPushReceiverVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
  	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushTemporaryVariableBytecode, 0, needsFrameIfMod16GENumArgs, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushLiteralVariableBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genStoreAndPopReceiverVariableBytecode, 0, needsFrameIfImmutability, -1, 0, 1, 0, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 1, 0 },
  	{ genStoreAndPopReceiverVariableBytecode, 0, needsFrameIfImmutability, -1, 0, 1, 0, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 1, 0 },
  	{ genStoreAndPopReceiverVariableBytecode, 0, needsFrameIfImmutability, -1, 0, 1, 0, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 1, 0 },
  	{ genStoreAndPopReceiverVariableBytecode, 0, needsFrameIfImmutability, -1, 0, 1, 0, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 1, 0 },
  	{ genStoreAndPopReceiverVariableBytecode, 0, needsFrameIfImmutability, -1, 0, 1, 0, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 1, 0 },
  	{ genStoreAndPopReceiverVariableBytecode, 0, needsFrameIfImmutability, -1, 0, 1, 0, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 1, 0 },
  	{ genStoreAndPopReceiverVariableBytecode, 0, needsFrameIfImmutability, -1, 0, 1, 0, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 1, 0 },
  	{ genStoreAndPopReceiverVariableBytecode, 0, needsFrameIfImmutability, -1, 0, 1, 0, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 1, 0 },
  	{ genStoreAndPopTemporaryVariableBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genStoreAndPopTemporaryVariableBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genStoreAndPopTemporaryVariableBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genStoreAndPopTemporaryVariableBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genStoreAndPopTemporaryVariableBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genStoreAndPopTemporaryVariableBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genStoreAndPopTemporaryVariableBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genStoreAndPopTemporaryVariableBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushReceiverBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushConstantTrueBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushConstantFalseBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushConstantNilBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushQuickIntegerConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushQuickIntegerConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushQuickIntegerConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushQuickIntegerConstantBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genReturnReceiver, 0, needsFrameIfInBlock, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0 },
  	{ genReturnTrue, 0, needsFrameIfInBlock, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0 },
  	{ genReturnFalse, 0, needsFrameIfInBlock, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0 },
  	{ genReturnNil, 0, needsFrameIfInBlock, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0 },
  	{ genReturnTopFromMethod, 0, needsFrameIfInBlock, -1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0 },
  	{ genReturnTopFromBlock, 0, needsFrameNever, -1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 },
  	{ unknownBytecode, 0, 0, 0, Nop, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
  	{ unknownBytecode, 0, 0, 0, Nop, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
  	{ extendedPushBytecode, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },
  	{ extendedStoreBytecode, 0, 0, 0, 0, 2, 0, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 0, 0 },
  	{ extendedStoreAndPopBytecode, 0, 0, 0, 0, 2, 0, 0, 0, 0, IMMUTABILITY, 0, 0, 1, 0, 0 },
  	{ genExtendedSendBytecode, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ doubleExtendedDoAnythingBytecode, 0, 0, 0, 0, 3, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genExtendedSuperBytecode, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0 },
  	{ genSecondExtendedSendBytecode, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genPopStackBytecode, 0, needsFrameNever, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ duplicateTopBytecode, 0, needsFrameNever, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushActiveContextBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushNewArrayBytecode, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ unknownBytecode, 0, 0, 0, Nop, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 },
  	{ genPushRemoteTempLongBytecode, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genStoreRemoteTempLongBytecode, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genStoreAndPopRemoteTempLongBytecode, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genPushClosureCopyCopiedValuesBytecode, v3BlockCodeSize, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
  	{ genShortUnconditionalJump, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genShortUnconditionalJump, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genShortUnconditionalJump, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genShortUnconditionalJump, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genShortUnconditionalJump, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genShortUnconditionalJump, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genShortUnconditionalJump, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genShortUnconditionalJump, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genShortJumpIfFalse, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genShortJumpIfFalse, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genShortJumpIfFalse, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genShortJumpIfFalse, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genShortJumpIfFalse, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genShortJumpIfFalse, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genShortJumpIfFalse, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genShortJumpIfFalse, v3ShortForwardBranchDistance, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genLongUnconditionalBackwardJump, v3LongBranchDistance, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genLongUnconditionalBackwardJump, v3LongBranchDistance, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genLongUnconditionalBackwardJump, v3LongBranchDistance, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genLongUnconditionalBackwardJump, v3LongBranchDistance, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genLongUnconditionalForwardJump, v3LongBranchDistance, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genLongUnconditionalForwardJump, v3LongBranchDistance, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genLongUnconditionalForwardJump, v3LongBranchDistance, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genLongUnconditionalForwardJump, v3LongBranchDistance, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genLongJumpIfTrue, v3LongForwardBranchDistance, 0, 0, 0, 2, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genLongJumpIfTrue, v3LongForwardBranchDistance, 0, 0, 0, 2, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genLongJumpIfTrue, v3LongForwardBranchDistance, 0, 0, 0, 2, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genLongJumpIfTrue, v3LongForwardBranchDistance, 0, 0, 0, 2, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genLongJumpIfFalse, v3LongForwardBranchDistance, 0, 0, 0, 2, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genLongJumpIfFalse, v3LongForwardBranchDistance, 0, 0, 0, 2, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genLongJumpIfFalse, v3LongForwardBranchDistance, 0, 0, 0, 2, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genLongJumpIfFalse, v3LongForwardBranchDistance, 0, 0, 0, 2, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorArithmetic, 0, 0, 0, AddRR, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorArithmetic, 0, 0, 0, SubRR, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorComparison, 0, 0, 0, JumpLess, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorComparison, 0, 0, 0, JumpGreater, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorComparison, 0, 0, 0, JumpLessOrEqual, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorComparison, 0, 0, 0, JumpGreaterOrEqual, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorComparison, 0, 0, 0, JumpZero, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorComparison, 0, 0, 0, JumpNonZero, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorArithmetic, 0, 0, 0, AndRR, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorArithmetic, 0, 0, 0, OrRR, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorEqualsEquals, 0, needsFrameNever, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorClass, 0, needsFrameIfStackGreaterThanOne, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorNotEqualsEquals, 0, needsFrameNever, -1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSpecialSelectorSend, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector0ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector1ArgBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 },
  	{ genSendLiteralSelector2ArgsBytecode, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 }
  };
  static sqInt guardPageSize;
  static sqInt initialPC;
  static sqInt introspectionData;
  static sqInt introspectionDataIndex;
  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 sqInt methodObj;
  static sqInt methodOrBlockNumArgs;
  static sqInt methodOrBlockNumTemps;
  static usqInt methodZoneBase;
  static usqIntptr_t minValidCallAddress;
  static usqInt mzFreeStart;
  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 AbstractInstruction * picMNUAbort;
  static BytecodeDescriptor * prevBCDescriptor;
  static AbstractInstruction * primInvokeInstruction;
  static PrimitiveDescriptor primitiveGeneratorTable[MaxCompiledPrimitiveIndex+1] = {
  	{ 0, -1 },
  	{ genPrimitiveAdd, 1 },
  	{ genPrimitiveSubtract, 1 },
  	{ genPrimitiveLessThan, 1 },
  	{ genPrimitiveGreaterThan, 1 },
  	{ genPrimitiveLessOrEqual, 1 },
  	{ genPrimitiveGreaterOrEqual, 1 },
  	{ genPrimitiveEqual, 1 },
  	{ genPrimitiveNotEqual, 1 },
  	{ genPrimitiveMultiply, 1 },
  	{ genPrimitiveDivide, 1 },
  	{ genPrimitiveMod, 1 },
  	{ genPrimitiveDiv, 1 },
  	{ genPrimitiveQuo, 1 },
  	{ genPrimitiveBitAnd, 1 },
  	{ genPrimitiveBitOr, 1 },
  	{ genPrimitiveBitXor, 1 },
  	{ genPrimitiveBitShift, 1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ genPrimitiveAsFloat, 0 },
  	{ genPrimitiveFloatAdd, 1 },
  	{ genPrimitiveFloatSubtract, 1 },
  	{ genPrimitiveFloatLessThan, 1 },
  	{ genPrimitiveFloatGreaterThan, 1 },
  	{ genPrimitiveFloatLessOrEqual, 1 },
  	{ genPrimitiveFloatGreaterOrEqual, 1 },
  	{ genPrimitiveFloatEqual, 1 },
  	{ genPrimitiveFloatNotEqual, 1 },
  	{ genPrimitiveFloatMultiply, 1 },
  	{ genPrimitiveFloatDivide, 1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ genPrimitiveFloatSquareRoot, 0 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ genPrimitiveAt, 1 },
  	{ genPrimitiveAtPut, 2 },
  	{ genPrimitiveSize, 0 },
  	{ genPrimitiveStringAt, 1 },
  	{ genPrimitiveStringAtPut, 2 },
  	{ genFastPrimFail, -1 },
  	{ genFastPrimFail, -1 },
  	{ genFastPrimFail, -1 },
  	{ genPrimitiveObjectAt, 1 },
  	{ 0, -1 },
  	{ genPrimitiveNew, 0 },
  	{ genPrimitiveNewWithArg, 1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ genPrimitiveIdentityHash, 0 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ genPrimitiveNewMethod, 2 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ genPrimitivePerform, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ genPrimitiveStringReplace, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ genPrimitiveIdentical, 1 },
  	{ genPrimitiveClass, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ genPrimitiveShallowCopy, 0 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ genPrimitiveStringCompareWith, 1 },
  	{ genPrimitiveHashMultiply, 0 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ genPrimitiveIntegerAt, 1 },
  	{ genPrimitiveIntegerAtPut, 2 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ genPrimitiveNotIdentical, 1 },
  	{ genPrimitiveAsCharacter, -1 },
  	{ genPrimitiveImmediateAsInteger, 0 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ genPrimitiveIdentityHash, 0 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ genFastPrimFail, -1 },
  	{ genFastPrimFail, -1 },
  	{ 0, -1 },
  	{ genPrimitiveClosureValue, 0 },
  	{ genPrimitiveClosureValue, 1 },
  	{ genPrimitiveClosureValue, 2 },
  	{ genPrimitiveClosureValue, 3 },
  	{ genPrimitiveClosureValue, 4 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ genPrimitiveClosureValue, 0 },
  	{ genPrimitiveClosureValue, 1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ 0, -1 },
  	{ genPrimitiveHighBit, 0 }
  };
  static sqInt primitiveIndex;
  static AbstractInstruction * primSetFunctionLabel;
  static sqInt receiverTags;
  static sqInt runtimeObjectRefIndex;
  static AbstractInstruction * sendMiss;
  static sqInt simNativeStackPtr;
  static sqInt simSpillBase;
  static SimStackEntry simStack[70];
  static sqInt simStackPtr;
  static AbstractInstruction * stackCheckLabel;
  static AbstractInstruction * stackOverflowCall;
  static sqInt superSendTrampolines[NumSendTrampolines];
  static sqInt tempOop;
  static char *trampolineAddresses[NumTrampolines*2];
  static sqInt trampolineTableIndex;
  static sqInt uncheckedEntryAlignment;
  static usqInt unpairedMethodList;
  static usqInt youngReferrers;
  static unsigned char codeModified;
  static unsigned char deadCode;
  static unsigned char directedSendUsesBinding;
  static unsigned char hasMovableLiteral;
  static unsigned char hasYoungReferent;
  static unsigned char inBlock;
  static unsigned char needsFrame;
  static unsigned char regArgsHaveBeenPushed;
  static unsigned char useTwoPaths;
  static AbstractInstruction aMethodLabel;
  static AbstractInstruction * const backEnd = &aMethodLabel;
  #if DUAL_MAPPED_CODE_ZONE
  static void (*ceFlushDCache)(usqIntptr_t from, usqIntptr_t to);
  #endif
  #if DUAL_MAPPED_CODE_ZONE
  static sqInt codeToDataDelta;
  #else
  # define codeToDataDelta 0
  #endif
  static AbstractInstruction * const methodLabel = &aMethodLabel;
  static void (*postCompileHook)(CogMethod *);
  sqInt blockNoContextSwitchOffset;
  sqInt breakPC;
  sqInt cbEntryOffset;
  sqInt cbNoSwitchEntryOffset;
  sqInt ceBaseFrameReturnTrampoline;
  sqInt ceCannotResumeTrampoline;
  sqInt ceCheckForInterruptTrampoline;
  sqInt ceReturnToInterpreterTrampoline;
  sqInt cFramePointerInUse;
  sqInt cmEntryOffset;
  sqInt cmNoCheckEntryOffset;
  sqInt missOffset;
  int traceFlags = 8 /* prim trace log on by default */;
  sqInt traceStores;
  void (*ceCall0ArgsPIC)(void);
  void (*ceCall1ArgsPIC)(void);
  void (*ceCall2ArgsPIC)(void);
  void (*ceCallCogCodePopReceiverAndClassRegs)(void);
  void (*ceCallCogCodePopReceiverArg0Regs)(void);
  void (*ceCallCogCodePopReceiverArg1Arg0Regs)(void);
  void (*ceCallCogCodePopReceiverReg)(void);
  void (*ceCaptureCStackPointers)(void);
  void (*ceEnterCogCodePopReceiverReg)(void);
  usqIntptr_t (*ceGetFP)(void);
  usqIntptr_t (*ceGetSP)(void);
  void (*ceInvokeInterpret)(void);
  #if COGMTVM
  usqIntptr_t (*ceTryLockVMOwner)(void);
  void (*ceUnlockVMOwner)(void);
  #endif /* COGMTVM */
  void (*realCECallCogCodePopReceiverAndClassRegs)(void);
  void (*realCECallCogCodePopReceiverArg0Regs)(void);
  void (*realCECallCogCodePopReceiverArg1Arg0Regs)(void);
  void (*realCECallCogCodePopReceiverReg)(void);
  void (*realCEEnterCogCodePopReceiverReg)(void);
  
  
  /*** Macros ***/
  #define inlineCacheValueForSelectorin(backEnd,selector,aCogMethod) (selector)
  #define roundUpToMethodAlignment(ignored,numBytes) ((numBytes) + 7 & -8)
  #define flushDCacheFromto(me,startAddress,endAddress) 0
  #define flushICacheFromto(me,startAddress,endAddress) __clear_cache((char*) startAddress, (char*) (endAddress ))
  #define cPICNumCases stackCheckOffset
  #define cPICNumCasesHack hack hack hack i.e. the getter macro does all the work
  #define abstractInstructionAt(index) (&abstractOpcodes[index])
  #define addressIsInInstructions(address) (!((usqInt)(address) & (BytesPerWord-1)) \
  							&& (address) >= &abstractOpcodes[0] \
  							&& (address) < &abstractOpcodes[opcodeIndex])
  #define allocateBlockStarts(numBlocks) do { \
  		blockStarts = (numBlocks) ? alloca(sizeof(BlockStart) * (numBlocks)) : 0; \
  } while (0)
  #define assertValidDualZoneReadAddress(address) 0
  #define assertValidDualZoneWriteAddress(address) 0
  #define backEnd() backEnd
  #define blockAlignment() 8
  #define blockStartAt(index) (&blockStarts[index])
  #define breakOnImplicitReceiver() (traceFlags & 64)
  #define ceBaseFrameReturnPC() ceBaseFrameReturnTrampoline
  #define ceCannotResumePC() ((usqInt)ceCannotResumeTrampoline)
  #define ceCheckFeatures() ceCheckFeaturesFunction()
  #define ceCheckLZCNT() ceCheckLZCNTFunction()
  #define ceReturnToInterpreterPC() ((usqInt)ceReturnToInterpreterTrampoline)
  #define codeByteAtput(address,value) byteAtput((address) + codeToDataDelta, value)
  #define codeLong32Atput(address,value) long32Atput((address) + codeToDataDelta, value)
  #define codeLong64Atput(address,value) long64Atput((address) + codeToDataDelta, value)
  #define codeLongAtput(address,value) longAtput((address) + codeToDataDelta, value)
  #define codeMemcpy(dest,src,bytes) memcpy(dest,src,bytes)
  #define codeMemmove(dest,src,bytes) memmove((char *)(dest)+codeToDataDelta,src,bytes)
  #define compileSendTrace() ((traceFlags & 258) == 258)
  #define cr() putchar('\n')
  #define entryOffset() cmEntryOffset
  #define generatorAt(index) (&generatorTable[index])
  #define getCodeToDataDelta() codeToDataDelta
  #define getIsObjectReference() 2
  #define halt() warning("halt")
  #define haltmsg(msg) warning("halt: " msg)
  #define interpretOffset() missOffset
  #define maxCogCodeSize() (16*1024*1024)
  #define maybeBreakGeneratingFromto(address,end) 0
  #define maybeHaltIfDebugPC() 0
  #define methodLabel() methodLabel
  #define methodZoneBase() methodZoneBase
  #define minCallAddress() minValidCallAddress
  #define noCheckEntryOffset() cmNoCheckEntryOffset
  #define noContextSwitchBlockEntryOffset() blockNoContextSwitchOffset
  #define notYetImplemented() warning("not yet implemented")
  #define printNum(n) printf("%" PRIdSQINT, (sqInt) (n))
  #define printOnTrace() (traceFlags & 1)
  #define print(aString) 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 setHasMovableLiteral(b) (hasMovableLiteral = (b))
  #define setHasYoungReferent(b) (hasYoungReferent = (b))
  #define tryLockVMOwner() (ceTryLockVMOwner() != 0)
  #define unlockVMOwner() ceUnlockVMOwner()
  #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 youngReferrers() youngReferrers
  #define maybeConstant(sse) ((sse)->constant)
  #define literalInstructionAt(index) (&literals[index])
  #define fullBlockEntryOffset() cbEntryOffset
  #define fullBlockNoContextSwitchEntryOffset() cbNoSwitchEntryOffset
  #define fixupAtIndex(index) (&fixups[index])
  #define simNativeStackAt(index) (simNativeStack + (index))
  #define simSelf() simStack
  #define simStackAt(index) (simStack + (index))
  #define traceDescriptor(ign) 0
  #define traceFixupmerge(igu,ana) 0
  #define traceMerge(ign) 0
  #define traceSimStack() 0
  #define traceSpill(ign) 0
  #define allocatype(numElements, elementType) alloca((numElements)*sizeof(elementType))
  #define numElementsIn(anArray) (sizeof(anArray)/sizeof(anArray[0]))
  #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)) == null)) {
  		(anInstruction->dependent = (self_in_addDependent->dependent));
  	}
  	return ((self_in_addDependent->dependent) = anInstruction);
  }
  
  
  /*	Answer an unused abstract register in the liveRegMask.
  	Subclasses with more registers can override to answer them. */
  
  	/* CogAbstractInstruction>>#availableFloatRegisterOrNoneFor: */
  static sqInt NoDbgRegParms
  availableFloatRegisterOrNoneFor(AbstractInstruction * self_in_availableFloatRegisterOrNoneFor, sqInt liveRegsMask)
  {
  	if (!(liveRegsMask & (1U << DPFPReg0))) {
  		return DPFPReg0;
  	}
  	if (!(liveRegsMask & (1U << DPFPReg1))) {
  		return DPFPReg1;
  	}
  	if (!(liveRegsMask & (1U << DPFPReg2))) {
  		return DPFPReg2;
  	}
  	if (!(liveRegsMask & (1U << DPFPReg3))) {
  		return DPFPReg3;
  	}
  	if (!(liveRegsMask & (1U << DPFPReg4))) {
  		return DPFPReg4;
  	}
  	if (!(liveRegsMask & (1U << DPFPReg5))) {
  		return DPFPReg5;
  	}
  	if (!(liveRegsMask & (1U << DPFPReg6))) {
  		return DPFPReg6;
  	}
  	if (!(liveRegsMask & (1U << DPFPReg7))) {
  		return DPFPReg7;
  	}
  	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;
  }
  
  
  /*	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). */
  
  	/* CogAbstractInstruction>>#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, NativeSPReg));
  	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).
  	N.B. CoInterpreter stack layout dictates that the stack pointer should be
  	loaded first.
  	The stack zone is allocated on the C stack before the interpreter runs and
  	hence before CStackPointer and CFramePointer are captured. So when running
  	in machine
  	code the native stack pointer and frame pointer appear to be on a colder
  	part of the
  	stack to CStackPointer and CFramePointer. When CStackPointerhas been set
  	and the frame pointer is still in machine code the current frame looks
  	like it has lots of
  	stack. If the frame pointer was set to CFramePointer before hand then it
  	would be beyond the stack pointer for that one instruction. */
  
  	/* CogAbstractInstruction>>#genLoadCStackPointers */
  static sqInt NoDbgRegParms
  genLoadCStackPointers(AbstractInstruction * self_in_genLoadCStackPointers)
  {
      sqInt address;
      sqInt address1;
  
  	/* begin MoveAw:R: */
  	address = cStackPointerAddress();
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(address, genoperandoperand(MoveAwR, address, NativeSPReg));
  	/* begin MoveAw:R: */
  	address1 = cFramePointerAddress();
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(address1, genoperandoperand(MoveAwR, address1, FPReg));
  	return 0;
  }
  
  
  /*	Switch back to the Smalltalk stack. Assign SPReg first
  	because typically it is used immediately afterwards. */
  
  	/* CogAbstractInstruction>>#genLoadStackPointers */
  static sqInt NoDbgRegParms
  genLoadStackPointers(AbstractInstruction * self_in_genLoadStackPointers)
  {
      sqInt address;
      sqInt address1;
  
  	/* begin MoveAw:R: */
  	address = stackPointerAddress();
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(address, genoperandoperand(MoveAwR, address, SPReg));
  	/* begin MoveAw:R: */
  	address1 = framePointerAddress();
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(address1, genoperandoperand(MoveAwR, address1, FPReg));
  	return 0;
  }
  
  
  /*	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. */
  
  	/* CogAbstractInstruction>>#genSaveStackPointers */
  static sqInt NoDbgRegParms
  genSaveStackPointers(AbstractInstruction * self_in_genSaveStackPointers)
  {
      sqInt address;
      sqInt address1;
  
  	/* begin MoveR:Aw: */
  	address = framePointerAddress();
  	/* begin gen:operand:literal: */
  	checkLiteralforInstruction(address, genoperandoperand(MoveRAw, FPReg, address));
  	/* begin MoveR:Aw: */
  	address1 = stackPointerAddress();
  	/* begin gen:operand:literal: */
  	checkLiteralforInstruction(address1, genoperandoperand(MoveRAw, SPReg, address1));
  	return 0;
  }
  
  
  /*	Generic register swap code. Subclasses for processors that have a true
  	exchange operation will override to use it. */
  
  	/* CogAbstractInstruction>>#genSwapR:R:Scratch: */
  static AbstractInstruction * NoDbgRegParms
  genSwapRRScratch(AbstractInstruction * self_in_genSwapRRScratch, sqInt regA, sqInt regB, sqInt regTmp)
  {
      AbstractInstruction *first;
  
  	first = genoperandoperand(MoveRR, regA, regTmp);
  	genoperandoperand(MoveRR, regB, regA);
  	genoperandoperand(MoveRR, TempReg, regB);
  	return first;
  }
  
  	/* CogAbstractInstruction>>#genWriteCResultIntoReg: */
  static AbstractInstruction * NoDbgRegParms
  genWriteCResultIntoReg(AbstractInstruction * self_in_genWriteCResultIntoReg, sqInt abstractRegister)
  {
  	if ((abstractRegister != NoReg)
  	 && (abstractRegister != ABIResultReg)) {
  		genoperandoperand(MoveRR, ABIResultReg, 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;
  
  	/* separate := nil for Slang */
  	(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 + (((sqInt)((usqInt)(BytesPerOop) << 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;
  
  	/* separate := nil for Slang */
  	(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 + (((sqInt)((usqInt)(BytesPerOop) << 1))));
  	((self_in_initializeUniqueLiteral->operands))[2] = -1;
  	return self_in_initializeUniqueLiteral;
  }
  
  	/* CogAbstractInstruction>>#isAnInstruction: */
  static sqInt NoDbgRegParms
  isAnInstruction(AbstractInstruction * self_in_isAnInstruction, AbstractInstruction *addressOrInstruction)
  {
  	return (addressIsInInstructions(addressOrInstruction))
  	 || (addressOrInstruction == (methodLabel()));
  }
  
  	/* 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;
  }
  
  
  /*	Rewrite a conditional jump long to jump to target. This version defaults
  	to using
  	rewriteJumpLongAt:, which works for many ISAs. Subclasses override if
  	necessary.  */
  
  	/* CogAbstractInstruction>>#rewriteConditionalJumpLongAt:target: */
  static sqInt NoDbgRegParms
  rewriteConditionalJumpLongAttarget(AbstractInstruction * self_in_rewriteConditionalJumpLongAttarget, sqInt callSiteReturnAddress, sqInt callTargetAddress)
  {
  	return rewriteJumpLongAttarget(self_in_rewriteConditionalJumpLongAttarget, callSiteReturnAddress, callTargetAddress);
  }
  
  
  /*	A hack hook to allow ARM to override the simulated address for the
  	short-cut trampolines,
  	and to allow x64 to address CStackPointer and CFramePointer relative to
  	VarBaseReg. 
   */
  
  	/* CogAbstractInstruction>>#wantsNearAddressFor: */
  static sqInt NoDbgRegParms
  wantsNearAddressFor(AbstractInstruction * self_in_wantsNearAddressFor, sqInt anObject)
  {
  	return 0;
  }
  
  
  /*	Remember the ROR is doubled by the cpu so use 30>>1 etc
  	ADDS destReg, srcReg, #immediate ROR #rot - ARM_ARM v7 DDI10406 p. A8-23 */
  
  	/* CogARMCompiler>>#adds:rn:imm:ror: */
  static sqInt NoDbgRegParms
  addsrnimmror(AbstractInstruction * self_in_addsrnimmror, sqInt destReg, sqInt srcReg, sqInt immediate, sqInt rot)
  {
  	return (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(AddOpcode) << 21))) | (0x100000)))) | ((((sqInt)((usqInt)(srcReg) << 16))) | (((sqInt)((usqInt)(destReg) << 12))))) | (((((sqInt)((usqInt)((((usqInt)(rot)) >> 1)) << 8))) | immediate) & 0xFFF);
  }
  
  
  /*	Remember the ROR is doubled by the cpu so use 30>>1 etc.
  	ADD destReg, srcReg, #immediate ROR #rot - ARM_ARM v7 DDI10406 p. A8-23 */
  
  	/* CogARMCompiler>>#add:rn:imm:ror: */
  static sqInt NoDbgRegParms
  addrnimmror(AbstractInstruction * self_in_addrnimmror, sqInt destReg, sqInt srcReg, sqInt immediate, sqInt rot)
  {
  	return (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(AddOpcode) << 21))) | (0)))) | ((((sqInt)((usqInt)(srcReg) << 16))) | (((sqInt)((usqInt)(destReg) << 12))))) | (((((sqInt)((usqInt)((((usqInt)(rot)) >> 1)) << 8))) | immediate) & 0xFFF);
  }
  
  
  /*	return an ADD destReg, srcReg, addReg instruction
  	ADD destReg, srcReg, addReg - ARM_ARM v7 DDI10406 p. A8-24 */
  
  	/* CogARMCompiler>>#add:rn:rm: */
  static sqInt NoDbgRegParms
  addrnrm(AbstractInstruction * self_in_addrnrm, sqInt destReg, sqInt srcReg, sqInt addReg)
  {
  	return (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(AddOpcode) << 21))) | (0)))) | ((((sqInt)((usqInt)(srcReg) << 16))) | (((sqInt)((usqInt)(destReg) << 12))))) | (addReg & 0xFFF);
  }
  
  
  /*	Answer the address of the __aeabi_idivmod() call provided by the ARM low
  	level libs to do an integer divide that returns the quo in R0 and rem in
  	R1. A word on the somewhat strange usage of idivmod herein; we need a
  	declaration for the _aeabi_idivmod helper function, despite the fact that
  	in a simple C program test, you don't.
  	To get that declaration we need a variable to hang it off; thus the
  	non-existent var idivmod, and in simulation we need to simulate it, which
  	is what aeabiDiv:Mod: does.
   */
  
  	/* CogARMCompiler>>#aeabiDivModFunctionAddr */
  static usqInt NoDbgRegParms
  aeabiDivModFunctionAddr(AbstractInstruction * self_in_aeabiDivModFunctionAddr)
  {
      extern void __aeabi_idivmod(int dividend, int divisor);
  
  	return (usqInt)__aeabi_idivmod;
  }
  
  
  /*	Remember the ROR is doubled by the cpu so use 30>>1 etc
  	ANDS destReg, srcReg, #immediate ROR #rot - ARM_ARM v7 DDI10406 p. A8-34 */
  
  	/* CogARMCompiler>>#ands:rn:imm:ror: */
  static sqInt NoDbgRegParms
  andsrnimmror(AbstractInstruction * self_in_andsrnimmror, sqInt destReg, sqInt srcReg, sqInt immediate, sqInt rot)
  {
  	return (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(AndOpcode) << 21))) | (0x100000)))) | ((((sqInt)((usqInt)(srcReg) << 16))) | (((sqInt)((usqInt)(destReg) << 12))))) | (((((sqInt)((usqInt)((((usqInt)(rot)) >> 1)) << 8))) | immediate) & 0xFFF);
  }
  
  
  /*	Remember the ROR is doubled by the cpu so use 30>>1 etc
  	AND destReg, srcReg, #immediate ROR #rot - ARM_ARM v7 DDI10406 p. A8-34 */
  
  	/* CogARMCompiler>>#and:rn:imm:ror: */
  static sqInt NoDbgRegParms
  andrnimmror(AbstractInstruction * self_in_andrnimmror, sqInt destReg, sqInt srcReg, sqInt immediate, sqInt rot)
  {
  	return (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(AndOpcode) << 21))) | (0)))) | ((((sqInt)((usqInt)(srcReg) << 16))) | (((sqInt)((usqInt)(destReg) << 12))))) | (((((sqInt)((usqInt)((((usqInt)(rot)) >> 1)) << 8))) | immediate) & 0xFFF);
  }
  
  
  /*	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. */
  
  	/* CogARMCompiler>>#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;
  }
  
  
  /*	Remember the ROR is doubled by the cpu so use 30>>1 etc
  	BICS destReg, srcReg, #immediate ROR #rot - ARM_ARM v7 DDI10406 pp.
  	A8-50-1 
   */
  
  	/* CogARMCompiler>>#bics:rn:imm:ror: */
  static sqInt NoDbgRegParms
  bicsrnimmror(AbstractInstruction * self_in_bicsrnimmror, sqInt destReg, sqInt srcReg, sqInt immediate, sqInt rot)
  {
  	return (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(BicOpcode) << 21))) | (0x100000)))) | ((((sqInt)((usqInt)(srcReg) << 16))) | (((sqInt)((usqInt)(destReg) << 12))))) | (((((sqInt)((usqInt)((((usqInt)(rot)) >> 1)) << 8))) | immediate) & 0xFFF);
  }
  
  
  /*	return a BL offset instruction; offset is signed 24bits of WORD offset, so
  	+_32Mbyte range. Return address is in LR
  	BL offset - ARM_ARM v7 DDI10406 pp. A8-58-9
   */
  
  	/* CogARMCompiler>>#bl: */
  static sqInt NoDbgRegParms
  bl(AbstractInstruction * self_in_bl, sqInt offset)
  {
  	return (((int)((usqInt)(AL) << 28))) | ((((int)((usqInt)((10 | (1 & 1))) << 24))) | ((((usqInt)(offset)) >> 2) & 0xFFFFFF));
  }
  
  
  /*	return a B offset instruction; offset is signed 24bits of WORD offset, so
  	+_32Mbyte range
  	B offset - ARM_ARM v7 DDI10406 pp. A8-44-5
   */
  
  	/* CogARMCompiler>>#b: */
  static sqInt NoDbgRegParms
  b(AbstractInstruction * self_in_b, sqInt offset)
  {
  	return (((int)((usqInt)(AL) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset)) >> 2) & 0xFFFFFF));
  }
  
  
  /*	ARMv8 calls and jumps span +/- 128 mb, more than enough for intra-zone
  	calls and jumps.
   */
  
  	/* CogARMCompiler>>#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:. */
  
  	/* CogARMCompiler>>#callTargetFromReturnAddress: */
  static sqInt NoDbgRegParms
  callTargetFromReturnAddress(AbstractInstruction * self_in_callTargetFromReturnAddress, sqInt callSiteReturnAddress)
  {
      sqInt call;
      sqInt callDistance;
      sqInt relativeJump;
  
  	call = longAt(callSiteReturnAddress - 4);
  	assert((instructionIsB(self_in_callTargetFromReturnAddress, call))
  	 || (instructionIsBL(self_in_callTargetFromReturnAddress, call)));
  	/* begin extractOffsetFromBL: */
  	relativeJump = call & 0xFFFFFF;
  	relativeJump = (relativeJump & (0x800000)
  		? ((int) (((sqInt)((usqInt)((relativeJump | 0x3F000000)) << 2))))
  		: ((sqInt)((usqInt)(relativeJump) << 2)));
  	callDistance = relativeJump;
  	return (callSiteReturnAddress + 4) + (((int) callDistance));
  }
  
  
  /*	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. */
  
  	/* CogARMCompiler>>#computeMaximumSize */
  static sqInt NoDbgRegParms
  computeMaximumSize(AbstractInstruction * self_in_computeMaximumSize)
  {
      sqInt constant;
      sqInt constant1;
      sqInt constant2;
      sqInt constant4;
      sqInt constant5;
      sqInt i;
      sqInt i1;
      sqInt i2;
      sqInt i3;
      sqInt n;
      sqInt r;
      sqInt value;
      unsigned int value1;
  
  	
  	switch ((self_in_computeMaximumSize->opcode)) {
  	case Label:
  		return 0;
  
  	case Literal:
  	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 JumpLongZero:
  	case JumpLongNonZero:
  	case Stop:
  	case AddRR:
  	case AndRR:
  	case CmpRR:
  	case OrRR:
  	case XorRR:
  	case SubRR:
  	case AddRRR:
  	case SubRRR:
  	case NegateR:
  	case LogicalShiftLeftCqR:
  	case LogicalShiftRightCqR:
  	case ArithmeticShiftRightCqRR:
  	case LogicalShiftRightCqRR:
  	case LogicalShiftLeftCqRR:
  	case ArithmeticShiftRightCqR:
  	case LogicalShiftLeftRR:
  	case LogicalShiftRightRR:
  	case ArithmeticShiftRightRR:
  	case AddRdRd:
  	case CmpRdRd:
  	case SubRdRd:
  	case MulRdRd:
  	case DivRdRd:
  	case SqrtRd:
  	case ClzRR:
  	case SMULL:
  	case MSR:
  	case CMPSMULL:
  	case PopLDM:
  	case PushSTM:
  	case MoveRR:
  	case MoveRdRd:
  	case MoveRdM64r:
  	case MoveM64rRd:
  	case MoveXbrRR:
  	case MoveRXbrR:
  	case MoveXwrRR:
  	case MoveRXwrR:
  	case PopR:
  	case PushR:
  		return 4;
  
  	case AlignmentNops:
  		return (((self_in_computeMaximumSize->operands))[0]) - 4;
  
  	case CallFull:
  	case JumpFull:
  	case AddCwR:
  	case AndCwR:
  	case CmpCwR:
  	case OrCwR:
  	case SubCwR:
  	case XorCwR:
  		return 8;
  
  	case JumpFPEqual:
  	case JumpFPNotEqual:
  	case JumpFPLess:
  	case JumpFPGreaterOrEqual:
  	case JumpFPGreater:
  	case JumpFPLessOrEqual:
  	case JumpFPOrdered:
  	case JumpFPUnordered:
  	case ConvertRRd:
  		return 8;
  
  	case RetN:
  		return ((((self_in_computeMaximumSize->operands))[0]) == 0
  			? 4
  			: 8);
  
  	case AddCqR:
  	case AddCqRR:
  	case CmpCqR:
  	case SubCqR:
  		/* begin rotateable8bitSignedImmediate:ifTrue:ifFalse: */
  		constant = ((self_in_computeMaximumSize->operands))[0];
  		value = constant;
  		while (1) {
  			if ((value & 0xFF) == value) {
  				n = constant != value;
  				return 4;
  			}
  			for (i1 = 2; i1 <= 30; i1 += 2) {
  				if ((value & (((0xFFU << i1) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i1)))) == value) {
  					r = 32 - i1;
  					i = (((usqInt)(value)) >> i1) | ((((sqInt)((usqInt)(value) << (32 - i1)))) & 0xFFFFFFFFU);
  					n = constant != value;
  					return 4;
  				}
  			}
  			if (!((value == constant)
  			 && (constant != 0))) break;
  			value = -constant;
  		}
  		return 8;
  
  	case AndCqR:
  	case AndCqRR:
  	case XorCqR:
  		/* begin rotateable8bitBitwiseImmediate:ifTrue:ifFalse: */
  		constant1 = ((self_in_computeMaximumSize->operands))[0];
  		value1 = constant1;
  		while (1) {
  			if ((value1 & 0xFF) == value1) {
  				n = constant1 != value1;
  				return 4;
  			}
  			for (i2 = 2; i2 <= 30; i2 += 2) {
  				if ((value1 & (((0xFFU << i2) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i2)))) == value1) {
  					r = 32 - i2;
  					i = ((value1) >> i2) | ((value1 << (32 - i2)) & 0xFFFFFFFFU);
  					n = constant1 != value1;
  					return 4;
  				}
  			}
  			if (!(value1 == constant1)) break;
  			value1 = (constant1 < 0
  				? -1 - constant1
  				: (unsigned int)~constant1);
  		}
  		return 8;
  
  	case OrCqR:
  	case TstCqR:
  	case LoadEffectiveAddressMwrR:
  	case MoveM16rR:
  		/* begin rotateable8bitImmediate:ifTrue:ifFalse: */
  		constant2 = ((self_in_computeMaximumSize->operands))[0];
  		if ((constant2 & 0xFF) == constant2) {
  			return 4;
  		}
  		for (i3 = 2; i3 <= 30; i3 += 2) {
  			if ((constant2 & (((0xFFU << i3) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i3)))) == constant2) {
  				r = 32 - i3;
  				i = (((usqInt)(constant2)) >> i3) | ((((sqInt)((usqInt)(constant2) << (32 - i3)))) & 0xFFFFFFFFU);
  				return 4;
  			}
  		}
  		return 8;
  
  	case MoveCqR:
  		return 4 /* literalLoadInstructionBytes */;
  
  	case MoveCwR:
  		return 4 /* literalLoadInstructionBytes */;
  
  	case MoveAwR:
  	case MoveAbR:
  	case PrefetchAw:
  		return (((((self_in_computeMaximumSize->operands))[0]) != null)
  		 && (((((self_in_computeMaximumSize->operands))[0]) >= (varBaseAddress()))
  		 && (((((self_in_computeMaximumSize->operands))[0]) - (varBaseAddress())) < (4096)))
  			? 4
  			: 8);
  
  	case MoveRAw:
  	case MoveRAb:
  		return (((((self_in_computeMaximumSize->operands))[1]) != null)
  		 && (((((self_in_computeMaximumSize->operands))[1]) >= (varBaseAddress()))
  		 && (((((self_in_computeMaximumSize->operands))[1]) - (varBaseAddress())) < (4096)))
  			? 4
  			: 8);
  
  	case MoveRMwr:
  	case MoveRMbr:
  	case MoveRM16r:
  		/* begin is12BitValue:ifTrue:ifFalse: */
  		constant4 = ((self_in_computeMaximumSize->operands))[1];
  		if ((SQABS(constant4)) <= 0xFFF) {
  
  			/* (2 raisedTo: 12)-1 */
  			if (constant4 >= 0) {
  				return 4;
  			}
  			else {
  				i = SQABS(constant4);
  				return 4;
  			}
  		}
  		else {
  			return 8;
  		}
  
  	case MoveMbrR:
  	case MoveMwrR:
  		/* begin is12BitValue:ifTrue:ifFalse: */
  		constant5 = ((self_in_computeMaximumSize->operands))[0];
  		if ((SQABS(constant5)) <= 0xFFF) {
  
  			/* (2 raisedTo: 12)-1 */
  			if (constant5 >= 0) {
  				return 4;
  			}
  			else {
  				i = SQABS(constant5);
  				return 4;
  			}
  		}
  		else {
  			return 8;
  		}
  
  	case PushCw:
  		return 8;
  
  	case PushCq:
  		return 8;
  
  	default:
  		error("Case not found and no otherwise clause");
  	}
  	return 0;
  }
  
  
  /*	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. */
  
  	/* CogARMCompiler>>#concretizeAt: */
  static sqInt NoDbgRegParms
  concretizeAt(AbstractInstruction * self_in_concretizeAt, sqInt actualAddress)
  {
  	assert((actualAddress % 4) == 0);
  	(self_in_concretizeAt->address) = actualAddress;
  	(self_in_concretizeAt->machineCodeSize) = dispatchConcretize(self_in_concretizeAt);
  	assert((((self_in_concretizeAt->maxSize)) == null)
  	 || (((self_in_concretizeAt->maxSize)) >= ((self_in_concretizeAt->machineCodeSize))));
  	return actualAddress + ((self_in_concretizeAt->machineCodeSize));
  }
  
  
  /*	Generate a CMP a, b, ASR #31 instruction, specifically for comparing the
  	resutls of SMULLs in genMulR:R:
   */
  
  	/* CogARMCompiler>>#concretizeCMPSMULL */
  static sqInt NoDbgRegParms
  concretizeCMPSMULL(AbstractInstruction * self_in_concretizeCMPSMULL)
  {
      sqInt aWord;
      usqInt hiReg;
      usqInt loReg;
  
  	hiReg = ((self_in_concretizeCMPSMULL->operands))[0];
  	loReg = ((self_in_concretizeCMPSMULL->operands))[1];
  	/* begin machineCodeAt:put: */
  	aWord = (((((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(CmpOpcode) << 21))) | (0x100000)))) | ((hiReg << 16) | (0))) + (0xF80)) + (64)) + loReg;
  	((self_in_concretizeCMPSMULL->machineCode))[0 / 4] = aWord;
  	return 4;
  }
  
  
  /*	Concretize the current instruction, but with a condition. */
  
  	/* CogARMCompiler>>#concretizeConditionalInstruction */
  static usqInt NoDbgRegParms
  concretizeConditionalInstruction(AbstractInstruction * self_in_concretizeConditionalInstruction)
  {
      sqInt aWord;
      sqInt i;
      usqInt instr;
      unsigned char savedCond;
  
  	assert(((self_in_concretizeConditionalInstruction->conditionOrNil)) != null);
  	savedCond = (self_in_concretizeConditionalInstruction->conditionOrNil);
  	(self_in_concretizeConditionalInstruction->conditionOrNil) = null;
  	(self_in_concretizeConditionalInstruction->machineCodeSize) = dispatchConcretize(self_in_concretizeConditionalInstruction);
  	(self_in_concretizeConditionalInstruction->conditionOrNil) = savedCond;
  	for (i = 0; i < ((self_in_concretizeConditionalInstruction->machineCodeSize)); i += 4) {
  		instr = (((((self_in_concretizeConditionalInstruction->machineCode))[i / 4]) | (4026531840U)) - (4026531840U));
  		/* begin machineCodeAt:put: */
  		aWord = instr | (((int)((usqInt)((((self_in_concretizeConditionalInstruction->conditionOrNil)) & 15)) << 28)));
  		((self_in_concretizeConditionalInstruction->machineCode))[i / 4] = aWord;
  	}
  	return (self_in_concretizeConditionalInstruction->machineCodeSize);
  }
  
  
  /*	fill with operand 0 according to the processor's endianness */
  
  	/* CogARMCompiler>>#concretizeFill32 */
  static sqInt NoDbgRegParms
  concretizeFill32(AbstractInstruction * self_in_concretizeFill32)
  {
      sqInt aWord;
  
  	/* begin machineCodeAt:put: */
  	aWord = ((self_in_concretizeFill32->operands))[0];
  	((self_in_concretizeFill32->machineCode))[0 / 4] = aWord;
  	return 4;
  }
  
  
  /*	Generate an MSR CPSR_f, #flags instruction.
  	Note that we only have business with the NZCV flags so we use
  	N -> 8
  	Z -> 4
  	C -> 2
  	V -> 1.
  	You don't want to mess with this too much.
   */
  
  	/* CogARMCompiler>>#concretizeMSR */
  static sqInt NoDbgRegParms
  concretizeMSR(AbstractInstruction * self_in_concretizeMSR)
  {
      sqInt aWord;
      usqInt flags;
  
  	flags = ((self_in_concretizeMSR->operands))[0];
  	/* begin machineCodeAt:put: */
  	aWord = msr(self_in_concretizeMSR, flags);
  	((self_in_concretizeMSR->machineCode))[0 / 4] = aWord;
  	return 4;
  }
  
  	/* CogARMCompiler>>#concretizePushOrPopMultipleRegisters: */
  static sqInt NoDbgRegParms
  concretizePushOrPopMultipleRegisters(AbstractInstruction * self_in_concretizePushOrPopMultipleRegisters, sqInt doPush)
  {
  	assert((((self_in_concretizePushOrPopMultipleRegisters->operands))[0]) != 0);
  	((self_in_concretizePushOrPopMultipleRegisters->machineCode))[0] = ((((((int)((usqInt)(AL) << 28))) + ((doPush
  	? 153092096
  	: 145752064))) + (((int)((usqInt)(SP) << 16)))) + (((self_in_concretizePushOrPopMultipleRegisters->operands))[0]));
  	return 4;
  }
  
  
  /*	Generate an SMULL loResultReg, hiResultReg, srcA, srcB instruction */
  
  	/* CogARMCompiler>>#concretizeSMULL */
  static sqInt NoDbgRegParms
  concretizeSMULL(AbstractInstruction * self_in_concretizeSMULL)
  {
      sqInt aWord;
      sqInt hiResultReg;
      usqInt loResultReg;
      usqInt srcA;
      usqInt srcB;
  
  
  	/* NOTE: srcB contains the other mutiplicand at this point. It is OK to use it as the destination for the low part of the result and in fact this saves us moving it later */
  	srcA = ((self_in_concretizeSMULL->operands))[0];
  	loResultReg = (srcB = ((self_in_concretizeSMULL->operands))[1]);
  	hiResultReg = RISCTempReg;
  	/* begin machineCodeAt:put: */
  	aWord = (((((((int)((usqInt)(AL) << 28))) | ((0) | ((12582912) | (0)))) | ((((sqInt)((usqInt)(hiResultReg) << 16))) | (loResultReg << 12))) + (srcA << 8)) + (144)) + srcB;
  	((self_in_concretizeSMULL->machineCode))[0 / 4] = aWord;
  	return 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
   */
  
  	/* CogARMCompiler>>#conditionIsNotNever: */
  static sqInt NoDbgRegParms
  conditionIsNotNever(AbstractInstruction * self_in_conditionIsNotNever, sqInt instr)
  {
  	return (((usqInt)(instr)) >> 28) < 15;
  }
  
  
  /*	return an {opcode} destReg, srcReg, addReg lsl #shft */
  /*	important detail - a 0 shft requires setting the shift-type code to 0 to
  	avoid potential instruction confusion
   */
  
  	/* CogARMCompiler>>#dataOpType:rd:rn:rm:lsr: */
  static sqInt NoDbgRegParms
  dataOpTyperdrnrmlsr(AbstractInstruction * self_in_dataOpTyperdrnrmlsr, sqInt armOpcode, sqInt destReg, sqInt srcReg, sqInt addReg, sqInt shft)
  {
  	if (shft == 0) {
  		return (((((int)((usqInt)(AL) << 28))) | ((0) | ((((sqInt)((usqInt)(armOpcode) << 21))) | (0x100000)))) | ((((sqInt)((usqInt)(srcReg) << 16))) | (((sqInt)((usqInt)(destReg) << 12))))) | (addReg & 0xFFF);
  	}
  	else {
  		return (((((int)((usqInt)(AL) << 28))) | ((0) | ((((sqInt)((usqInt)(armOpcode) << 21))) | (0x100000)))) | ((((sqInt)((usqInt)(srcReg) << 16))) | (((sqInt)((usqInt)(destReg) << 12))))) | ((((((sqInt)((usqInt)(shft) << 7))) | 32) | addReg) & 0xFFF);
  	}
  }
  
  
  /*	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. */
  
  	/* CogARMCompiler>>#dispatchConcretize */
  static sqInt NoDbgRegParms
  dispatchConcretize(AbstractInstruction * self_in_dispatchConcretize)
  {
      usqInt addressOperand;
      sqInt aWord;
      sqInt aWord1;
      sqInt aWord10;
      sqInt aWord11;
      sqInt aWord110;
      sqInt aWord111;
      sqInt aWord1110;
      sqInt aWord1111;
      sqInt aWord1112;
      sqInt aWord1113;
      sqInt aWord112;
      sqInt aWord113;
      sqInt aWord114;
      sqInt aWord115;
      sqInt aWord116;
      sqInt aWord117;
      sqInt aWord118;
      sqInt aWord119;
      sqInt aWord12;
      sqInt aWord120;
      sqInt aWord121;
      sqInt aWord1210;
      sqInt aWord1211;
      sqInt aWord122;
      sqInt aWord123;
      sqInt aWord124;
      sqInt aWord125;
      sqInt aWord126;
      sqInt aWord127;
      sqInt aWord128;
      sqInt aWord129;
      sqInt aWord13;
      sqInt aWord130;
      sqInt aWord131;
      sqInt aWord132;
      sqInt aWord133;
      sqInt aWord134;
      sqInt aWord135;
      sqInt aWord136;
      sqInt aWord14;
      sqInt aWord15;
      sqInt aWord16;
      sqInt aWord17;
      sqInt aWord18;
      sqInt aWord19;
      sqInt aWord2;
      sqInt aWord20;
      sqInt aWord21;
      sqInt aWord210;
      sqInt aWord211;
      sqInt aWord2110;
      sqInt aWord2111;
      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 aWord23;
      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 aWord32;
      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 aWord42;
      sqInt aWord43;
      sqInt aWord44;
      sqInt aWord45;
      sqInt aWord46;
      sqInt aWord47;
      sqInt aWord48;
      sqInt aWord49;
      sqInt aWord5;
      sqInt aWord50;
      sqInt aWord51;
      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 aWord8;
      sqInt aWord9;
      usqInt base;
      usqInt base1;
      usqInt base2;
      usqInt base3;
      usqInt baseReg;
      usqInt baseReg1;
      usqInt baseReg2;
      usqInt constant;
      usqInt constant1;
      usqInt constant10;
      usqInt constant11;
      usqInt constant12;
      usqInt constant13;
      usqInt constant14;
      usqInt constant15;
      usqInt constant2;
      usqInt constant3;
      sqInt constant4;
      usqInt constant5;
      usqInt constant6;
      usqInt constant7;
      usqInt constant8;
      usqInt constant9;
      AbstractInstruction *dependentChain;
      usqInt dest;
      usqInt dest1;
      usqInt dest2;
      usqInt destAddr;
      usqInt destAddr1;
      usqInt destReg;
      usqInt destReg1;
      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;
      usqInt distance;
      usqInt distance1;
      usqInt distance2;
      usqInt distance3;
      usqInt distance4;
      usqInt distance5;
      usqInt distReg;
      usqInt distReg1;
      usqInt distReg2;
      usqInt dstReg;
      usqInt dstReg1;
      sqInt flagsOrOpcode;
      sqInt flagsOrOpcode1;
      sqInt flagsOrOpcode11;
      sqInt flagsOrOpcode12;
      sqInt flagsOrOpcode2;
      sqInt flagsOrOpcode3;
      sqInt flagsOrOpcode4;
      sqInt flagsOrOpcode5;
      sqInt flagsOrOpcode6;
      sqInt flagsOrOpcode7;
      usqInt fpReg;
      sqInt hb;
      sqInt hb1;
      sqInt hb11;
      sqInt hb12;
      sqInt hb2;
      sqInt hb3;
      sqInt hb4;
      sqInt hb5;
      sqInt hb6;
      sqInt i;
      sqInt i1;
      sqInt i10;
      sqInt i11;
      sqInt i12;
      sqInt i13;
      sqInt i14;
      sqInt i15;
      sqInt i16;
      sqInt i2;
      sqInt i3;
      sqInt i4;
      sqInt i5;
      sqInt i6;
      sqInt i7;
      sqInt i8;
      sqInt i9;
      sqInt immediate;
      sqInt immediate1;
      sqInt immediate10;
      sqInt immediate11;
      sqInt immediate110;
      sqInt immediate12;
      sqInt immediate13;
      sqInt immediate14;
      sqInt immediate15;
      sqInt immediate16;
      sqInt immediate17;
      sqInt immediate18;
      sqInt immediate19;
      sqInt immediate2;
      sqInt immediate20;
      sqInt immediate3;
      sqInt immediate4;
      sqInt immediate5;
      sqInt immediate6;
      sqInt immediate7;
      sqInt immediate8;
      sqInt immediate9;
      usqInt index;
      usqInt index1;
      usqInt index2;
      usqInt index3;
      sqInt instrOffset;
      sqInt instrOffset1;
      sqInt instrOffset10;
      sqInt instrOffset11;
      sqInt instrOffset12;
      sqInt instrOffset13;
      sqInt instrOffset14;
      sqInt instrOffset15;
      sqInt instrOffset16;
      sqInt instrOffset17;
      sqInt instrOffset18;
      sqInt instrOffset19;
      sqInt instrOffset2;
      sqInt instrOffset20;
      sqInt instrOffset21;
      sqInt instrOffset22;
      sqInt instrOffset23;
      sqInt instrOffset24;
      sqInt instrOffset25;
      sqInt instrOffset26;
      sqInt instrOffset27;
      sqInt instrOffset28;
      sqInt instrOffset29;
      sqInt instrOffset3;
      sqInt instrOffset30;
      sqInt instrOffset4;
      sqInt instrOffset5;
      sqInt instrOffset6;
      sqInt instrOffset7;
      sqInt instrOffset8;
      sqInt instrOffset9;
      sqInt invert;
      sqInt invert1;
      sqInt invert2;
      sqInt invert3;
      sqInt invert4;
      unsigned int invVal;
      AbstractInstruction *jumpTarget;
      AbstractInstruction *jumpTarget1;
      AbstractInstruction *jumpTarget10;
      AbstractInstruction *jumpTarget11;
      AbstractInstruction *jumpTarget110;
      AbstractInstruction *jumpTarget111;
      AbstractInstruction *jumpTarget112;
      AbstractInstruction *jumpTarget113;
      AbstractInstruction *jumpTarget114;
      AbstractInstruction *jumpTarget115;
      AbstractInstruction *jumpTarget116;
      AbstractInstruction *jumpTarget117;
      AbstractInstruction *jumpTarget118;
      AbstractInstruction *jumpTarget119;
      AbstractInstruction *jumpTarget12;
      AbstractInstruction *jumpTarget120;
      AbstractInstruction *jumpTarget121;
      AbstractInstruction *jumpTarget122;
      AbstractInstruction *jumpTarget123;
      AbstractInstruction *jumpTarget124;
      AbstractInstruction *jumpTarget13;
      AbstractInstruction *jumpTarget14;
      AbstractInstruction *jumpTarget15;
      AbstractInstruction *jumpTarget16;
      AbstractInstruction *jumpTarget17;
      AbstractInstruction *jumpTarget18;
      AbstractInstruction *jumpTarget19;
      AbstractInstruction *jumpTarget2;
      AbstractInstruction *jumpTarget20;
      AbstractInstruction *jumpTarget21;
      AbstractInstruction *jumpTarget22;
      AbstractInstruction *jumpTarget23;
      AbstractInstruction *jumpTarget24;
      AbstractInstruction *jumpTarget25;
      AbstractInstruction *jumpTarget26;
      AbstractInstruction *jumpTarget27;
      AbstractInstruction *jumpTarget28;
      AbstractInstruction *jumpTarget29;
      AbstractInstruction *jumpTarget3;
      AbstractInstruction *jumpTarget30;
      AbstractInstruction *jumpTarget31;
      AbstractInstruction *jumpTarget32;
      AbstractInstruction *jumpTarget33;
      AbstractInstruction *jumpTarget34;
      AbstractInstruction *jumpTarget4;
      AbstractInstruction *jumpTarget5;
      AbstractInstruction *jumpTarget6;
      AbstractInstruction *jumpTarget7;
      AbstractInstruction *jumpTarget8;
      AbstractInstruction *jumpTarget9;
      usqInt maskReg;
      sqInt negate;
      sqInt negate1;
      sqInt negate2;
      sqInt offset;
      sqInt offset1;
      sqInt offset10;
      sqInt offset11;
      sqInt offset12;
      sqInt offset13;
      sqInt offset14;
      sqInt offset15;
      sqInt offset16;
      sqInt offset17;
      sqInt offset18;
      sqInt offset19;
      sqInt offset2;
      sqInt offset20;
      sqInt offset21;
      sqInt offset22;
      sqInt offset23;
      sqInt offset24;
      sqInt offset25;
      sqInt offset26;
      usqInt offset27;
      sqInt offset28;
      sqInt offset29;
      sqInt offset3;
      sqInt offset30;
      sqInt offset31;
      sqInt offset32;
      sqInt offset33;
      sqInt offset4;
      sqInt offset5;
      sqInt offset6;
      sqInt offset7;
      sqInt offset8;
      sqInt offset9;
      sqInt p;
      sqInt rd;
      sqInt rd1;
      int rd10;
      int rd11;
      sqInt rd110;
      int rd12;
      int rd13;
      usqInt rd14;
      usqInt rd15;
      sqInt rd16;
      int rd17;
      int rd18;
      sqInt rd19;
      sqInt rd2;
      int rd20;
      sqInt rd3;
      sqInt rd4;
      sqInt rd5;
      sqInt rd6;
      sqInt rd7;
      int rd8;
      int rd9;
      usqInt reg;
      usqInt reg1;
      usqInt reg2;
      usqInt reg3;
      usqInt reg4;
      usqInt reg5;
      usqInt reg6;
      usqInt reg7;
      usqInt regA;
      usqInt regB;
      usqInt regLHS;
      usqInt regLHS1;
      usqInt regLHS2;
      usqInt regLHS3;
      usqInt regLHS4;
      usqInt regRHS;
      usqInt regRHS1;
      usqInt regRHS2;
      usqInt regRHS3;
      usqInt rn;
      usqInt rn1;
      usqInt rn10;
      usqInt rn11;
      usqInt rn110;
      usqInt rn111;
      usqInt rn112;
      usqInt rn12;
      usqInt rn13;
      usqInt rn14;
      usqInt rn15;
      usqInt rn16;
      usqInt rn17;
      usqInt rn18;
      usqInt rn19;
      usqInt rn2;
      usqInt rn20;
      usqInt rn21;
      usqInt rn22;
      usqInt rn23;
      usqInt rn24;
      usqInt rn25;
      usqInt rn26;
      usqInt rn27;
      usqInt rn3;
      usqInt rn4;
      usqInt rn5;
      usqInt rn6;
      usqInt rn7;
      usqInt rn8;
      usqInt rn9;
      sqInt rot;
      sqInt rot1;
      sqInt rot10;
      sqInt rot11;
      sqInt rot12;
      sqInt rot13;
      sqInt rot14;
      sqInt rot2;
      sqInt rot3;
      sqInt rot4;
      sqInt rot5;
      sqInt rot6;
      sqInt rot7;
      sqInt rot8;
      sqInt rot9;
      usqInt src;
      usqInt src1;
      usqInt srcAddr;
      usqInt srcAddr1;
      usqInt srcReg;
      usqInt srcReg1;
      usqInt srcReg10;
      usqInt srcReg11;
      usqInt srcReg12;
      usqInt srcReg13;
      usqInt srcReg14;
      usqInt srcReg15;
      usqInt srcReg16;
      usqInt srcReg17;
      usqInt srcReg18;
      usqInt srcReg19;
      usqInt srcReg2;
      usqInt srcReg20;
      usqInt srcReg21;
      usqInt srcReg22;
      usqInt srcReg23;
      usqInt srcReg24;
      usqInt srcReg3;
      usqInt srcReg4;
      usqInt srcReg5;
      usqInt srcReg6;
      usqInt srcReg7;
      usqInt srcReg8;
      usqInt srcReg9;
      int u;
      int u1;
      sqInt val;
      sqInt val1;
      sqInt val11;
      sqInt val12;
      sqInt val2;
      sqInt val3;
      usqInt val4;
      sqInt val5;
      sqInt val6;
      sqInt value;
      sqInt value1;
      sqInt value2;
      unsigned int value3;
      unsigned int value4;
      unsigned int value5;
      unsigned int value6;
      unsigned int value7;
      sqInt word;
      sqInt word1;
      usqInt word2;
      usqInt word3;
  
  	if (!(((self_in_dispatchConcretize->conditionOrNil)) == null)) {
  		return concretizeConditionalInstruction(self_in_dispatchConcretize);
  	}
  	
  	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]));
  			}
  			dependentChain = (dependentChain->dependent);
  		}
  		return 0;
  
  	case Literal:
  		return concretizeLiteral(self_in_dispatchConcretize);
  
  	case AlignmentNops:
  		/* begin concretizeAlignmentNops */
  		assert((((self_in_dispatchConcretize->machineCodeSize)) % 4) == 0);
  		for (p = 0; p < ((self_in_dispatchConcretize->machineCodeSize)); p += 4) {
  			/* begin machineCodeAt:put: */
  			((self_in_dispatchConcretize->machineCode))[p / 4] = 3785359360U;
  		}
  		return ((usqInt) ((self_in_dispatchConcretize->machineCodeSize)));
  
  	case Fill32:
  		return concretizeFill32(self_in_dispatchConcretize);
  
  	case Nop:
  		/* begin concretizeNop */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = 3785359360U;
  		return 4;
  
  	case Call:
  		/* begin concretizeCall */
  		assert((((self_in_dispatchConcretize->operands))[0]) != 0);
  		assert(((((self_in_dispatchConcretize->operands))[0]) % 4) == 0);
  
  		/* normal pc offset */
  		offset2 = (((int) (((self_in_dispatchConcretize->operands))[0]))) - (((int) (((self_in_dispatchConcretize->address)) + 8)));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset2));
  		/* begin machineCodeAt:put: */
  		aWord = bl(self_in_dispatchConcretize, offset2);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord;
  		return 4;
  
  	case CallFull:
  		/* begin concretizeCallFull */
  		jumpTarget1 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		if ((addressIsInInstructions(jumpTarget1))
  		 || (jumpTarget1 == (methodLabel()))) {
  			jumpTarget1 = ((AbstractInstruction *) ((jumpTarget1->address)));
  		}
  		assert(jumpTarget1 != 0);
  		jumpTarget = jumpTarget1;
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord1 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord1;
  		instrOffset = 4;
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[instrOffset / 4] = ((((int)((usqInt)(AL) << 28))) | ((19922704 | (((int)((usqInt)((1 & 1)) << 5)))) | ConcreteIPReg));
  		assert(instrOffset == (literalLoadInstructionBytes(self_in_dispatchConcretize)));
  		return instrOffset + 4;
  
  	case JumpR:
  		/* begin concretizeJumpR */
  
  		/* bx reg */
  		reg = ((self_in_dispatchConcretize->operands))[0];
  		aWord2 = (((int)((usqInt)(AL) << 28))) | ((19922704 | (((int)((usqInt)((0 & 1)) << 5)))) | reg);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord2;
  		return 4;
  
  	case JumpFull:
  		/* begin concretizeJumpFull */
  		jumpTarget11 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		if ((addressIsInInstructions(jumpTarget11))
  		 || (jumpTarget11 == (methodLabel()))) {
  			jumpTarget11 = ((AbstractInstruction *) ((jumpTarget11->address)));
  		}
  		assert(jumpTarget11 != 0);
  		jumpTarget2 = jumpTarget11;
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord3 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord3;
  		instrOffset1 = 4;
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[instrOffset1 / 4] = ((((int)((usqInt)(AL) << 28))) | ((19922704 | (((int)((usqInt)((0 & 1)) << 5)))) | ConcreteIPReg));
  		return instrOffset1 + 4;
  
  	case JumpLong:
  	case Jump:
  		/* begin concretizeConditionalJump: */
  		jumpTarget12 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget12);
  		if ((addressIsInInstructions(jumpTarget12))
  		 || (jumpTarget12 == (methodLabel()))) {
  			jumpTarget12 = ((AbstractInstruction *) ((jumpTarget12->address)));
  		}
  		assert(jumpTarget12 != 0);
  		jumpTarget3 = jumpTarget12;
  		offset3 = (((int) jumpTarget3)) - (((int) (((self_in_dispatchConcretize->address)) + 8)));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset3));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = ((((int)((usqInt)(AL) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset3)) >> 2) & 0xFFFFFF)));
  		return 4;
  
  	case JumpLongZero:
  	case JumpZero:
  		/* begin concretizeConditionalJump: */
  		jumpTarget13 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget13);
  		if ((addressIsInInstructions(jumpTarget13))
  		 || (jumpTarget13 == (methodLabel()))) {
  			jumpTarget13 = ((AbstractInstruction *) ((jumpTarget13->address)));
  		}
  		assert(jumpTarget13 != 0);
  		jumpTarget4 = jumpTarget13;
  		offset4 = (((int) jumpTarget4)) - (((int) (((self_in_dispatchConcretize->address)) + 8)));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset4));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = ((((int)((usqInt)(EQ) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset4)) >> 2) & 0xFFFFFF)));
  		return 4;
  
  	case JumpLongNonZero:
  	case JumpNonZero:
  		/* begin concretizeConditionalJump: */
  		jumpTarget14 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget14);
  		if ((addressIsInInstructions(jumpTarget14))
  		 || (jumpTarget14 == (methodLabel()))) {
  			jumpTarget14 = ((AbstractInstruction *) ((jumpTarget14->address)));
  		}
  		assert(jumpTarget14 != 0);
  		jumpTarget5 = jumpTarget14;
  		offset5 = (((int) jumpTarget5)) - (((int) (((self_in_dispatchConcretize->address)) + 8)));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset5));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = ((((int)((usqInt)(NE) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset5)) >> 2) & 0xFFFFFF)));
  		return 4;
  
  	case JumpNegative:
  		/* begin concretizeConditionalJump: */
  		jumpTarget15 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget15);
  		if ((addressIsInInstructions(jumpTarget15))
  		 || (jumpTarget15 == (methodLabel()))) {
  			jumpTarget15 = ((AbstractInstruction *) ((jumpTarget15->address)));
  		}
  		assert(jumpTarget15 != 0);
  		jumpTarget6 = jumpTarget15;
  		offset6 = (((int) jumpTarget6)) - (((int) (((self_in_dispatchConcretize->address)) + 8)));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset6));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = ((((int)((usqInt)(MI) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset6)) >> 2) & 0xFFFFFF)));
  		return 4;
  
  	case JumpNonNegative:
  		/* begin concretizeConditionalJump: */
  		jumpTarget16 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget16);
  		if ((addressIsInInstructions(jumpTarget16))
  		 || (jumpTarget16 == (methodLabel()))) {
  			jumpTarget16 = ((AbstractInstruction *) ((jumpTarget16->address)));
  		}
  		assert(jumpTarget16 != 0);
  		jumpTarget7 = jumpTarget16;
  		offset7 = (((int) jumpTarget7)) - (((int) (((self_in_dispatchConcretize->address)) + 8)));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset7));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = ((((int)((usqInt)(PL) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset7)) >> 2) & 0xFFFFFF)));
  		return 4;
  
  	case JumpOverflow:
  		/* begin concretizeConditionalJump: */
  		jumpTarget17 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget17);
  		if ((addressIsInInstructions(jumpTarget17))
  		 || (jumpTarget17 == (methodLabel()))) {
  			jumpTarget17 = ((AbstractInstruction *) ((jumpTarget17->address)));
  		}
  		assert(jumpTarget17 != 0);
  		jumpTarget8 = jumpTarget17;
  		offset8 = (((int) jumpTarget8)) - (((int) (((self_in_dispatchConcretize->address)) + 8)));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset8));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = ((((int)((usqInt)(VS) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset8)) >> 2) & 0xFFFFFF)));
  		return 4;
  
  	case JumpNoOverflow:
  		/* begin concretizeConditionalJump: */
  		jumpTarget18 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget18);
  		if ((addressIsInInstructions(jumpTarget18))
  		 || (jumpTarget18 == (methodLabel()))) {
  			jumpTarget18 = ((AbstractInstruction *) ((jumpTarget18->address)));
  		}
  		assert(jumpTarget18 != 0);
  		jumpTarget9 = jumpTarget18;
  		offset9 = (((int) jumpTarget9)) - (((int) (((self_in_dispatchConcretize->address)) + 8)));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset9));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = ((((int)((usqInt)(VC) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset9)) >> 2) & 0xFFFFFF)));
  		return 4;
  
  	case JumpCarry:
  	case JumpAboveOrEqual:
  		/* begin concretizeConditionalJump: */
  		jumpTarget19 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget19);
  		if ((addressIsInInstructions(jumpTarget19))
  		 || (jumpTarget19 == (methodLabel()))) {
  			jumpTarget19 = ((AbstractInstruction *) ((jumpTarget19->address)));
  		}
  		assert(jumpTarget19 != 0);
  		jumpTarget10 = jumpTarget19;
  		offset10 = (((int) jumpTarget10)) - (((int) (((self_in_dispatchConcretize->address)) + 8)));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset10));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = ((((int)((usqInt)(CS) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset10)) >> 2) & 0xFFFFFF)));
  		return 4;
  
  	case JumpNoCarry:
  	case JumpBelow:
  		/* begin concretizeConditionalJump: */
  		jumpTarget110 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget110);
  		if ((addressIsInInstructions(jumpTarget110))
  		 || (jumpTarget110 == (methodLabel()))) {
  			jumpTarget110 = ((AbstractInstruction *) ((jumpTarget110->address)));
  		}
  		assert(jumpTarget110 != 0);
  		jumpTarget20 = jumpTarget110;
  		offset11 = (((int) jumpTarget20)) - (((int) (((self_in_dispatchConcretize->address)) + 8)));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset11));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = ((((int)((usqInt)(CC) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset11)) >> 2) & 0xFFFFFF)));
  		return 4;
  
  	case JumpLess:
  		/* begin concretizeConditionalJump: */
  		jumpTarget111 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget111);
  		if ((addressIsInInstructions(jumpTarget111))
  		 || (jumpTarget111 == (methodLabel()))) {
  			jumpTarget111 = ((AbstractInstruction *) ((jumpTarget111->address)));
  		}
  		assert(jumpTarget111 != 0);
  		jumpTarget21 = jumpTarget111;
  		offset12 = (((int) jumpTarget21)) - (((int) (((self_in_dispatchConcretize->address)) + 8)));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset12));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = ((((int)((usqInt)(LT) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset12)) >> 2) & 0xFFFFFF)));
  		return 4;
  
  	case JumpGreaterOrEqual:
  		/* begin concretizeConditionalJump: */
  		jumpTarget112 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget112);
  		if ((addressIsInInstructions(jumpTarget112))
  		 || (jumpTarget112 == (methodLabel()))) {
  			jumpTarget112 = ((AbstractInstruction *) ((jumpTarget112->address)));
  		}
  		assert(jumpTarget112 != 0);
  		jumpTarget22 = jumpTarget112;
  		offset13 = (((int) jumpTarget22)) - (((int) (((self_in_dispatchConcretize->address)) + 8)));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset13));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = ((((int)((usqInt)(GE) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset13)) >> 2) & 0xFFFFFF)));
  		return 4;
  
  	case JumpGreater:
  		/* begin concretizeConditionalJump: */
  		jumpTarget113 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget113);
  		if ((addressIsInInstructions(jumpTarget113))
  		 || (jumpTarget113 == (methodLabel()))) {
  			jumpTarget113 = ((AbstractInstruction *) ((jumpTarget113->address)));
  		}
  		assert(jumpTarget113 != 0);
  		jumpTarget23 = jumpTarget113;
  		offset14 = (((int) jumpTarget23)) - (((int) (((self_in_dispatchConcretize->address)) + 8)));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset14));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = ((((int)((usqInt)(GT) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset14)) >> 2) & 0xFFFFFF)));
  		return 4;
  
  	case JumpLessOrEqual:
  		/* begin concretizeConditionalJump: */
  		jumpTarget114 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget114);
  		if ((addressIsInInstructions(jumpTarget114))
  		 || (jumpTarget114 == (methodLabel()))) {
  			jumpTarget114 = ((AbstractInstruction *) ((jumpTarget114->address)));
  		}
  		assert(jumpTarget114 != 0);
  		jumpTarget24 = jumpTarget114;
  		offset15 = (((int) jumpTarget24)) - (((int) (((self_in_dispatchConcretize->address)) + 8)));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset15));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = ((((int)((usqInt)(LE) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset15)) >> 2) & 0xFFFFFF)));
  		return 4;
  
  	case JumpAbove:
  		/* begin concretizeConditionalJump: */
  		jumpTarget115 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget115);
  		if ((addressIsInInstructions(jumpTarget115))
  		 || (jumpTarget115 == (methodLabel()))) {
  			jumpTarget115 = ((AbstractInstruction *) ((jumpTarget115->address)));
  		}
  		assert(jumpTarget115 != 0);
  		jumpTarget25 = jumpTarget115;
  		offset16 = (((int) jumpTarget25)) - (((int) (((self_in_dispatchConcretize->address)) + 8)));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset16));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = ((((int)((usqInt)(HI) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset16)) >> 2) & 0xFFFFFF)));
  		return 4;
  
  	case JumpBelowOrEqual:
  		/* begin concretizeConditionalJump: */
  		jumpTarget116 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget116);
  		if ((addressIsInInstructions(jumpTarget116))
  		 || (jumpTarget116 == (methodLabel()))) {
  			jumpTarget116 = ((AbstractInstruction *) ((jumpTarget116->address)));
  		}
  		assert(jumpTarget116 != 0);
  		jumpTarget26 = jumpTarget116;
  		offset17 = (((int) jumpTarget26)) - (((int) (((self_in_dispatchConcretize->address)) + 8)));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset17));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = ((((int)((usqInt)(LS) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset17)) >> 2) & 0xFFFFFF)));
  		return 4;
  
  	case JumpFPEqual:
  		/* begin concretizeFPConditionalJump: */
  		jumpTarget117 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget117);
  		if ((addressIsInInstructions(jumpTarget117))
  		 || (jumpTarget117 == (methodLabel()))) {
  			jumpTarget117 = ((AbstractInstruction *) ((jumpTarget117->address)));
  		}
  		assert(jumpTarget117 != 0);
  		jumpTarget27 = jumpTarget117;
  		offset18 = (((int) jumpTarget27)) - (((int) (((self_in_dispatchConcretize->address)) + (12))));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset18));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = 4008835600U /* fmstat */;
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[4 / 4] = ((((int)((usqInt)(EQ) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset18)) >> 2) & 0xFFFFFF)));
  		return 8;
  
  	case JumpFPNotEqual:
  		/* begin concretizeFPConditionalJump: */
  		jumpTarget118 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget118);
  		if ((addressIsInInstructions(jumpTarget118))
  		 || (jumpTarget118 == (methodLabel()))) {
  			jumpTarget118 = ((AbstractInstruction *) ((jumpTarget118->address)));
  		}
  		assert(jumpTarget118 != 0);
  		jumpTarget28 = jumpTarget118;
  		offset19 = (((int) jumpTarget28)) - (((int) (((self_in_dispatchConcretize->address)) + (12))));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset19));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = 4008835600U /* fmstat */;
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[4 / 4] = ((((int)((usqInt)(NE) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset19)) >> 2) & 0xFFFFFF)));
  		return 8;
  
  	case JumpFPLess:
  		/* begin concretizeFPConditionalJump: */
  		jumpTarget119 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget119);
  		if ((addressIsInInstructions(jumpTarget119))
  		 || (jumpTarget119 == (methodLabel()))) {
  			jumpTarget119 = ((AbstractInstruction *) ((jumpTarget119->address)));
  		}
  		assert(jumpTarget119 != 0);
  		jumpTarget29 = jumpTarget119;
  		offset20 = (((int) jumpTarget29)) - (((int) (((self_in_dispatchConcretize->address)) + (12))));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset20));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = 4008835600U /* fmstat */;
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[4 / 4] = ((((int)((usqInt)(LT) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset20)) >> 2) & 0xFFFFFF)));
  		return 8;
  
  	case JumpFPGreaterOrEqual:
  		/* begin concretizeFPConditionalJump: */
  		jumpTarget120 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget120);
  		if ((addressIsInInstructions(jumpTarget120))
  		 || (jumpTarget120 == (methodLabel()))) {
  			jumpTarget120 = ((AbstractInstruction *) ((jumpTarget120->address)));
  		}
  		assert(jumpTarget120 != 0);
  		jumpTarget30 = jumpTarget120;
  		offset21 = (((int) jumpTarget30)) - (((int) (((self_in_dispatchConcretize->address)) + (12))));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset21));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = 4008835600U /* fmstat */;
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[4 / 4] = ((((int)((usqInt)(GE) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset21)) >> 2) & 0xFFFFFF)));
  		return 8;
  
  	case JumpFPGreater:
  		/* begin concretizeFPConditionalJump: */
  		jumpTarget121 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget121);
  		if ((addressIsInInstructions(jumpTarget121))
  		 || (jumpTarget121 == (methodLabel()))) {
  			jumpTarget121 = ((AbstractInstruction *) ((jumpTarget121->address)));
  		}
  		assert(jumpTarget121 != 0);
  		jumpTarget31 = jumpTarget121;
  		offset22 = (((int) jumpTarget31)) - (((int) (((self_in_dispatchConcretize->address)) + (12))));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset22));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = 4008835600U /* fmstat */;
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[4 / 4] = ((((int)((usqInt)(GT) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset22)) >> 2) & 0xFFFFFF)));
  		return 8;
  
  	case JumpFPLessOrEqual:
  		/* begin concretizeFPConditionalJump: */
  		jumpTarget122 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget122);
  		if ((addressIsInInstructions(jumpTarget122))
  		 || (jumpTarget122 == (methodLabel()))) {
  			jumpTarget122 = ((AbstractInstruction *) ((jumpTarget122->address)));
  		}
  		assert(jumpTarget122 != 0);
  		jumpTarget32 = jumpTarget122;
  		offset23 = (((int) jumpTarget32)) - (((int) (((self_in_dispatchConcretize->address)) + (12))));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset23));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = 4008835600U /* fmstat */;
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[4 / 4] = ((((int)((usqInt)(LE) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset23)) >> 2) & 0xFFFFFF)));
  		return 8;
  
  	case JumpFPOrdered:
  		/* begin concretizeFPConditionalJump: */
  		jumpTarget123 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget123);
  		if ((addressIsInInstructions(jumpTarget123))
  		 || (jumpTarget123 == (methodLabel()))) {
  			jumpTarget123 = ((AbstractInstruction *) ((jumpTarget123->address)));
  		}
  		assert(jumpTarget123 != 0);
  		jumpTarget33 = jumpTarget123;
  		offset24 = (((int) jumpTarget33)) - (((int) (((self_in_dispatchConcretize->address)) + (12))));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset24));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = 4008835600U /* fmstat */;
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[4 / 4] = ((((int)((usqInt)(VC) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset24)) >> 2) & 0xFFFFFF)));
  		return 8;
  
  	case JumpFPUnordered:
  		/* begin concretizeFPConditionalJump: */
  		jumpTarget124 = ((AbstractInstruction *) (((self_in_dispatchConcretize->operands))[0]));
  		assertSaneJumpTarget(jumpTarget124);
  		if ((addressIsInInstructions(jumpTarget124))
  		 || (jumpTarget124 == (methodLabel()))) {
  			jumpTarget124 = ((AbstractInstruction *) ((jumpTarget124->address)));
  		}
  		assert(jumpTarget124 != 0);
  		jumpTarget34 = jumpTarget124;
  		offset25 = (((int) jumpTarget34)) - (((int) (((self_in_dispatchConcretize->address)) + (12))));
  		assert(isInImmediateJumpRange(self_in_dispatchConcretize, offset25));
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = 4008835600U /* fmstat */;
  		/* begin machineCodeAt:put: */
  		((self_in_dispatchConcretize->machineCode))[4 / 4] = ((((int)((usqInt)(VS) << 28))) | ((((int)((usqInt)((10 | (0 & 1))) << 24))) | ((((usqInt)(offset25)) >> 2) & 0xFFFFFF)));
  		return 8;
  
  	case RetN:
  		/* begin concretizeRetN */
  		offset26 = ((self_in_dispatchConcretize->operands))[0];
  		if (offset26 == 0) {
  			/* begin machineCodeAt:put: */
  			aWord4 = movrn(self_in_dispatchConcretize, PC, LR);
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord4;
  			return 4;
  		}
  		assert(offset26 < 0xFF);
  		/* begin machineCodeAt:put: */
  		aWord11 = addrnimmror(self_in_dispatchConcretize, SP, SP, offset26, 0);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord11;
  		/* begin machineCodeAt:put: */
  		aWord21 = movrn(self_in_dispatchConcretize, PC, LR);
  		((self_in_dispatchConcretize->machineCode))[4 / 4] = aWord21;
  		return 8;
  
  	case Stop:
  		/* begin concretizeStop */
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = ((((int)((usqInt)(AL) << 28))) | ((18874368) | (112)));
  		return 4;
  
  	case AddCqR:
  		/* begin concretizeNegateableDataOperationCqR:R: */
  		rd = ((self_in_dispatchConcretize->operands))[1];
  		val = ((self_in_dispatchConcretize->operands))[0];
  
  		/* Extra note - if ever a version of this code wants to NOT set the Set flag
  		   - Cmp must always have it set or it will pretend to be a SMALALBT and Very Bad Things might happen. */
  		rn = ((self_in_dispatchConcretize->operands))[1];
  		/* begin rotateable8bitSignedImmediate:ifTrue:ifFalse: */
  		value = val;
  		while (1) {
  			if ((value & 0xFF) == value) {
  				negate = val != value;
  				/* begin machineCodeAt:put: */
  				flagsOrOpcode = (negate
  					? inverseOpcodeFor(self_in_dispatchConcretize, AddOpcode)
  					: AddOpcode);
  				aWord5 = (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((sqInt)((usqInt)(flagsOrOpcode) << 21))) | (0x100000)))) | ((rn << 16) | (((sqInt)((usqInt)(rd) << 12))))) | (((0) | value) & 0xFFF);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord5;
  				return 4;
  				goto l95;
  			}
  			for (i = 2; i <= 30; i += 2) {
  				if ((value & (((0xFFU << i) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i)))) == value) {
  					rot = 32 - i;
  					immediate = (((usqInt)(value)) >> i) | ((((sqInt)((usqInt)(value) << (32 - i)))) & 0xFFFFFFFFU);
  					negate = val != value;
  					/* begin machineCodeAt:put: */
  					flagsOrOpcode1 = (negate
  						? inverseOpcodeFor(self_in_dispatchConcretize, AddOpcode)
  						: AddOpcode);
  					aWord5 = (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((sqInt)((usqInt)(flagsOrOpcode1) << 21))) | (0x100000)))) | ((rn << 16) | (((sqInt)((usqInt)(rd) << 12))))) | (((((sqInt)((usqInt)((((usqInt)(rot)) >> 1)) << 8))) | immediate) & 0xFFF);
  					((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord5;
  					return 4;
  					goto l95;
  				}
  			}
  			if (!((value == val)
  			 && (val != 0))) break;
  			value = -val;
  		}
  		
  		/* let's try to see if the constant can be made from a simple shift of 0xFFFFFFFF */
  		if (val > 0) {
  			hb = highBit(val);
  			if ((1U << hb) == (val + 1)) {
  
  				/* MVN temp,  #0, making 0xffffffff */
  				/* begin machineCodeAt:put: */
  				aWord12 = mvnimmror(self_in_dispatchConcretize, ConcreteIPReg, 0, 0);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord12;
  				/* begin machineCodeAt:put: */
  				aWord22 = dataOpTyperdrnrmlsr(self_in_dispatchConcretize, AddOpcode, rd, rn, ConcreteIPReg, 32 - hb);
  				((self_in_dispatchConcretize->machineCode))[4 / 4] = aWord22;
  				return 8;
  			}
  		}
  		/* begin concretizeDataOperationCwR:R: */
  		constant = ((self_in_dispatchConcretize->operands))[0];
  		rn1 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord31 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord31;
  		instrOffset2 = 4;
  		/* begin machineCodeAt:put: */
  		aWord111 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(AddOpcode) << 21))) | (0x100000)))) | ((rn1 << 16) | (((sqInt)((usqInt)(rd) << 12))))) | (ConcreteIPReg & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[instrOffset2 / 4] = aWord111;
  		return instrOffset2 + 4;
  	l95:	/* end rotateable8bitSignedImmediate:ifTrue:ifFalse: */;
  		return 0;
  
  	case AddCqRR:
  		/* begin concretizeNegateableDataOperationCqR:R: */
  		rd1 = ((self_in_dispatchConcretize->operands))[2];
  		val1 = ((self_in_dispatchConcretize->operands))[0];
  
  		/* Extra note - if ever a version of this code wants to NOT set the Set flag
  		   - Cmp must always have it set or it will pretend to be a SMALALBT and Very Bad Things might happen. */
  		rn2 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin rotateable8bitSignedImmediate:ifTrue:ifFalse: */
  		value1 = val1;
  		while (1) {
  			if ((value1 & 0xFF) == value1) {
  				negate1 = val1 != value1;
  				/* begin machineCodeAt:put: */
  				flagsOrOpcode2 = (negate1
  					? inverseOpcodeFor(self_in_dispatchConcretize, AddOpcode)
  					: AddOpcode);
  				aWord6 = (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((sqInt)((usqInt)(flagsOrOpcode2) << 21))) | (0x100000)))) | ((rn2 << 16) | (((sqInt)((usqInt)(rd1) << 12))))) | (((0) | value1) & 0xFFF);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord6;
  				return 4;
  				goto l102;
  			}
  			for (i1 = 2; i1 <= 30; i1 += 2) {
  				if ((value1 & (((0xFFU << i1) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i1)))) == value1) {
  					rot1 = 32 - i1;
  					immediate1 = (((usqInt)(value1)) >> i1) | ((((sqInt)((usqInt)(value1) << (32 - i1)))) & 0xFFFFFFFFU);
  					negate1 = val1 != value1;
  					/* begin machineCodeAt:put: */
  					flagsOrOpcode3 = (negate1
  						? inverseOpcodeFor(self_in_dispatchConcretize, AddOpcode)
  						: AddOpcode);
  					aWord6 = (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((sqInt)((usqInt)(flagsOrOpcode3) << 21))) | (0x100000)))) | ((rn2 << 16) | (((sqInt)((usqInt)(rd1) << 12))))) | (((((sqInt)((usqInt)((((usqInt)(rot1)) >> 1)) << 8))) | immediate1) & 0xFFF);
  					((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord6;
  					return 4;
  					goto l102;
  				}
  			}
  			if (!((value1 == val1)
  			 && (val1 != 0))) break;
  			value1 = -val1;
  		}
  		
  		/* let's try to see if the constant can be made from a simple shift of 0xFFFFFFFF */
  		if (val1 > 0) {
  			hb1 = highBit(val1);
  			if ((1U << hb1) == (val1 + 1)) {
  
  				/* MVN temp,  #0, making 0xffffffff */
  				/* begin machineCodeAt:put: */
  				aWord13 = mvnimmror(self_in_dispatchConcretize, ConcreteIPReg, 0, 0);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord13;
  				/* begin machineCodeAt:put: */
  				aWord23 = dataOpTyperdrnrmlsr(self_in_dispatchConcretize, AddOpcode, rd1, rn2, ConcreteIPReg, 32 - hb1);
  				((self_in_dispatchConcretize->machineCode))[4 / 4] = aWord23;
  				return 8;
  			}
  		}
  		/* begin concretizeDataOperationCwR:R: */
  		constant1 = ((self_in_dispatchConcretize->operands))[0];
  		rn11 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord32 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord32;
  		instrOffset3 = 4;
  		/* begin machineCodeAt:put: */
  		aWord112 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(AddOpcode) << 21))) | (0x100000)))) | ((rn11 << 16) | (((sqInt)((usqInt)(rd1) << 12))))) | (ConcreteIPReg & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[instrOffset3 / 4] = aWord112;
  		return instrOffset3 + 4;
  	l102:	/* end rotateable8bitSignedImmediate:ifTrue:ifFalse: */;
  		return 0;
  
  	case AndCqR:
  		/* begin concretizeInvertibleDataOperationCqR: */
  		val3 = ((self_in_dispatchConcretize->operands))[0];
  		rn22 = ((self_in_dispatchConcretize->operands))[1];
  		assert(!((((self_in_dispatchConcretize->opcode)) == CmpOpcode)));
  		/* begin rotateable8bitBitwiseImmediate:ifTrue:ifFalse: */
  		value5 = val3;
  		while (1) {
  			if ((value5 & 0xFF) == value5) {
  				invert2 = val3 != value5;
  				/* begin machineCodeAt:put: */
  				flagsOrOpcode4 = (invert2
  					? inverseOpcodeFor(self_in_dispatchConcretize, AndOpcode)
  					: AndOpcode);
  				aWord74 = (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((sqInt)((usqInt)(flagsOrOpcode4) << 21))) | (0x100000)))) | ((rn22 << 16) | (rn22 << 12))) | (((0) | value5) & 0xFFF);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord74;
  				return 4;
  				goto l251;
  			}
  			for (i9 = 2; i9 <= 30; i9 += 2) {
  				if ((value5 & (((0xFFU << i9) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i9)))) == value5) {
  					rot9 = 32 - i9;
  					immediate15 = ((value5) >> i9) | ((value5 << (32 - i9)) & 0xFFFFFFFFU);
  					invert2 = val3 != value5;
  					/* begin machineCodeAt:put: */
  					flagsOrOpcode11 = (invert2
  						? inverseOpcodeFor(self_in_dispatchConcretize, AndOpcode)
  						: AndOpcode);
  					aWord74 = (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((sqInt)((usqInt)(flagsOrOpcode11) << 21))) | (0x100000)))) | ((rn22 << 16) | (rn22 << 12))) | (((((sqInt)((usqInt)((((usqInt)(rot9)) >> 1)) << 8))) | immediate15) & 0xFFF);
  					((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord74;
  					return 4;
  					goto l251;
  				}
  			}
  			if (!(value5 == val3)) break;
  			value5 = (val3 < 0
  				? -1 - val3
  				: (unsigned int)~val3);
  		}
  	l251:	/* end rotateable8bitBitwiseImmediate:ifTrue:ifFalse: */;
  		if (val3 > 0) {
  			hb3 = highBit(val3);
  			if ((1U << hb3) == (val3 + 1)) {
  
  				/* MVN temp,  #0, making 0xffffffff */
  				/* begin machineCodeAt:put: */
  				aWord133 = mvnimmror(self_in_dispatchConcretize, ConcreteIPReg, 0, 0);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord133;
  				/* begin machineCodeAt:put: */
  				aWord223 = dataOpTyperdrnrmlsr(self_in_dispatchConcretize, AndOpcode, rn22, rn22, ConcreteIPReg, 32 - hb3);
  				((self_in_dispatchConcretize->machineCode))[4 / 4] = aWord223;
  				return 8;
  			}
  		}
  		/* begin concretizeDataOperationCqR: */
  		val11 = ((self_in_dispatchConcretize->operands))[0];
  		rn23 = ((self_in_dispatchConcretize->operands))[1];
  
  		/* Extra note - if ever a version of this code wants to NOT set the Set flag - Cmp must always have it set or it will pretend to be a SMALALBT and Very Bad Things might happen */
  		rd17 = (((self_in_dispatchConcretize->opcode)) == CmpOpcode
  			? 0
  			: rn23);
  		/* begin rotateable8bitImmediate:ifTrue:ifFalse: */
  		if ((val11 & 0xFF) == val11) {
  			/* begin machineCodeAt:put: */
  			aWord410 = (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(AndOpcode) << 21))) | (0x100000)))) | ((rn23 << 16) | (((int)((usqInt)(rd17) << 12))))) | (((0) | val11) & 0xFFF);
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord410;
  			return 4;
  			goto l243;
  		}
  		for (i13 = 2; i13 <= 30; i13 += 2) {
  			if ((val11 & (((0xFFU << i13) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i13)))) == val11) {
  				rot11 = 32 - i13;
  				immediate16 = (((usqInt)(val11)) >> i13) | ((((sqInt)((usqInt)(val11) << (32 - i13)))) & 0xFFFFFFFFU);
  				/* begin machineCodeAt:put: */
  				aWord410 = (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(AndOpcode) << 21))) | (0x100000)))) | ((rn23 << 16) | (((int)((usqInt)(rd17) << 12))))) | (((((sqInt)((usqInt)((((usqInt)(rot11)) >> 1)) << 8))) | immediate16) & 0xFFF);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord410;
  				return 4;
  				goto l243;
  			}
  		}
  	l243:	/* end rotateable8bitImmediate:ifTrue:ifFalse: */;
  		if (val11 > 0) {
  			hb11 = highBit(val11);
  			if ((1U << hb11) == (val11 + 1)) {
  
  				/* MVN temp,  #0, making 0xffffffff */
  				/* begin machineCodeAt:put: */
  				aWord1210 = mvnimmror(self_in_dispatchConcretize, ConcreteIPReg, 0, 0);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord1210;
  				/* begin machineCodeAt:put: */
  				aWord2110 = dataOpTyperdrnrmlsr(self_in_dispatchConcretize, AndOpcode, rd17, rn23, ConcreteIPReg, 32 - hb11);
  				((self_in_dispatchConcretize->machineCode))[4 / 4] = aWord2110;
  				return 8;
  			}
  		}
  		/* begin concretizeDataOperationCwR:R: */
  		rd16 = ((self_in_dispatchConcretize->operands))[1];
  		constant12 = ((self_in_dispatchConcretize->operands))[0];
  		rn110 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord313 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord313;
  		instrOffset27 = 4;
  		/* begin machineCodeAt:put: */
  		aWord1110 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(AndOpcode) << 21))) | (0x100000)))) | ((rn110 << 16) | (((sqInt)((usqInt)(rd16) << 12))))) | (ConcreteIPReg & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[instrOffset27 / 4] = aWord1110;
  		return instrOffset27 + 4;
  
  	case AndCqRR:
  		/* begin concretizeAndCqRR */
  		val4 = ((self_in_dispatchConcretize->operands))[0];
  		srcReg24 = ((self_in_dispatchConcretize->operands))[1];
  		dstReg1 = ((self_in_dispatchConcretize->operands))[2];
  		/* begin rotateable8bitBitwiseImmediate:ifTrue:ifFalse: */
  		value6 = val4;
  		while (1) {
  			if ((value6 & 0xFF) == value6) {
  				invert3 = val4 != value6;
  				/* begin machineCodeAt:put: */
  				aWord75 = (invert3
  					? bicsrnimmror(self_in_dispatchConcretize, dstReg1, srcReg24, value6, 0)
  					: andsrnimmror(self_in_dispatchConcretize, dstReg1, srcReg24, value6, 0));
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord75;
  				return 4;
  				goto l257;
  			}
  			for (i10 = 2; i10 <= 30; i10 += 2) {
  				if ((value6 & (((0xFFU << i10) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i10)))) == value6) {
  					rot10 = 32 - i10;
  					immediate17 = ((value6) >> i10) | ((value6 << (32 - i10)) & 0xFFFFFFFFU);
  					invert3 = val4 != value6;
  					/* begin machineCodeAt:put: */
  					aWord75 = (invert3
  						? bicsrnimmror(self_in_dispatchConcretize, dstReg1, srcReg24, immediate17, rot10)
  						: andsrnimmror(self_in_dispatchConcretize, dstReg1, srcReg24, immediate17, rot10));
  					((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord75;
  					return 4;
  					goto l257;
  				}
  			}
  			if (!(value6 == val4)) break;
  			value6 = (val4 < 0
  				? -1 - val4
  				: (unsigned int)~val4);
  		}
  		
  		/* First see if the constant can be made from a simple shift of 0xFFFFFFFF */
  		hb4 = highBit(((self_in_dispatchConcretize->operands))[0]);
  		if ((1U << hb4) == (val4 + 1)) {
  
  			/* MVN temp reg, 0, making 0xffffffff */
  			/* begin machineCodeAt:put: */
  			aWord134 = mvnimmror(self_in_dispatchConcretize, ConcreteIPReg, 0, 0);
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord134;
  			/* begin machineCodeAt:put: */
  			aWord224 = dataOpTyperdrnrmlsr(self_in_dispatchConcretize, AndOpcode, dstReg1, srcReg24, ConcreteIPReg, 32 - hb4);
  			((self_in_dispatchConcretize->machineCode))[4 / 4] = aWord224;
  			return 8;
  		}
  		/* begin concretizeDataOperationCwR:R: */
  		constant13 = ((self_in_dispatchConcretize->operands))[0];
  		rn24 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord314 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord314;
  		instrOffset28 = 4;
  		/* begin machineCodeAt:put: */
  		aWord1111 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(AndOpcode) << 21))) | (0x100000)))) | ((rn24 << 16) | (dstReg1 << 12))) | (ConcreteIPReg & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[instrOffset28 / 4] = aWord1111;
  		return instrOffset28 + 4;
  	l257:	/* end rotateable8bitBitwiseImmediate:ifTrue:ifFalse: */;
  		return self_in_dispatchConcretize;
  
  	case CmpCqR:
  		/* begin concretizeNegateableDataOperationCqR:R: */
  		val2 = ((self_in_dispatchConcretize->operands))[0];
  
  		/* Extra note - if ever a version of this code wants to NOT set the Set flag
  		   - Cmp must always have it set or it will pretend to be a SMALALBT and Very Bad Things might happen. */
  		rn3 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin rotateable8bitSignedImmediate:ifTrue:ifFalse: */
  		value2 = val2;
  		while (1) {
  			if ((value2 & 0xFF) == value2) {
  				negate2 = val2 != value2;
  				/* begin machineCodeAt:put: */
  				flagsOrOpcode5 = (negate2
  					? inverseOpcodeFor(self_in_dispatchConcretize, CmpOpcode)
  					: CmpOpcode);
  				aWord7 = (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((sqInt)((usqInt)(flagsOrOpcode5) << 21))) | (0x100000)))) | ((rn3 << 16) | (0))) | (((0) | value2) & 0xFFF);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord7;
  				return 4;
  				goto l109;
  			}
  			for (i2 = 2; i2 <= 30; i2 += 2) {
  				if ((value2 & (((0xFFU << i2) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i2)))) == value2) {
  					rot2 = 32 - i2;
  					immediate2 = (((usqInt)(value2)) >> i2) | ((((sqInt)((usqInt)(value2) << (32 - i2)))) & 0xFFFFFFFFU);
  					negate2 = val2 != value2;
  					/* begin machineCodeAt:put: */
  					flagsOrOpcode6 = (negate2
  						? inverseOpcodeFor(self_in_dispatchConcretize, CmpOpcode)
  						: CmpOpcode);
  					aWord7 = (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((sqInt)((usqInt)(flagsOrOpcode6) << 21))) | (0x100000)))) | ((rn3 << 16) | (0))) | (((((sqInt)((usqInt)((((usqInt)(rot2)) >> 1)) << 8))) | immediate2) & 0xFFF);
  					((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord7;
  					return 4;
  					goto l109;
  				}
  			}
  			if (!((value2 == val2)
  			 && (val2 != 0))) break;
  			value2 = -val2;
  		}
  		
  		/* let's try to see if the constant can be made from a simple shift of 0xFFFFFFFF */
  		if (val2 > 0) {
  			hb2 = highBit(val2);
  			if ((1U << hb2) == (val2 + 1)) {
  
  				/* MVN temp,  #0, making 0xffffffff */
  				/* begin machineCodeAt:put: */
  				aWord14 = mvnimmror(self_in_dispatchConcretize, ConcreteIPReg, 0, 0);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord14;
  				/* begin machineCodeAt:put: */
  				aWord24 = dataOpTyperdrnrmlsr(self_in_dispatchConcretize, CmpOpcode, 0, rn3, ConcreteIPReg, 32 - hb2);
  				((self_in_dispatchConcretize->machineCode))[4 / 4] = aWord24;
  				return 8;
  			}
  		}
  		/* begin concretizeDataOperationCwR:R: */
  		constant2 = ((self_in_dispatchConcretize->operands))[0];
  		rn12 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord33 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord33;
  		instrOffset4 = 4;
  		/* begin machineCodeAt:put: */
  		aWord113 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(CmpOpcode) << 21))) | (0x100000)))) | ((rn12 << 16) | (0))) | (ConcreteIPReg & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[instrOffset4 / 4] = aWord113;
  		return instrOffset4 + 4;
  	l109:	/* end rotateable8bitSignedImmediate:ifTrue:ifFalse: */;
  		return 0;
  
  	case OrCqR:
  		/* begin concretizeDataOperationCqR: */
  		val5 = ((self_in_dispatchConcretize->operands))[0];
  		rn25 = ((self_in_dispatchConcretize->operands))[1];
  
  		/* Extra note - if ever a version of this code wants to NOT set the Set flag - Cmp must always have it set or it will pretend to be a SMALALBT and Very Bad Things might happen */
  		rd18 = (((self_in_dispatchConcretize->opcode)) == CmpOpcode
  			? 0
  			: rn25);
  		/* begin rotateable8bitImmediate:ifTrue:ifFalse: */
  		if ((val5 & 0xFF) == val5) {
  			/* begin machineCodeAt:put: */
  			aWord76 = (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(OrOpcode) << 21))) | (0x100000)))) | ((rn25 << 16) | (((int)((usqInt)(rd18) << 12))))) | (((0) | val5) & 0xFFF);
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord76;
  			return 4;
  			goto l266;
  		}
  		for (i14 = 2; i14 <= 30; i14 += 2) {
  			if ((val5 & (((0xFFU << i14) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i14)))) == val5) {
  				rot12 = 32 - i14;
  				immediate18 = (((usqInt)(val5)) >> i14) | ((((sqInt)((usqInt)(val5) << (32 - i14)))) & 0xFFFFFFFFU);
  				/* begin machineCodeAt:put: */
  				aWord76 = (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(OrOpcode) << 21))) | (0x100000)))) | ((rn25 << 16) | (((int)((usqInt)(rd18) << 12))))) | (((((sqInt)((usqInt)((((usqInt)(rot12)) >> 1)) << 8))) | immediate18) & 0xFFF);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord76;
  				return 4;
  				goto l266;
  			}
  		}
  	l266:	/* end rotateable8bitImmediate:ifTrue:ifFalse: */;
  		if (val5 > 0) {
  			hb5 = highBit(val5);
  			if ((1U << hb5) == (val5 + 1)) {
  
  				/* MVN temp,  #0, making 0xffffffff */
  				/* begin machineCodeAt:put: */
  				aWord135 = mvnimmror(self_in_dispatchConcretize, ConcreteIPReg, 0, 0);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord135;
  				/* begin machineCodeAt:put: */
  				aWord225 = dataOpTyperdrnrmlsr(self_in_dispatchConcretize, OrOpcode, rd18, rn25, ConcreteIPReg, 32 - hb5);
  				((self_in_dispatchConcretize->machineCode))[4 / 4] = aWord225;
  				return 8;
  			}
  		}
  		/* begin concretizeDataOperationCwR:R: */
  		rd19 = ((self_in_dispatchConcretize->operands))[1];
  		constant14 = ((self_in_dispatchConcretize->operands))[0];
  		rn111 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord315 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord315;
  		instrOffset29 = 4;
  		/* begin machineCodeAt:put: */
  		aWord1112 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(OrOpcode) << 21))) | (0x100000)))) | ((rn111 << 16) | (((sqInt)((usqInt)(rd19) << 12))))) | (ConcreteIPReg & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[instrOffset29 / 4] = aWord1112;
  		return instrOffset29 + 4;
  
  	case SubCqR:
  		/* begin concretizeSubCqR */
  		word = ((self_in_dispatchConcretize->operands))[0];
  		reg1 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin rotateable8bitImmediate:ifTrue:ifFalse: */
  		if ((word & 0xFF) == word) {
  			/* begin machineCodeAt:put: */
  			aWord8 = subsrnimmror(self_in_dispatchConcretize, reg1, reg1, word, 0);
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord8;
  			return 4;
  			goto l118;
  		}
  		for (i3 = 2; i3 <= 30; i3 += 2) {
  			if ((word & (((0xFFU << i3) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i3)))) == word) {
  				rot3 = 32 - i3;
  				immediate3 = (((usqInt)(word)) >> i3) | ((((sqInt)((usqInt)(word) << (32 - i3)))) & 0xFFFFFFFFU);
  				/* begin machineCodeAt:put: */
  				aWord8 = subsrnimmror(self_in_dispatchConcretize, reg1, reg1, immediate3, rot3);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord8;
  				return 4;
  				goto l118;
  			}
  		}
  	l118:	/* end rotateable8bitImmediate:ifTrue:ifFalse: */;
  		/* begin rotateable8bitImmediate:ifTrue:ifFalse: */
  		if (((-word) & 0xFF) == (-word)) {
  			immediate3 = -word;
  			/* begin machineCodeAt:put: */
  			aWord15 = addsrnimmror(self_in_dispatchConcretize, reg1, reg1, immediate3, 0);
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord15;
  			return 4;
  			goto l121;
  		}
  		for (i11 = 2; i11 <= 30; i11 += 2) {
  			if (((-word) & (((0xFFU << i11) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i11)))) == (-word)) {
  				rot3 = 32 - i11;
  				immediate3 = (((usqInt)((-word))) >> i11) | ((((sqInt)((usqInt)((-word)) << (32 - i11)))) & 0xFFFFFFFFU);
  				/* begin machineCodeAt:put: */
  				aWord15 = addsrnimmror(self_in_dispatchConcretize, reg1, reg1, immediate3, rot3);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord15;
  				return 4;
  				goto l121;
  			}
  		}
  	l121:	/* end rotateable8bitImmediate:ifTrue:ifFalse: */;
  		/* begin concretizeDataOperationCwR:R: */
  		constant3 = ((self_in_dispatchConcretize->operands))[0];
  		rn4 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord25 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord25;
  		instrOffset5 = 4;
  		/* begin machineCodeAt:put: */
  		aWord114 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(SubOpcode) << 21))) | (0x100000)))) | ((rn4 << 16) | (reg1 << 12))) | (ConcreteIPReg & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[instrOffset5 / 4] = aWord114;
  		return instrOffset5 + 4;
  
  	case TstCqR:
  		/* begin concretizeTstCqR */
  		reg2 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin rotateable8bitImmediate:ifTrue:ifFalse: */
  		constant4 = ((self_in_dispatchConcretize->operands))[0];
  		if ((constant4 & 0xFF) == constant4) {
  			/* begin machineCodeAt:put: */
  			aWord9 = tstrnimmror(self_in_dispatchConcretize, reg2, reg2, constant4, 0);
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord9;
  			return 4;
  			goto l127;
  		}
  		for (i4 = 2; i4 <= 30; i4 += 2) {
  			if ((constant4 & (((0xFFU << i4) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i4)))) == constant4) {
  				rot4 = 32 - i4;
  				immediate4 = (((usqInt)(constant4)) >> i4) | ((((sqInt)((usqInt)(constant4) << (32 - i4)))) & 0xFFFFFFFFU);
  				/* begin machineCodeAt:put: */
  				aWord9 = tstrnimmror(self_in_dispatchConcretize, reg2, reg2, immediate4, rot4);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord9;
  				return 4;
  				goto l127;
  			}
  		}
  	l127:	/* end rotateable8bitImmediate:ifTrue:ifFalse: */;
  		/* begin concretizeDataOperationCwR:R: */
  		constant11 = ((self_in_dispatchConcretize->operands))[0];
  		rn5 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord26 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord26;
  		instrOffset6 = 4;
  		/* begin machineCodeAt:put: */
  		aWord16 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(TstOpcode) << 21))) | (0x100000)))) | ((rn5 << 16) | (reg2 << 12))) | (ConcreteIPReg & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[instrOffset6 / 4] = aWord16;
  		return instrOffset6 + 4;
  
  	case XorCqR:
  		/* begin concretizeInvertibleDataOperationCqR: */
  		val6 = ((self_in_dispatchConcretize->operands))[0];
  		rn26 = ((self_in_dispatchConcretize->operands))[1];
  		assert(!((((self_in_dispatchConcretize->opcode)) == CmpOpcode)));
  		/* begin rotateable8bitBitwiseImmediate:ifTrue:ifFalse: */
  		value7 = val6;
  		while (1) {
  			if ((value7 & 0xFF) == value7) {
  				invert4 = val6 != value7;
  				/* begin machineCodeAt:put: */
  				flagsOrOpcode7 = (invert4
  					? inverseOpcodeFor(self_in_dispatchConcretize, XorOpcode)
  					: XorOpcode);
  				aWord77 = (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((sqInt)((usqInt)(flagsOrOpcode7) << 21))) | (0x100000)))) | ((rn26 << 16) | (rn26 << 12))) | (((0) | value7) & 0xFFF);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord77;
  				return 4;
  				goto l280;
  			}
  			for (i15 = 2; i15 <= 30; i15 += 2) {
  				if ((value7 & (((0xFFU << i15) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i15)))) == value7) {
  					rot14 = 32 - i15;
  					immediate19 = ((value7) >> i15) | ((value7 << (32 - i15)) & 0xFFFFFFFFU);
  					invert4 = val6 != value7;
  					/* begin machineCodeAt:put: */
  					flagsOrOpcode12 = (invert4
  						? inverseOpcodeFor(self_in_dispatchConcretize, XorOpcode)
  						: XorOpcode);
  					aWord77 = (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((sqInt)((usqInt)(flagsOrOpcode12) << 21))) | (0x100000)))) | ((rn26 << 16) | (rn26 << 12))) | (((((sqInt)((usqInt)((((usqInt)(rot14)) >> 1)) << 8))) | immediate19) & 0xFFF);
  					((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord77;
  					return 4;
  					goto l280;
  				}
  			}
  			if (!(value7 == val6)) break;
  			value7 = (val6 < 0
  				? -1 - val6
  				: (unsigned int)~val6);
  		}
  	l280:	/* end rotateable8bitBitwiseImmediate:ifTrue:ifFalse: */;
  		if (val6 > 0) {
  			hb6 = highBit(val6);
  			if ((1U << hb6) == (val6 + 1)) {
  
  				/* MVN temp,  #0, making 0xffffffff */
  				/* begin machineCodeAt:put: */
  				aWord136 = mvnimmror(self_in_dispatchConcretize, ConcreteIPReg, 0, 0);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord136;
  				/* begin machineCodeAt:put: */
  				aWord226 = dataOpTyperdrnrmlsr(self_in_dispatchConcretize, XorOpcode, rn26, rn26, ConcreteIPReg, 32 - hb6);
  				((self_in_dispatchConcretize->machineCode))[4 / 4] = aWord226;
  				return 8;
  			}
  		}
  		/* begin concretizeDataOperationCqR: */
  		val12 = ((self_in_dispatchConcretize->operands))[0];
  		rn27 = ((self_in_dispatchConcretize->operands))[1];
  
  		/* Extra note - if ever a version of this code wants to NOT set the Set flag - Cmp must always have it set or it will pretend to be a SMALALBT and Very Bad Things might happen */
  		rd20 = (((self_in_dispatchConcretize->opcode)) == CmpOpcode
  			? 0
  			: rn27);
  		/* begin rotateable8bitImmediate:ifTrue:ifFalse: */
  		if ((val12 & 0xFF) == val12) {
  			/* begin machineCodeAt:put: */
  			aWord411 = (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(XorOpcode) << 21))) | (0x100000)))) | ((rn27 << 16) | (((int)((usqInt)(rd20) << 12))))) | (((0) | val12) & 0xFFF);
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord411;
  			return 4;
  			goto l272;
  		}
  		for (i16 = 2; i16 <= 30; i16 += 2) {
  			if ((val12 & (((0xFFU << i16) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i16)))) == val12) {
  				rot13 = 32 - i16;
  				immediate110 = (((usqInt)(val12)) >> i16) | ((((sqInt)((usqInt)(val12) << (32 - i16)))) & 0xFFFFFFFFU);
  				/* begin machineCodeAt:put: */
  				aWord411 = (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(XorOpcode) << 21))) | (0x100000)))) | ((rn27 << 16) | (((int)((usqInt)(rd20) << 12))))) | (((((sqInt)((usqInt)((((usqInt)(rot13)) >> 1)) << 8))) | immediate110) & 0xFFF);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord411;
  				return 4;
  				goto l272;
  			}
  		}
  	l272:	/* end rotateable8bitImmediate:ifTrue:ifFalse: */;
  		if (val12 > 0) {
  			hb12 = highBit(val12);
  			if ((1U << hb12) == (val12 + 1)) {
  
  				/* MVN temp,  #0, making 0xffffffff */
  				/* begin machineCodeAt:put: */
  				aWord1211 = mvnimmror(self_in_dispatchConcretize, ConcreteIPReg, 0, 0);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord1211;
  				/* begin machineCodeAt:put: */
  				aWord2111 = dataOpTyperdrnrmlsr(self_in_dispatchConcretize, XorOpcode, rd20, rn27, ConcreteIPReg, 32 - hb12);
  				((self_in_dispatchConcretize->machineCode))[4 / 4] = aWord2111;
  				return 8;
  			}
  		}
  		/* begin concretizeDataOperationCwR:R: */
  		rd110 = ((self_in_dispatchConcretize->operands))[1];
  		constant15 = ((self_in_dispatchConcretize->operands))[0];
  		rn112 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord316 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord316;
  		instrOffset30 = 4;
  		/* begin machineCodeAt:put: */
  		aWord1113 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(XorOpcode) << 21))) | (0x100000)))) | ((rn112 << 16) | (((sqInt)((usqInt)(rd110) << 12))))) | (ConcreteIPReg & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[instrOffset30 / 4] = aWord1113;
  		return instrOffset30 + 4;
  
  	case AddCwR:
  		/* begin concretizeDataOperationCwR:R: */
  		rd2 = ((self_in_dispatchConcretize->operands))[1];
  		constant5 = ((self_in_dispatchConcretize->operands))[0];
  		rn6 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord10 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord10;
  		instrOffset7 = 4;
  		/* begin machineCodeAt:put: */
  		aWord17 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(AddOpcode) << 21))) | (0x100000)))) | ((rn6 << 16) | (((sqInt)((usqInt)(rd2) << 12))))) | (ConcreteIPReg & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[instrOffset7 / 4] = aWord17;
  		return instrOffset7 + 4;
  
  	case AndCwR:
  		/* begin concretizeDataOperationCwR:R: */
  		rd3 = ((self_in_dispatchConcretize->operands))[1];
  		constant6 = ((self_in_dispatchConcretize->operands))[0];
  		rn7 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord18 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord18;
  		instrOffset8 = 4;
  		/* begin machineCodeAt:put: */
  		aWord19 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(AndOpcode) << 21))) | (0x100000)))) | ((rn7 << 16) | (((sqInt)((usqInt)(rd3) << 12))))) | (ConcreteIPReg & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[instrOffset8 / 4] = aWord19;
  		return instrOffset8 + 4;
  
  	case CmpCwR:
  		/* begin concretizeDataOperationCwR:R: */
  		rd4 = 0;
  		constant7 = ((self_in_dispatchConcretize->operands))[0];
  		rn8 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord20 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord20;
  		instrOffset9 = 4;
  		/* begin machineCodeAt:put: */
  		aWord110 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(CmpOpcode) << 21))) | (0x100000)))) | ((rn8 << 16) | (((sqInt)((usqInt)(rd4) << 12))))) | (ConcreteIPReg & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[instrOffset9 / 4] = aWord110;
  		return instrOffset9 + 4;
  
  	case OrCwR:
  		/* begin concretizeDataOperationCwR:R: */
  		rd5 = ((self_in_dispatchConcretize->operands))[1];
  		constant8 = ((self_in_dispatchConcretize->operands))[0];
  		rn9 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord27 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord27;
  		instrOffset10 = 4;
  		/* begin machineCodeAt:put: */
  		aWord115 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(OrOpcode) << 21))) | (0x100000)))) | ((rn9 << 16) | (((sqInt)((usqInt)(rd5) << 12))))) | (ConcreteIPReg & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[instrOffset10 / 4] = aWord115;
  		return instrOffset10 + 4;
  
  	case SubCwR:
  		/* begin concretizeDataOperationCwR:R: */
  		rd6 = ((self_in_dispatchConcretize->operands))[1];
  		constant9 = ((self_in_dispatchConcretize->operands))[0];
  		rn10 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord28 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord28;
  		instrOffset11 = 4;
  		/* begin machineCodeAt:put: */
  		aWord116 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(SubOpcode) << 21))) | (0x100000)))) | ((rn10 << 16) | (((sqInt)((usqInt)(rd6) << 12))))) | (ConcreteIPReg & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[instrOffset11 / 4] = aWord116;
  		return instrOffset11 + 4;
  
  	case XorCwR:
  		/* begin concretizeDataOperationCwR:R: */
  		rd7 = ((self_in_dispatchConcretize->operands))[1];
  		constant10 = ((self_in_dispatchConcretize->operands))[0];
  		rn13 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord29 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord29;
  		instrOffset12 = 4;
  		/* begin machineCodeAt:put: */
  		aWord117 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(XorOpcode) << 21))) | (0x100000)))) | ((rn13 << 16) | (((sqInt)((usqInt)(rd7) << 12))))) | (ConcreteIPReg & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[instrOffset12 / 4] = aWord117;
  		return instrOffset12 + 4;
  
  	case AddRR:
  		/* begin concretizeDataOperationRR: */
  		srcReg1 = ((self_in_dispatchConcretize->operands))[0];
  		rn14 = ((self_in_dispatchConcretize->operands))[1];
  		rd8 = rn14;
  		/* begin machineCodeAt:put: */
  		aWord30 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(AddOpcode) << 21))) | (0x100000)))) | ((rn14 << 16) | (((int)((usqInt)(rd8) << 12))))) | (srcReg1 & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord30;
  		return 4;
  
  	case AndRR:
  		/* begin concretizeDataOperationRR: */
  		srcReg2 = ((self_in_dispatchConcretize->operands))[0];
  		rn15 = ((self_in_dispatchConcretize->operands))[1];
  		rd9 = rn15;
  		/* begin machineCodeAt:put: */
  		aWord34 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(AndOpcode) << 21))) | (0x100000)))) | ((rn15 << 16) | (((int)((usqInt)(rd9) << 12))))) | (srcReg2 & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord34;
  		return 4;
  
  	case CmpRR:
  		/* begin concretizeDataOperationRR: */
  		srcReg3 = ((self_in_dispatchConcretize->operands))[0];
  		rn16 = ((self_in_dispatchConcretize->operands))[1];
  		rd10 = 0;
  		/* begin machineCodeAt:put: */
  		aWord35 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(CmpOpcode) << 21))) | (0x100000)))) | ((rn16 << 16) | (((int)((usqInt)(rd10) << 12))))) | (srcReg3 & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord35;
  		return 4;
  
  	case OrRR:
  		/* begin concretizeDataOperationRR: */
  		srcReg4 = ((self_in_dispatchConcretize->operands))[0];
  		rn17 = ((self_in_dispatchConcretize->operands))[1];
  		rd11 = rn17;
  		/* begin machineCodeAt:put: */
  		aWord36 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(OrOpcode) << 21))) | (0x100000)))) | ((rn17 << 16) | (((int)((usqInt)(rd11) << 12))))) | (srcReg4 & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord36;
  		return 4;
  
  	case SubRR:
  		/* begin concretizeDataOperationRR: */
  		srcReg5 = ((self_in_dispatchConcretize->operands))[0];
  		rn18 = ((self_in_dispatchConcretize->operands))[1];
  		rd12 = rn18;
  		/* begin machineCodeAt:put: */
  		aWord37 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(SubOpcode) << 21))) | (0x100000)))) | ((rn18 << 16) | (((int)((usqInt)(rd12) << 12))))) | (srcReg5 & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord37;
  		return 4;
  
  	case XorRR:
  		/* begin concretizeDataOperationRR: */
  		srcReg6 = ((self_in_dispatchConcretize->operands))[0];
  		rn19 = ((self_in_dispatchConcretize->operands))[1];
  		rd13 = rn19;
  		/* begin machineCodeAt:put: */
  		aWord38 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(XorOpcode) << 21))) | (0x100000)))) | ((rn19 << 16) | (((int)((usqInt)(rd13) << 12))))) | (srcReg6 & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord38;
  		return 4;
  
  	case AddRRR:
  		/* begin concretizeDataOperationRRR: */
  		srcReg7 = ((self_in_dispatchConcretize->operands))[0];
  		rn20 = ((self_in_dispatchConcretize->operands))[1];
  		rd14 = ((self_in_dispatchConcretize->operands))[2];
  		/* begin machineCodeAt:put: */
  		aWord39 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(AddOpcode) << 21))) | (0x100000)))) | ((rn20 << 16) | (rd14 << 12))) | (srcReg7 & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord39;
  		return 4;
  
  	case SubRRR:
  		/* begin concretizeDataOperationRRR: */
  		srcReg8 = ((self_in_dispatchConcretize->operands))[0];
  		rn21 = ((self_in_dispatchConcretize->operands))[1];
  		rd15 = ((self_in_dispatchConcretize->operands))[2];
  		/* begin machineCodeAt:put: */
  		aWord40 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(SubOpcode) << 21))) | (0x100000)))) | ((rn21 << 16) | (rd15 << 12))) | (srcReg8 & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord40;
  		return 4;
  
  	case AddRdRd:
  		/* begin concretizeAddRdRd */
  		regRHS = ((self_in_dispatchConcretize->operands))[0];
  		regLHS = ((self_in_dispatchConcretize->operands))[1];
  		((self_in_dispatchConcretize->machineCode))[0] = (((3996125952U | (regLHS << 16)) | (regLHS << 12)) | regRHS);
  		return 4;
  
  	case CmpRdRd:
  		/* begin concretizeCmpRdRd */
  		regA = ((self_in_dispatchConcretize->operands))[0];
  		regB = ((self_in_dispatchConcretize->operands))[1];
  		((self_in_dispatchConcretize->machineCode))[0] = ((4004776768U | (regB << 12)) | regA);
  		return 4;
  
  	case DivRdRd:
  		/* begin concretizeDivRdRd */
  		regRHS1 = ((self_in_dispatchConcretize->operands))[0];
  		regLHS1 = ((self_in_dispatchConcretize->operands))[1];
  		((self_in_dispatchConcretize->machineCode))[0] = (((4001368832U | (regLHS1 << 16)) | (regLHS1 << 12)) | regRHS1);
  		return 4;
  
  	case MulRdRd:
  		/* begin concretizeMulRdRd */
  		regRHS2 = ((self_in_dispatchConcretize->operands))[0];
  		regLHS2 = ((self_in_dispatchConcretize->operands))[1];
  		((self_in_dispatchConcretize->machineCode))[0] = (((3995077376U | (regLHS2 << 16)) | (regLHS2 << 12)) | regRHS2);
  		return 4;
  
  	case SubRdRd:
  		/* begin concretizeSubRdRd */
  		regRHS3 = ((self_in_dispatchConcretize->operands))[0];
  		regLHS3 = ((self_in_dispatchConcretize->operands))[1];
  		((self_in_dispatchConcretize->machineCode))[0] = (((3996126016U | (regLHS3 << 16)) | (regLHS3 << 12)) | regRHS3);
  		return 4;
  
  	case SqrtRd:
  		/* begin concretizeSqrtRd */
  		regLHS4 = ((self_in_dispatchConcretize->operands))[0];
  		((self_in_dispatchConcretize->machineCode))[0] = ((4004580288U | (regLHS4 << 12)) | regLHS4);
  		return 4;
  
  	case NegateR:
  		/* begin concretizeNegateR */
  
  		/* RSB destReg, srcReg, #0 */
  		reg3 = ((self_in_dispatchConcretize->operands))[0];
  		aWord41 = ((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(RsbOpcode) << 21))) | (0)))) | ((reg3 << 16) | (reg3 << 12));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord41;
  		return 4;
  
  	case LoadEffectiveAddressMwrR:
  		/* begin concretizeLoadEffectiveAddressMwrR */
  		offset27 = ((self_in_dispatchConcretize->operands))[0];
  		srcReg9 = ((self_in_dispatchConcretize->operands))[1];
  		destReg1 = ((self_in_dispatchConcretize->operands))[2];
  		/* begin rotateable8bitImmediate:ifTrue:ifFalse: */
  		if ((offset27 & 0xFF) == offset27) {
  			/* begin machineCodeAt:put: */
  			aWord42 = addrnimmror(self_in_dispatchConcretize, destReg1, srcReg9, offset27, 0);
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord42;
  			return 4;
  		}
  		for (i5 = 2; i5 <= 30; i5 += 2) {
  			if ((offset27 & (((0xFFU << i5) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i5)))) == offset27) {
  				rot5 = 32 - i5;
  				immediate5 = ((offset27) >> i5) | ((offset27 << (32 - i5)) & 0xFFFFFFFFU);
  				/* begin machineCodeAt:put: */
  				aWord42 = addrnimmror(self_in_dispatchConcretize, destReg1, srcReg9, immediate5, rot5);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord42;
  				return 4;
  			}
  		}
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord118 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord118;
  		instrOffset13 = 4;
  		/* begin machineCodeAt:put: */
  		aWord210 = addrnrm(self_in_dispatchConcretize, destReg1, srcReg9, ConcreteIPReg);
  		((self_in_dispatchConcretize->machineCode))[instrOffset13 / 4] = aWord210;
  		return instrOffset13 + 4;
  
  	case ArithmeticShiftRightCqR:
  		/* begin concretizeArithmeticShiftRightCqR */
  		distance = ((self_in_dispatchConcretize->operands))[0];
  		reg4 = ((self_in_dispatchConcretize->operands))[1];
  		assert(((distance >= 1) && (distance <= 0x1F)));
  		/* begin machineCodeAt:put: */
  		aWord43 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(MoveOpcode) << 21))) | (0x100000)))) | ((0) | (reg4 << 12))) | (((distance << 7) | (64 | reg4)) & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord43;
  		return 4;
  
  	case LogicalShiftRightCqR:
  		/* begin concretizeLogicalShiftRightCqR */
  		distance1 = ((self_in_dispatchConcretize->operands))[0];
  		reg5 = ((self_in_dispatchConcretize->operands))[1];
  		assert(((distance1 >= 1) && (distance1 <= 0x1F)));
  		/* begin machineCodeAt:put: */
  		aWord44 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(MoveOpcode) << 21))) | (0x100000)))) | ((0) | (reg5 << 12))) | (((distance1 << 7) | (32 | reg5)) & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord44;
  		return 4;
  
  	case LogicalShiftLeftCqR:
  		/* begin concretizeLogicalShiftLeftCqR */
  		distance2 = ((self_in_dispatchConcretize->operands))[0];
  		reg6 = ((self_in_dispatchConcretize->operands))[1];
  		assert(((distance2 >= 1) && (distance2 <= 0x1F)));
  		/* begin machineCodeAt:put: */
  		aWord45 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(MoveOpcode) << 21))) | (0x100000)))) | ((0) | (reg6 << 12))) | (((distance2 << 7) | reg6) & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord45;
  		return 4;
  
  	case ArithmeticShiftRightCqRR:
  		/* begin concretizeArithmeticShiftRightCqRR */
  		distance3 = ((self_in_dispatchConcretize->operands))[0];
  		srcReg10 = ((self_in_dispatchConcretize->operands))[1];
  		destReg2 = ((self_in_dispatchConcretize->operands))[2];
  		assert(((distance3 >= 1) && (distance3 <= 0x1F)));
  		/* begin machineCodeAt:put: */
  		aWord46 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(MoveOpcode) << 21))) | (0x100000)))) | ((0) | (destReg2 << 12))) | (((distance3 << 7) | (64 | srcReg10)) & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord46;
  		return 4;
  
  	case LogicalShiftRightCqRR:
  		/* begin concretizeLogicalShiftRightCqRR */
  		distance4 = ((self_in_dispatchConcretize->operands))[0];
  		srcReg11 = ((self_in_dispatchConcretize->operands))[1];
  		destReg3 = ((self_in_dispatchConcretize->operands))[2];
  		assert(((distance4 >= 1) && (distance4 <= 0x1F)));
  		/* begin machineCodeAt:put: */
  		aWord47 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(MoveOpcode) << 21))) | (0x100000)))) | ((0) | (destReg3 << 12))) | (((distance4 << 7) | (32 | srcReg11)) & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord47;
  		return 4;
  
  	case LogicalShiftLeftCqRR:
  		/* begin concretizeLogicalShiftLeftCqRR */
  		distance5 = ((self_in_dispatchConcretize->operands))[0];
  		srcReg12 = ((self_in_dispatchConcretize->operands))[1];
  		destReg4 = ((self_in_dispatchConcretize->operands))[2];
  		assert(((distance5 >= 1) && (distance5 <= 0x1F)));
  		/* begin machineCodeAt:put: */
  		aWord48 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(MoveOpcode) << 21))) | (0x100000)))) | ((0) | (destReg4 << 12))) | (((distance5 << 7) | srcReg12) & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord48;
  		return 4;
  
  	case ArithmeticShiftRightRR:
  		/* begin concretizeArithmeticShiftRightRR */
  		distReg = ((self_in_dispatchConcretize->operands))[0];
  
  		/* cond 000 1101 0 0000 destR distR 0101 srcR */
  		destReg5 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin machineCodeAt:put: */
  		aWord49 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(MoveOpcode) << 21))) | (0x100000)))) | ((0) | (destReg5 << 12))) | (((distReg << 8) | (80 | destReg5)) & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord49;
  		return 4;
  
  	case LogicalShiftLeftRR:
  		/* begin concretizeLogicalShiftLeftRR */
  		distReg1 = ((self_in_dispatchConcretize->operands))[0];
  
  		/* cond 000 1101 0 0000 dest dist 0001 srcR */
  		destReg6 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin machineCodeAt:put: */
  		aWord50 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(MoveOpcode) << 21))) | (0x100000)))) | ((0) | (destReg6 << 12))) | (((distReg1 << 8) | (16 | destReg6)) & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord50;
  		return 4;
  
  	case LogicalShiftRightRR:
  		/* begin concretizeLogicalShiftRightRR */
  		distReg2 = ((self_in_dispatchConcretize->operands))[0];
  
  		/* cond 000 1101 0 0000 dest dist 0011 srcR */
  		destReg7 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin machineCodeAt:put: */
  		aWord51 = (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(MoveOpcode) << 21))) | (0x100000)))) | ((0) | (destReg7 << 12))) | (((distReg2 << 8) | (48 | destReg7)) & 0xFFF);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord51;
  		return 4;
  
  	case ClzRR:
  		/* begin concretizeClzRR */
  		maskReg = ((self_in_dispatchConcretize->operands))[0];
  		dest = ((self_in_dispatchConcretize->operands))[1];
  		/* begin machineCodeAt:put: */
  		aWord52 = (((((int)((usqInt)(AL) << 28))) + 24055568) + (dest << 12)) + maskReg;
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord52;
  		return 4;
  
  	case SMULL:
  		return concretizeSMULL(self_in_dispatchConcretize);
  
  	case CMPSMULL:
  		return concretizeCMPSMULL(self_in_dispatchConcretize);
  
  	case MSR:
  		return concretizeMSR(self_in_dispatchConcretize);
  
  	case PopLDM:
  		return concretizePushOrPopMultipleRegisters(self_in_dispatchConcretize, 0);
  
  	case PushSTM:
  		return concretizePushOrPopMultipleRegisters(self_in_dispatchConcretize, 1);
  
  	case MoveCqR:
  		/* begin concretizeMoveCqR */
  		word1 = ((self_in_dispatchConcretize->operands))[0];
  		reg7 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin rotateable8bitImmediate:ifTrue:ifFalse: */
  		if ((word1 & 0xFF) == word1) {
  			/* begin machineCodeAt:put: */
  			aWord53 = movimmror(self_in_dispatchConcretize, reg7, word1, 0);
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord53;
  			return 4;
  			goto l169;
  		}
  		for (i6 = 2; i6 <= 30; i6 += 2) {
  			if ((word1 & (((0xFFU << i6) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i6)))) == word1) {
  				rot6 = 32 - i6;
  				immediate6 = (((usqInt)(word1)) >> i6) | ((((sqInt)((usqInt)(word1) << (32 - i6)))) & 0xFFFFFFFFU);
  				/* begin machineCodeAt:put: */
  				aWord53 = movimmror(self_in_dispatchConcretize, reg7, immediate6, rot6);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord53;
  				return 4;
  				goto l169;
  			}
  		}
  	l169:	/* end rotateable8bitImmediate:ifTrue:ifFalse: */;
  		invVal = (word1 < 0
  			? -1 - word1
  			: (unsigned int)~word1);
  		/* begin rotateable8bitImmediate:ifTrue:ifFalse: */
  		if ((invVal & 0xFF) == invVal) {
  			/* begin machineCodeAt:put: */
  			aWord119 = mvnimmror(self_in_dispatchConcretize, reg7, invVal, 0);
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord119;
  			return 4;
  		}
  		for (i12 = 2; i12 <= 30; i12 += 2) {
  			if ((invVal & (((0xFFU << i12) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i12)))) == invVal) {
  				rot6 = 32 - i12;
  				immediate6 = ((invVal) >> i12) | ((invVal << (32 - i12)) & 0xFFFFFFFFU);
  				/* begin machineCodeAt:put: */
  				aWord119 = mvnimmror(self_in_dispatchConcretize, reg7, immediate6, rot6);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord119;
  				return 4;
  			}
  		}
  		return loadCwInto(self_in_dispatchConcretize, ((self_in_dispatchConcretize->operands))[1]);
  
  	case MoveCwR:
  		/* begin concretizeMoveCwR */
  		return loadCwInto(self_in_dispatchConcretize, ((self_in_dispatchConcretize->operands))[1]);
  
  	case MoveRR:
  		/* begin concretizeMoveRR */
  		srcReg13 = ((self_in_dispatchConcretize->operands))[0];
  
  		/* cond 000 1101 0 0000 dest 0000 0000 srcR */
  		destReg8 = ((self_in_dispatchConcretize->operands))[1];
  		/* begin machineCodeAt:put: */
  		aWord54 = movrn(self_in_dispatchConcretize, destReg8, srcReg13);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord54;
  		return 4;
  
  	case MoveAwR:
  		/* begin concretizeMoveAwR */
  		srcAddr = ((self_in_dispatchConcretize->operands))[0];
  		destReg9 = ((self_in_dispatchConcretize->operands))[1];
  		if ((srcAddr != null)
  		 && ((srcAddr >= (varBaseAddress()))
  		 && ((srcAddr - (varBaseAddress())) < (4096)))) {
  			/* begin machineCodeAt:put: */
  			aWord55 = ldrrnplusImm(self_in_dispatchConcretize, destReg9, ConcreteVarBaseReg, srcAddr - (varBaseAddress()));
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord55;
  			return 4;
  		}
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord120 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord120;
  		instrOffset14 = 4;
  		/* begin machineCodeAt:put: */
  		aWord211 = ldrrnplusImm(self_in_dispatchConcretize, destReg9, ConcreteIPReg, 0);
  		((self_in_dispatchConcretize->machineCode))[instrOffset14 / 4] = aWord211;
  		return instrOffset14 + 4;
  
  	case MoveRAw:
  		/* begin concretizeMoveRAw */
  		srcReg14 = ((self_in_dispatchConcretize->operands))[0];
  		destAddr = ((self_in_dispatchConcretize->operands))[1];
  		if ((destAddr != null)
  		 && ((destAddr >= (varBaseAddress()))
  		 && ((destAddr - (varBaseAddress())) < (4096)))) {
  			/* begin machineCodeAt:put: */
  			aWord56 = strrnplusImm(self_in_dispatchConcretize, srcReg14, ConcreteVarBaseReg, destAddr - (varBaseAddress()));
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord56;
  			return 4;
  		}
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord121 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord121;
  		instrOffset15 = 4;
  		/* begin machineCodeAt:put: */
  		aWord212 = strrnplusImm(self_in_dispatchConcretize, srcReg14, ConcreteIPReg, 0);
  		((self_in_dispatchConcretize->machineCode))[instrOffset15 / 4] = aWord212;
  		return instrOffset15 + 4;
  
  	case MoveAbR:
  		/* begin concretizeMoveAbR */
  		srcAddr1 = ((self_in_dispatchConcretize->operands))[0];
  		destReg10 = ((self_in_dispatchConcretize->operands))[1];
  		if ((srcAddr1 != null)
  		 && ((srcAddr1 >= (varBaseAddress()))
  		 && ((srcAddr1 - (varBaseAddress())) < (4096)))) {
  			/* begin machineCodeAt:put: */
  			aWord57 = ldrbrnplusimm(self_in_dispatchConcretize, destReg10, ConcreteVarBaseReg, 1, srcAddr1 - (varBaseAddress()));
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord57;
  			return 4;
  		}
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord122 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord122;
  		instrOffset16 = 4;
  		/* begin machineCodeAt:put: */
  		aWord213 = ldrbrnplusimm(self_in_dispatchConcretize, destReg10, ConcreteIPReg, 1, 0);
  		((self_in_dispatchConcretize->machineCode))[instrOffset16 / 4] = aWord213;
  		return instrOffset16 + 4;
  
  	case MoveRAb:
  		/* begin concretizeMoveRAb */
  		srcReg15 = ((self_in_dispatchConcretize->operands))[0];
  		destAddr1 = ((self_in_dispatchConcretize->operands))[1];
  		if ((destAddr1 != null)
  		 && ((destAddr1 >= (varBaseAddress()))
  		 && ((destAddr1 - (varBaseAddress())) < (4096)))) {
  			/* begin machineCodeAt:put: */
  			aWord58 = strbrnplusimm(self_in_dispatchConcretize, srcReg15, ConcreteVarBaseReg, 1, destAddr1 - (varBaseAddress()));
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord58;
  			return 4;
  		}
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord123 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord123;
  		instrOffset17 = 4;
  		/* begin machineCodeAt:put: */
  		aWord214 = strbrnplusimm(self_in_dispatchConcretize, srcReg15, ConcreteIPReg, 1, 0);
  		((self_in_dispatchConcretize->machineCode))[instrOffset17 / 4] = aWord214;
  		return instrOffset17 + 4;
  
  	case MoveMbrR:
  		/* begin concretizeMoveMbrR */
  		offset28 = ((self_in_dispatchConcretize->operands))[0];
  		srcReg16 = ((self_in_dispatchConcretize->operands))[1];
  		destReg11 = ((self_in_dispatchConcretize->operands))[2];
  		/* begin is12BitValue:ifTrue:ifFalse: */
  		if ((SQABS(offset28)) <= 0xFFF) {
  
  			/* (2 raisedTo: 12)-1 */
  			if (offset28 >= 0) {
  				/* begin machineCodeAt:put: */
  				aWord59 = ldrbrnplusimm(self_in_dispatchConcretize, destReg11, srcReg16, 1, offset28);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord59;
  				return 4;
  			}
  			else {
  				immediate7 = SQABS(offset28);
  				/* begin machineCodeAt:put: */
  				aWord59 = ldrbrnplusimm(self_in_dispatchConcretize, destReg11, srcReg16, 0, immediate7);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord59;
  				return 4;
  			}
  		}
  		else {
  			if ((offset28 != null)
  			 && ((offset28 >= (varBaseAddress()))
  			 && ((offset28 - (varBaseAddress())) < (4096)))) {
  				/* begin machineCodeAt:put: */
  				aWord124 = addsrnimmror(self_in_dispatchConcretize, ConcreteIPReg, ConcreteVarBaseReg, offset28 - (varBaseAddress()), 0);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord124;
  				instrOffset18 = 4;
  			}
  			else {
  				/* begin moveCw:intoR: */
  				assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  				assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  				/* begin machineCodeAt:put: */
  				aWord215 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  					? 1
  					: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord215;
  				instrOffset18 = 4;
  			}
  			/* begin machineCodeAt:put: */
  			aWord310 = ldrbrnrm(self_in_dispatchConcretize, destReg11, srcReg16, ConcreteIPReg);
  			((self_in_dispatchConcretize->machineCode))[instrOffset18 / 4] = aWord310;
  			return instrOffset18 + 4;
  		}
  
  	case MoveRMbr:
  		/* begin concretizeMoveRMbr */
  		srcReg17 = ((self_in_dispatchConcretize->operands))[0];
  		offset29 = ((self_in_dispatchConcretize->operands))[1];
  		baseReg = ((self_in_dispatchConcretize->operands))[2];
  		/* begin is12BitValue:ifTrue:ifFalse: */
  		if ((SQABS(offset29)) <= 0xFFF) {
  
  			/* (2 raisedTo: 12)-1 */
  			if (offset29 >= 0) {
  				/* begin machineCodeAt:put: */
  				aWord60 = strbrnplusimm(self_in_dispatchConcretize, srcReg17, baseReg, 1, offset29);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord60;
  				return 4;
  			}
  			else {
  				immediate8 = SQABS(offset29);
  				/* begin machineCodeAt:put: */
  				aWord60 = strbrnplusimm(self_in_dispatchConcretize, srcReg17, baseReg, 0, immediate8);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord60;
  				return 4;
  			}
  		}
  		else {
  			if ((offset29 != null)
  			 && ((offset29 >= (varBaseAddress()))
  			 && ((offset29 - (varBaseAddress())) < (4096)))) {
  				/* begin machineCodeAt:put: */
  				aWord125 = addsrnimmror(self_in_dispatchConcretize, ConcreteIPReg, ConcreteVarBaseReg, offset29 - (varBaseAddress()), 0);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord125;
  				instrOffset19 = 4;
  			}
  			else {
  				/* begin moveCw:intoR: */
  				assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  				assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  				/* begin machineCodeAt:put: */
  				aWord216 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  					? 1
  					: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord216;
  				instrOffset19 = 4;
  			}
  			/* begin machineCodeAt:put: */
  			aWord311 = strbrnrm(self_in_dispatchConcretize, srcReg17, baseReg, ConcreteIPReg);
  			((self_in_dispatchConcretize->machineCode))[instrOffset19 / 4] = aWord311;
  			return instrOffset19 + 4;
  		}
  
  	case MoveRM16r:
  		/* begin concretizeMoveRM16r */
  		srcReg18 = ((self_in_dispatchConcretize->operands))[0];
  		offset30 = ((self_in_dispatchConcretize->operands))[1];
  		baseReg1 = ((self_in_dispatchConcretize->operands))[2];
  		/* begin is12BitValue:ifTrue:ifFalse: */
  		if ((SQABS(offset30)) <= 0xFFF) {
  
  			/* (2 raisedTo: 12)-1 */
  			if (offset30 >= 0) {
  				/* begin machineCodeAt:put: */
  				aWord61 = strhrnplusimm(self_in_dispatchConcretize, srcReg18, baseReg1, 1, offset30);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord61;
  				return 4;
  			}
  			else {
  				immediate9 = SQABS(offset30);
  				/* begin machineCodeAt:put: */
  				aWord61 = strhrnplusimm(self_in_dispatchConcretize, srcReg18, baseReg1, 0, immediate9);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord61;
  				return 4;
  			}
  		}
  		else {
  			if ((offset30 != null)
  			 && ((offset30 >= (varBaseAddress()))
  			 && ((offset30 - (varBaseAddress())) < (4096)))) {
  				/* begin machineCodeAt:put: */
  				aWord126 = addsrnimmror(self_in_dispatchConcretize, ConcreteIPReg, ConcreteVarBaseReg, offset30 - (varBaseAddress()), 0);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord126;
  				instrOffset20 = 4;
  			}
  			else {
  				/* begin moveCw:intoR: */
  				assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  				assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  				/* begin machineCodeAt:put: */
  				aWord217 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  					? 1
  					: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord217;
  				instrOffset20 = 4;
  			}
  			/* begin machineCodeAt:put: */
  			aWord312 = strhrnrm(self_in_dispatchConcretize, srcReg18, baseReg1, ConcreteIPReg);
  			((self_in_dispatchConcretize->machineCode))[instrOffset20 / 4] = aWord312;
  			return instrOffset20 + 4;
  		}
  
  	case MoveM16rR:
  		/* begin concretizeMoveM16rR */
  		offset31 = ((self_in_dispatchConcretize->operands))[0];
  		srcReg19 = ((self_in_dispatchConcretize->operands))[1];
  		destReg12 = ((self_in_dispatchConcretize->operands))[2];
  		/* begin is8BitValue:ifTrue:ifFalse: */
  		if ((SQABS(offset31)) <= 0xFF) {
  
  			/* (2 raisedTo: 8)-1 */
  			if (offset31 >= 0) {
  				/* begin machineCodeAt:put: */
  				aWord62 = ldrhrnplusimm(self_in_dispatchConcretize, destReg12, srcReg19, 1, offset31);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord62;
  				return 4;
  			}
  			else {
  				immediate10 = SQABS(offset31);
  				/* begin machineCodeAt:put: */
  				aWord62 = ldrhrnplusimm(self_in_dispatchConcretize, destReg12, srcReg19, 0, immediate10);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord62;
  				return 4;
  			}
  		}
  		else {
  			/* begin moveCw:intoR: */
  			assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  			assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  			/* begin machineCodeAt:put: */
  			aWord127 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  				? 1
  				: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord127;
  			instrOffset21 = 4;
  			/* begin machineCodeAt:put: */
  			aWord218 = ldrhrnrm(self_in_dispatchConcretize, destReg12, srcReg19, ConcreteIPReg);
  			((self_in_dispatchConcretize->machineCode))[instrOffset21 / 4] = aWord218;
  			return instrOffset21 + 4;
  		}
  		return 0;
  
  	case MoveM64rRd:
  		/* begin concretizeMoveM64rRd */
  		offset = ((self_in_dispatchConcretize->operands))[0];
  		u = (offset > 0
  			? 1
  			: 0);
  		srcReg = ((self_in_dispatchConcretize->operands))[1];
  		destReg = ((self_in_dispatchConcretize->operands))[2];
  		((self_in_dispatchConcretize->machineCode))[0] = ((((3977251584U | (srcReg << 16)) | (destReg << 12)) | (((int)((usqInt)(u) << 23)))) | (((usqInt)(offset)) >> 2));
  		return 4;
  
  	case MoveMwrR:
  		/* begin concretizeMoveMwrR */
  		offset32 = ((self_in_dispatchConcretize->operands))[0];
  		srcReg20 = ((self_in_dispatchConcretize->operands))[1];
  		destReg13 = ((self_in_dispatchConcretize->operands))[2];
  		/* begin is12BitValue:ifTrue:ifFalse: */
  		if ((SQABS(offset32)) <= 0xFFF) {
  
  			/* (2 raisedTo: 12)-1 */
  			if (offset32 >= 0) {
  				/* begin machineCodeAt:put: */
  				aWord63 = ldrrnplusimm(self_in_dispatchConcretize, destReg13, srcReg20, 1, offset32);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord63;
  				return 4;
  			}
  			else {
  				immediate11 = SQABS(offset32);
  				/* begin machineCodeAt:put: */
  				aWord63 = ldrrnplusimm(self_in_dispatchConcretize, destReg13, srcReg20, 0, immediate11);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord63;
  				return 4;
  			}
  		}
  		else {
  			/* begin moveCw:intoR: */
  			assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  			assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  			/* begin machineCodeAt:put: */
  			aWord128 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  				? 1
  				: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord128;
  			instrOffset22 = 4;
  			/* begin machineCodeAt:put: */
  			aWord219 = ldrrnrm(self_in_dispatchConcretize, destReg13, srcReg20, ConcreteIPReg);
  			((self_in_dispatchConcretize->machineCode))[instrOffset22 / 4] = aWord219;
  			return instrOffset22 + 4;
  		}
  
  	case MoveXbrRR:
  		/* begin concretizeMoveXbrRR */
  
  		/* index is number of *bytes* */
  		index = ((self_in_dispatchConcretize->operands))[0];
  		base = ((self_in_dispatchConcretize->operands))[1];
  
  		/* LDRB	dest, [base, +index, LSL #0] */
  		/* cond 011 1100 1 base dest 00000 00 0 inde */
  		dest1 = ((self_in_dispatchConcretize->operands))[2];
  		/* begin machineCodeAt:put: */
  		aWord64 = ldrbrnrm(self_in_dispatchConcretize, dest1, base, index);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord64;
  		return 4;
  
  	case MoveRXbrR:
  		/* begin concretizeMoveRXbrR */
  		src = ((self_in_dispatchConcretize->operands))[0];
  		index1 = ((self_in_dispatchConcretize->operands))[1];
  
  		/* str	b	src, [base, +index, LSL #0] */
  		/* cond 011 1100 0 base srcR 00000 00 0 index */
  		base1 = ((self_in_dispatchConcretize->operands))[2];
  		/* begin machineCodeAt:put: */
  		aWord65 = strbrnrm(self_in_dispatchConcretize, src, base1, index1);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord65;
  		return 4;
  
  	case MoveXwrRR:
  		/* begin concretizeMoveXwrRR */
  		index2 = ((self_in_dispatchConcretize->operands))[0];
  		base2 = ((self_in_dispatchConcretize->operands))[1];
  
  		/* LDR	dest, [base, +index, LSL #2] */
  		/* cond 011 1100 1 base dest 00010 00 0 inde bulit by lowest level generator so we can do the lsl #2 on the index register */
  		dest2 = ((self_in_dispatchConcretize->operands))[2];
  		/* begin machineCodeAt:put: */
  		aWord66 = memMxrregbasepubwlrmLsl2(self_in_dispatchConcretize, AL, dest2, base2, 1, 1, 0, 0, 1, index2);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord66;
  		return 4;
  
  	case MoveRXwrR:
  		/* begin concretizeMoveRXwrR */
  		src1 = ((self_in_dispatchConcretize->operands))[0];
  
  		/* index is number of *words* = 4* bytes */
  		index3 = ((self_in_dispatchConcretize->operands))[1];
  
  		/* str		src, [base, +index, LSL #2] */
  		/* cond 011 1100 0 base srcR 00010 00 0 inde */
  		base3 = ((self_in_dispatchConcretize->operands))[2];
  		/* begin machineCodeAt:put: */
  		aWord67 = memMxrregbasepubwlrmLsl2(self_in_dispatchConcretize, AL, src1, base3, 1, 1, 0, 0, 0, index3);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord67;
  		return 4;
  
  	case MoveRMwr:
  		/* begin concretizeMoveRMwr */
  		srcReg21 = ((self_in_dispatchConcretize->operands))[0];
  		offset33 = ((self_in_dispatchConcretize->operands))[1];
  		baseReg2 = ((self_in_dispatchConcretize->operands))[2];
  		/* begin is12BitValue:ifTrue:ifFalse: */
  		if ((SQABS(offset33)) <= 0xFFF) {
  
  			/* (2 raisedTo: 12)-1 */
  			if (offset33 >= 0) {
  				/* begin machineCodeAt:put: */
  				aWord68 = strrnplusimm(self_in_dispatchConcretize, srcReg21, baseReg2, 1, offset33);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord68;
  				return 4;
  			}
  			else {
  				immediate12 = SQABS(offset33);
  				/* begin machineCodeAt:put: */
  				aWord68 = strrnplusimm(self_in_dispatchConcretize, srcReg21, baseReg2, 0, immediate12);
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord68;
  				return 4;
  			}
  		}
  		else {
  			/* begin moveCw:intoR: */
  			assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  			assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  			/* begin machineCodeAt:put: */
  			aWord129 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  				? 1
  				: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord129;
  			instrOffset23 = 4;
  			/* begin machineCodeAt:put: */
  			aWord220 = strrnrm(self_in_dispatchConcretize, srcReg21, baseReg2, ConcreteIPReg);
  			((self_in_dispatchConcretize->machineCode))[instrOffset23 / 4] = aWord220;
  			return instrOffset23 + 4;
  		}
  
  	case MoveRdM64r:
  		/* begin concretizeMoveRdM64r */
  		offset1 = ((self_in_dispatchConcretize->operands))[1];
  		u1 = (offset1 > 0
  			? 1
  			: 0);
  		dstReg = ((self_in_dispatchConcretize->operands))[2];
  		fpReg = ((self_in_dispatchConcretize->operands))[0];
  		((self_in_dispatchConcretize->machineCode))[0] = ((((3976203008U | (dstReg << 16)) | (fpReg << 12)) | (((int)((usqInt)(u1) << 23)))) | (((usqInt)(offset1)) >> 2));
  		return 4;
  
  	case PopR:
  		/* begin concretizePopR */
  
  		/* LDR destReg, [SP], #4 */
  		destReg14 = ((self_in_dispatchConcretize->operands))[0];
  		aWord69 = popR(self_in_dispatchConcretize, destReg14);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord69;
  		return 4;
  
  	case PushR:
  		/* begin concretizePushR */
  
  		/* cond | 010 | 1001 | 0 | -Rn- | -Rd- | 0000 0000 0100 */
  		/* STR srcReg, [sp, #-4] */
  		srcReg22 = ((self_in_dispatchConcretize->operands))[0];
  		aWord70 = pushR(self_in_dispatchConcretize, srcReg22);
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord70;
  		return 4;
  
  	case PushCq:
  		/* begin concretizePushCq */
  		word2 = ((self_in_dispatchConcretize->operands))[0];
  		/* begin rotateable8bitBitwiseImmediate:ifTrue:ifFalse: */
  		value3 = word2;
  		while (1) {
  			if ((value3 & 0xFF) == value3) {
  				invert = word2 != value3;
  				/* begin machineCodeAt:put: */
  				aWord71 = (invert
  					? mvnimmror(self_in_dispatchConcretize, ConcreteIPReg, value3, 0)
  					: movimmror(self_in_dispatchConcretize, ConcreteIPReg, value3, 0));
  				((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord71;
  				instrOffset24 = 4;
  				goto l226;
  			}
  			for (i7 = 2; i7 <= 30; i7 += 2) {
  				if ((value3 & (((0xFFU << i7) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i7)))) == value3) {
  					rot7 = 32 - i7;
  					immediate13 = ((value3) >> i7) | ((value3 << (32 - i7)) & 0xFFFFFFFFU);
  					invert = word2 != value3;
  					/* begin machineCodeAt:put: */
  					aWord71 = (invert
  						? mvnimmror(self_in_dispatchConcretize, ConcreteIPReg, immediate13, rot7)
  						: movimmror(self_in_dispatchConcretize, ConcreteIPReg, immediate13, rot7));
  					((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord71;
  					instrOffset24 = 4;
  					goto l226;
  				}
  			}
  			if (!(value3 == word2)) break;
  			value3 = (word2 < 0
  				? -1 - word2
  				: (unsigned int)~word2);
  		}
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord130 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord130;
  		instrOffset24 = 4;
  	l226:	/* end rotateable8bitBitwiseImmediate:ifTrue:ifFalse: */;
  		/* begin machineCodeAt:put: */
  		aWord221 = pushR(self_in_dispatchConcretize, ConcreteIPReg);
  		((self_in_dispatchConcretize->machineCode))[instrOffset24 / 4] = aWord221;
  		return instrOffset24 + 4;
  
  	case PushCw:
  		/* begin concretizePushCw */
  		word3 = ((self_in_dispatchConcretize->operands))[0];
  		if (((addressIsInInstructions(((AbstractInstruction *) word3)))
  		 || ((((AbstractInstruction *) word3)) == (methodLabel())))
  		 || (addressIsInCurrentCompilation(word3))) {
  			instrOffset25 = loadCwInto(self_in_dispatchConcretize, ConcreteIPReg);
  		}
  		else {
  			/* begin rotateable8bitBitwiseImmediate:ifTrue:ifFalse: */
  			value4 = word3;
  			while (1) {
  				if ((value4 & 0xFF) == value4) {
  					invert1 = word3 != value4;
  					/* begin machineCodeAt:put: */
  					aWord72 = (invert1
  						? mvnimmror(self_in_dispatchConcretize, ConcreteIPReg, value4, 0)
  						: movimmror(self_in_dispatchConcretize, ConcreteIPReg, value4, 0));
  					((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord72;
  					instrOffset25 = 4;
  					goto l230;
  				}
  				for (i8 = 2; i8 <= 30; i8 += 2) {
  					if ((value4 & (((0xFFU << i8) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i8)))) == value4) {
  						rot8 = 32 - i8;
  						immediate14 = ((value4) >> i8) | ((value4 << (32 - i8)) & 0xFFFFFFFFU);
  						invert1 = word3 != value4;
  						/* begin machineCodeAt:put: */
  						aWord72 = (invert1
  							? mvnimmror(self_in_dispatchConcretize, ConcreteIPReg, immediate14, rot8)
  							: movimmror(self_in_dispatchConcretize, ConcreteIPReg, immediate14, rot8));
  						((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord72;
  						instrOffset25 = 4;
  						goto l230;
  					}
  				}
  				if (!(value4 == word3)) break;
  				value4 = (word3 < 0
  					? -1 - word3
  					: (unsigned int)~word3);
  			}
  			instrOffset25 = loadCwInto(self_in_dispatchConcretize, ConcreteIPReg);
  	l230:	/* end rotateable8bitBitwiseImmediate:ifTrue:ifFalse: */;
  		}
  		/* begin machineCodeAt:put: */
  		aWord131 = pushR(self_in_dispatchConcretize, ConcreteIPReg);
  		((self_in_dispatchConcretize->machineCode))[instrOffset25 / 4] = aWord131;
  		return instrOffset25 + 4;
  
  	case PrefetchAw:
  		/* begin concretizePrefetchAw */
  		addressOperand = ((self_in_dispatchConcretize->operands))[0];
  		if ((addressOperand != null)
  		 && ((addressOperand >= (varBaseAddress()))
  		 && ((addressOperand - (varBaseAddress())) < (4096)))) {
  			/* begin machineCodeAt:put: */
  			immediate20 = addressOperand - (varBaseAddress());
  			aWord73 = ((usqInt) (4115722240U | ((((int)((usqInt)(ConcreteVarBaseReg) << 16))) | ((0x800000) | immediate20))));
  			((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord73;
  			return 4;
  		}
  		/* begin moveCw:intoR: */
  		assert(addressIsInCurrentCompilation((((self_in_dispatchConcretize->dependent))->address)));
  		assert((SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8)))) < (4096));
  		/* begin machineCodeAt:put: */
  		aWord132 = ldrrnplusimm(self_in_dispatchConcretize, ConcreteIPReg, PC, (((((self_in_dispatchConcretize->dependent))->address)) >= (((self_in_dispatchConcretize->address)) + 8)
  			? 1
  			: 0), SQABS((((((self_in_dispatchConcretize->dependent))->address)) - (((self_in_dispatchConcretize->address)) + 8))));
  		((self_in_dispatchConcretize->machineCode))[0 / 4] = aWord132;
  		instrOffset26 = 4;
  		/* begin machineCodeAt:put: */
  		aWord222 = 4115722240U | ((((int)((usqInt)(ConcreteIPReg) << 16))) | ((0x800000) | 0));
  		((self_in_dispatchConcretize->machineCode))[instrOffset26 / 4] = aWord222;
  		return instrOffset26 + 4;
  
  	case ConvertRRd:
  		/* begin concretizeConvertRRd */
  		srcReg23 = ((self_in_dispatchConcretize->operands))[0];
  		destReg15 = ((self_in_dispatchConcretize->operands))[1];
  		((self_in_dispatchConcretize->machineCode))[0] = (fmsrFromto(self_in_dispatchConcretize, srcReg23, 9));
  		((self_in_dispatchConcretize->machineCode))[1] = (fsitodFromto(self_in_dispatchConcretize, 9, destReg15));
  		return 8;
  
  	default:
  		error("Case not found and no otherwise clause");
  	}
  	return 0;
  }
  
  
  /*	FMSR or VMOV instruction to move a value from an ARM reg to an fpu double
  	register ready for conversion
  	FMSR regB, regA - ARM_ARM v5 DDI 01001.pdf pp. C4-68
  	VMOV regB, regA - ARM_ARM v7 DDi10406 pp. A8-462-3
   */
  /*	the dest reg bits are spread out a little */
  
  	/* CogARMCompiler>>#fmsrFrom:to: */
  static usqInt NoDbgRegParms
  fmsrFromto(AbstractInstruction * self_in_fmsrFromto, sqInt regA, sqInt regB)
  {
      sqInt destReg;
  
  	destReg = (((sqInt)((usqInt)((((usqInt)(regB)) >> 1)) << 16))) | (((sqInt)((usqInt)((regB & 1)) << 7)));
  	return (3992979984U | (((sqInt)((usqInt)(regA) << 12)))) | destReg;
  }
  
  
  /*	FSITOD or VCVT instruction to move convert an integer value to an fpu
  	double FSITOD regB, regA - ARM_ARM v5 DDI 01001.pdf pp. C4-95
  	VCVTW. regB, regA - ARM_ARM v7 DDI10406.pdf pp. A8-576-8
   */
  /*	the src reg bits are spread out a little */
  
  	/* CogARMCompiler>>#fsitodFrom:to: */
  static usqInt NoDbgRegParms
  fsitodFromto(AbstractInstruction * self_in_fsitodFromto, sqInt regA, sqInt regB)
  {
      sqInt srcReg;
  
  	srcReg = (((usqInt)(regA)) >> 1) | (((sqInt)((usqInt)((regA & 1)) << 5)));
  	return (4005039040U | srcReg) | (((sqInt)((usqInt)(regB) << 12)));
  }
  
  
  /*	Answer if CallFull and/or JumpFull are relative and hence need relocating
  	on method
  	compation. If so, they are annotated with IsRelativeCall in methods and
  	relocated in
  	relocateIfCallOrMethodReference:mcpc:delta: */
  
  	/* CogARMCompiler>>#fullCallsAreRelative */
  static sqInt NoDbgRegParms
  fullCallsAreRelative(AbstractInstruction * self_in_fullCallsAreRelative)
  {
  	return 0;
  }
  
  
  /*	Currently no instruction level support for divide on ARM. See also
  	#canDivQuoRem 
   */
  
  	/* CogARMCompiler>>#genDivR:R:Quo:Rem: */
  static AbstractInstruction * NoDbgRegParms
  genDivRRQuoRem(AbstractInstruction * self_in_genDivRRQuoRem, sqInt abstractRegDivisor, sqInt abstractRegDividend, sqInt abstractRegQuotient, sqInt abstractRegRemainder)
  {
      usqInt divRemFunctionAddr;
      AbstractInstruction * inst;
      sqInt rDividend;
      sqInt rDivisor;
      sqInt rQuotient;
      sqInt rRemainder;
  
  	assert(abstractRegDividend != abstractRegDivisor);
  	assert(abstractRegQuotient != abstractRegRemainder);
  	rDividend = abstractRegDividend;
  	rDivisor = abstractRegDivisor;
  	if (!(rDividend == CArg0Reg)) {
  
  		/* we need to move the value in rDividend to CArg0Reg. Best to double check if rDivisor is already using it first */
  		if (rDivisor == CArg0Reg) {
  
  			/* oh dear; we also need to move rDivisor's value out of the way first.. I'll move it to CArg1Reg and if some nitwit has managed to put rDividend there they deserve the crash */
  			if (rDividend == CArg1Reg) {
  				error("register choices in genDivR:R:Quo:Rem: made life impossible");
  			}
  			genoperandoperand(MoveRR, rDivisor, CArg1Reg);
  			rDivisor = CArg1Reg;
  		}
  		genoperandoperand(MoveRR, rDividend, CArg0Reg);
  	}
  	if (!(rDivisor == CArg1Reg)) {
  		genoperandoperand(MoveRR, rDivisor, CArg1Reg);
  	}
  	divRemFunctionAddr = aeabiDivModFunctionAddr(self_in_genDivRRQuoRem);
  	/* begin saveAndRestoreLinkRegAround: */
  	inst = genoperand(PushR, LinkReg);
  	CallFullRTregistersToBeSavedMask(((usqInt)divRemFunctionAddr), (1U << CArg2Reg) | (1U << CArg3Reg));
  	genoperand(PopR, LinkReg);
  	rQuotient = abstractRegQuotient;
  	rRemainder = abstractRegRemainder;
  	if (!(rQuotient == CArg0Reg)) {
  
  		/* oh good grief, not again */
  		genoperandoperand(MoveRR, CArg0Reg, rQuotient);
  		if (rQuotient == CArg1Reg) {
  			error("register choices in genDivR:R:Quo:Rem: made life impossible");
  		}
  	}
  	if (!(rRemainder == CArg1Reg)) {
  		genoperandoperand(MoveRR, CArg1Reg, rRemainder);
  	}
  	return self_in_genDivRRQuoRem;
  }
  
  
  /*	Generate the code to pass up to four arguments in a C run-time call. Hack:
  	each argument is
  	either a negative number, which encodes a constant, or a non-negative
  	number, that of a register.
  	
  	Run-time calls have no more than four arguments, so chosen so that on ARM,
  	where in its C ABI the
  	first four integer arguments are passed in registers, all arguments can be
  	passed in registers. We
  	defer to the back end to generate this code not so much that the back end
  	knows whether it uses
  	the stack or registers to pass arguments (it does, but...). In fact we
  	defer for an extremely evil reason.
  	Doing so allows the x64 (where up to 6 args are passed) to assign the
  	register arguments in an order
  	that allows some of the argument registers to be used for specific
  	abstract registers, specifically
  	ReceiverResultReg and ClassReg. This is evil, evil, evil, but also it's
  	really nice to keep using the old
  	register assignments the original author has grown accustomed to. */
  
  	/* CogARMCompiler>>#genMarshallNArgs:arg:arg:arg:arg: */
  static AbstractInstruction * NoDbgRegParms
  genMarshallNArgsargargargarg(AbstractInstruction * self_in_genMarshallNArgsargargargarg, sqInt numArgs, sqInt regOrConst0, sqInt regOrConst1, sqInt regOrConst2, sqInt regOrConst3)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *anInstruction3;
  
  	if (numArgs == 0) {
  		return self_in_genMarshallNArgsargargargarg;
  	}
  	if (numArgs > 1) {
  		if ((!(regOrConst1 < NoReg))
  		 && (regOrConst1 == CArg0Reg)) {
  			genoperandoperand(MoveRR, regOrConst1, Extra0Reg);
  			return genMarshallNArgsargargargarg(self_in_genMarshallNArgsargargargarg, numArgs, regOrConst0, Extra0Reg, regOrConst2, regOrConst3);
  		}
  		if (numArgs > 2) {
  			if ((!(regOrConst2 < NoReg))
  			 && ((regOrConst2 == CArg0Reg)
  			 || (regOrConst2 == CArg1Reg))) {
  				genoperandoperand(MoveRR, regOrConst2, Extra1Reg);
  				return genMarshallNArgsargargargarg(self_in_genMarshallNArgsargargargarg, numArgs, regOrConst0, regOrConst1, Extra1Reg, regOrConst3);
  			}
  			if (numArgs > 3) {
  				if ((!(regOrConst3 < NoReg))
  				 && ((regOrConst3 == CArg0Reg)
  				 || ((regOrConst3 == CArg1Reg)
  				 || (regOrConst3 == CArg2Reg)))) {
  					genoperandoperand(MoveRR, regOrConst3, Extra2Reg);
  					return genMarshallNArgsargargargarg(self_in_genMarshallNArgsargargargarg, numArgs, regOrConst0, regOrConst1, regOrConst2, Extra2Reg);
  				}
  			}
  		}
  	}
  	if (regOrConst0 < NoReg) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction = genoperandoperand(MoveCqR, -2 - regOrConst0, CArg0Reg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(-2 - regOrConst0));
  		}
  	}
  	else {
  		if (regOrConst0 != CArg0Reg) {
  			genoperandoperand(MoveRR, regOrConst0, CArg0Reg);
  		}
  	}
  	if (numArgs == 1) {
  		return self_in_genMarshallNArgsargargargarg;
  	}
  	if (regOrConst1 < NoReg) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction1 = genoperandoperand(MoveCqR, -2 - regOrConst1, CArg1Reg);
  		if (usesOutOfLineLiteral(anInstruction1)) {
  			(anInstruction1->dependent = locateLiteral(-2 - regOrConst1));
  		}
  	}
  	else {
  		if (regOrConst1 != CArg1Reg) {
  			genoperandoperand(MoveRR, regOrConst1, CArg1Reg);
  		}
  	}
  	if (numArgs == 2) {
  		return self_in_genMarshallNArgsargargargarg;
  	}
  	if (regOrConst2 < NoReg) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction2 = genoperandoperand(MoveCqR, -2 - regOrConst2, CArg2Reg);
  		if (usesOutOfLineLiteral(anInstruction2)) {
  			(anInstruction2->dependent = locateLiteral(-2 - regOrConst2));
  		}
  	}
  	else {
  		if (regOrConst2 != CArg2Reg) {
  			genoperandoperand(MoveRR, regOrConst2, CArg2Reg);
  		}
  	}
  	if (numArgs == 3) {
  		return self_in_genMarshallNArgsargargargarg;
  	}
  	if (regOrConst3 < NoReg) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction3 = genoperandoperand(MoveCqR, -2 - regOrConst3, CArg3Reg);
  		if (usesOutOfLineLiteral(anInstruction3)) {
  			(anInstruction3->dependent = locateLiteral(-2 - regOrConst3));
  		}
  	}
  	else {
  		if (regOrConst3 != CArg3Reg) {
  			genoperandoperand(MoveRR, regOrConst3, CArg3Reg);
  		}
  	}
  	return self_in_genMarshallNArgsargargargarg;
  }
  
  
  /*	Use SMULL to produce a 64-bit result, explicitly in RISCTempReg,regDest. -
  	ARM_ARM v7 DDI10406 pp. A8-354-5
  	By comparing RISCTempReg with regDest ASR 31(which effectively makes it 0
  	or -1) we know that the result being EQ means the hi reg and the top bit
  	of the lo reg are the same - ie no overflow. The condition code can then
  	be forced to oVerflow by use of MSR APSR_nzcvq, #1, lsl 28
   */
  
  	/* CogARMCompiler>>#genMulR:R: */
  static AbstractInstruction * NoDbgRegParms
  genMulRR(AbstractInstruction * self_in_genMulRR, sqInt regSource, sqInt regDest)
  {
      AbstractInstruction *first;
  
  
  	/* result in RISCTempReg,regDest */
  	first = genoperandoperand(SMULL, regSource, regDest);
  	genoperandoperand(CMPSMULL, RISCTempReg, regDest);
  	genoperand(MSR, 1);
  	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) */
  
  	/* CogARMCompiler>>#genPushRegisterArgsForAbortMissNumArgs: */
  static AbstractInstruction * NoDbgRegParms
  genPushRegisterArgsForAbortMissNumArgs(AbstractInstruction * self_in_genPushRegisterArgsForAbortMissNumArgs, sqInt numArgs)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
  
  	if (numArgs <= 1 /* numRegArgs */) {
  		assert((numRegArgs()) <= 2);
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction = genoperandoperandoperand(MoveMwrR, 0, SPReg, TempReg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(0));
  		}
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction1 = genoperandoperandoperand(MoveRMwr, ReceiverResultReg, 0, SPReg);
  		if (usesOutOfLineLiteral(anInstruction1)) {
  			(anInstruction1->dependent = locateLiteral(0));
  		}
  		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. */
  
  	/* CogARMCompiler>>#genPushRegisterArgsForNumArgs:scratchReg: */
  static AbstractInstruction * NoDbgRegParms
  genPushRegisterArgsForNumArgsscratchReg(AbstractInstruction * self_in_genPushRegisterArgsForNumArgsscratchReg, sqInt numArgs, sqInt ignored)
  {
  	if (numArgs <= 1 /* numRegArgs */) {
  		assert((numRegArgs()) <= 2);
  		genoperand(PushR, ReceiverResultReg);
  		if (numArgs > 0) {
  			genoperand(PushR, Arg0Reg);
  			if (numArgs > 1) {
  				genoperand(PushR, Arg1Reg);
  			}
  		}
  	}
  	return self_in_genPushRegisterArgsForNumArgsscratchReg;
  }
  
  
  /*	This is a no-op on ARM since the ABI passes up to 4 args in registers and
  	trampolines currently observe that limit.
   */
  
  	/* CogARMCompiler>>#genRemoveNArgsFromStack: */
  static sqInt NoDbgRegParms
  genRemoveNArgsFromStack(AbstractInstruction * self_in_genRemoveNArgsFromStack, sqInt n)
  {
  	assert(n <= 4);
  	return 0;
  }
  
  
  /*	Restore the registers in regMask as saved by genSaveRegs:. */
  
  	/* CogARMCompiler>>#genRestoreRegs: */
  static AbstractInstruction * NoDbgRegParms
  genRestoreRegs(AbstractInstruction * self_in_genRestoreRegs, sqInt regMask)
  {
  	/* begin genPopRegisterMask: */
  	return (regMask == 0
  		? genoperandoperand(Label, (labelCounter += 1), bytecodePC)
  		: genoperand(PopLDM, regMask));
  }
  
  
  /*	Save the registers in regMask for a call into the C run-time from a
  	trampoline 
   */
  
  	/* CogARMCompiler>>#genSaveRegs: */
  static AbstractInstruction * NoDbgRegParms
  genSaveRegs(AbstractInstruction * self_in_genSaveRegs, sqInt regMask)
  {
  	/* begin genPushRegisterMask: */
  	return (regMask == 0
  		? genoperandoperand(Label, (labelCounter += 1), bytecodePC)
  		: genoperand(PushSTM, regMask));
  }
  
  	/* CogARMCompiler>>#genSubstituteReturnAddress: */
  static AbstractInstruction * NoDbgRegParms
  genSubstituteReturnAddress(AbstractInstruction * self_in_genSubstituteReturnAddress, sqInt retpc)
  {
  	/* begin gen:literal:operand: */
  	return checkLiteralforInstruction(retpc, genoperandoperand(MoveCwR, retpc, LR));
  }
  
  
  /*	Answer the instruction immediately preceding followingAddress. */
  
  	/* CogARMCompiler>>#instructionBeforeAddress: */
  static sqInt NoDbgRegParms
  instructionBeforeAddress(AbstractInstruction * self_in_instructionBeforeAddress, sqInt followingAddress)
  {
  	return longAt(followingAddress - 4);
  }
  
  
  /*	is this a BLX <targetReg> instruction? */
  
  	/* CogARMCompiler>>#instructionIsBLX: */
  static sqInt NoDbgRegParms
  instructionIsBLX(AbstractInstruction * self_in_instructionIsBLX, sqInt instr)
  {
  	return (conditionIsNotNever(self_in_instructionIsBLX, instr))
  	 && ((instr & 0xFFFFFF0) == 19922736);
  }
  
  
  /*	is this a BL <offset> instruction? */
  
  	/* CogARMCompiler>>#instructionIsBL: */
  static sqInt NoDbgRegParms
  instructionIsBL(AbstractInstruction * self_in_instructionIsBL, sqInt instr)
  {
  	return (conditionIsNotNever(self_in_instructionIsBL, instr))
  	 && ((instr & (251658240)) == (184549376));
  }
  
  
  /*	is this a BX <targetReg> instruction? */
  
  	/* CogARMCompiler>>#instructionIsBX: */
  static sqInt NoDbgRegParms
  instructionIsBX(AbstractInstruction * self_in_instructionIsBX, sqInt instr)
  {
  	return (conditionIsNotNever(self_in_instructionIsBX, instr))
  	 && ((instr & 0xFFFFFF0) == 19922704);
  }
  
  
  /*	is this a B <offset> instruction? */
  
  	/* CogARMCompiler>>#instructionIsB: */
  static sqInt NoDbgRegParms
  instructionIsB(AbstractInstruction * self_in_instructionIsB, sqInt instr)
  {
  	return (conditionIsNotNever(self_in_instructionIsB, instr))
  	 && ((instr & (251658240)) == (167772160));
  }
  
  
  /*	is this a CMP instruction? */
  
  	/* CogARMCompiler>>#instructionIsCMP: */
  static sqInt NoDbgRegParms
  instructionIsCMP(AbstractInstruction * self_in_instructionIsCMP, sqInt instr)
  {
  	return (conditionIsNotNever(self_in_instructionIsCMP, instr))
  	 && (((((usqInt)(instr)) >> 21) & 0x7F) == CmpOpcode);
  }
  
  
  /*	is this any kind of LDR instruction? c.f. memMxr:reg:base:u:b:l:imm: */
  
  	/* CogARMCompiler>>#instructionIsLDR: */
  static sqInt NoDbgRegParms
  instructionIsLDR(AbstractInstruction * self_in_instructionIsLDR, sqInt instr)
  {
  	return (conditionIsNotNever(self_in_instructionIsLDR, instr))
  	 && (((((usqInt)(instr)) >> 20) & 197) == 65);
  }
  
  
  /*	is this an ORR instruction? */
  
  	/* CogARMCompiler>>#instructionIsOR: */
  static sqInt NoDbgRegParms
  instructionIsOR(AbstractInstruction * self_in_instructionIsOR, sqInt instr)
  {
  	return (conditionIsNotNever(self_in_instructionIsOR, instr))
  	 && (((((usqInt)(instr)) >> 21) & 0x7F) == (16 | OrOpcode));
  }
  
  
  /*	is this a push -str r??, [sp, #-4] - instruction? */
  
  	/* CogARMCompiler>>#instructionIsPush: */
  static sqInt NoDbgRegParms
  instructionIsPush(AbstractInstruction * self_in_instructionIsPush, sqInt instr)
  {
  	return (conditionIsNotNever(self_in_instructionIsPush, instr))
  	 && ((instr & 268374015) == 86835204);
  }
  
  
  /*	Answer the instruction size at pc.Simple on ARM ;-) */
  
  	/* CogARMCompiler>>#instructionSizeAt: */
  static sqInt NoDbgRegParms
  instructionSizeAt(AbstractInstruction * self_in_instructionSizeAt, sqInt pc)
  {
  	return 4;
  }
  
  
  /*	Several of the opcodes are inverses. Answer the inverse for an opcode if
  	it has one.
  	See Table A3-2 in sec A3.4 Data-processing instructions of the AARM. */
  
  	/* CogARMCompiler>>#inverseOpcodeFor: */
  static sqInt NoDbgRegParms
  inverseOpcodeFor(AbstractInstruction * self_in_inverseOpcodeFor, sqInt armOpcode)
  {
  	
  	switch (armOpcode) {
  	case AddOpcode:
  		return SubOpcode;
  
  	case AndOpcode:
  		return BicOpcode;
  
  	case BicOpcode:
  		return AndOpcode;
  
  	case CmpOpcode:
  		return CmpNotOpcode;
  
  	case MoveOpcode:
  		return MoveNotOpcode;
  
  	case MoveNotOpcode:
  		return MoveOpcode;
  
  	case SubOpcode:
  		return AddOpcode;
  
  	default:
  		error("opcode has no inverse");
  		return -1;
  
  	}
  }
  
  
  /*	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 */
  
  	/* CogARMCompiler>>#isCallPrecedingReturnPC: */
  static sqInt NoDbgRegParms
  isCallPrecedingReturnPC(AbstractInstruction * self_in_isCallPrecedingReturnPC, sqInt mcpc)
  {
      sqInt call;
  
  	/* begin instructionBeforeAddress: */
  	call = longAt(mcpc - 4);
  	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.
   */
  
  	/* CogARMCompiler>>#isInImmediateJumpRange: */
  static sqInt NoDbgRegParms
  isInImmediateJumpRange(AbstractInstruction * self_in_isInImmediateJumpRange, usqIntptr_t operand)
  {
  	return (((((int) operand)) >= -33554432) && ((((int) operand)) <= 0x1FFFFFC));
  }
  
  	/* CogARMCompiler>>#isJumpAt: */
  static sqInt NoDbgRegParms
  isJumpAt(AbstractInstruction * self_in_isJumpAt, sqInt pc)
  {
      int instr;
  
  	instr = long32At(pc);
  	return (instructionIsB(self_in_isJumpAt, instr))
  	 || (instructionIsBX(self_in_isJumpAt, instr));
  }
  
  
  /*	add xx, pc, blah or sub xx, pc, blah */
  
  	/* CogARMCompiler>>#isPCRelativeValueLoad: */
  static sqInt NoDbgRegParms
  isPCRelativeValueLoad(AbstractInstruction * self_in_isPCRelativeValueLoad, unsigned int instr)
  {
  	return (((instr) >> 16) == 57999)
  	 || (((instr) >> 16) == 57935);
  }
  
  
  /*	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
   */
  
  	/* CogARMCompiler>>#jumpLongByteSize */
  static sqInt NoDbgRegParms
  jumpLongByteSize(AbstractInstruction * self_in_jumpLongByteSize)
  {
  	return 4;
  }
  
  	/* CogARMCompiler>>#jumpLongConditionalByteSize */
  static sqInt NoDbgRegParms
  jumpLongConditionalByteSize(AbstractInstruction * self_in_jumpLongConditionalByteSize)
  {
  	/* begin jumpLongByteSize */
  	return 4;
  }
  
  
  /*	Answer the target address for the long jump immediately preceding mcpc */
  
  	/* CogARMCompiler>>#jumpLongTargetBeforeFollowingAddress: */
  static sqInt NoDbgRegParms
  jumpLongTargetBeforeFollowingAddress(AbstractInstruction * self_in_jumpLongTargetBeforeFollowingAddress, sqInt mcpc)
  {
  	return callTargetFromReturnAddress(self_in_jumpLongTargetBeforeFollowingAddress, mcpc);
  }
  
  	/* CogARMCompiler>>#jumpTargetPCAt: */
  static usqInt NoDbgRegParms
  jumpTargetPCAt(AbstractInstruction * self_in_jumpTargetPCAt, sqInt pc)
  {
      int operand;
      int word;
  
  	word = long32At(pc);
  	operand = word & 0xFFFFFF;
  	if (operand & 0x800000) {
  		operand -= 0x1000000;
  	}
  	return ((operand * 4) + pc) + 8;
  }
  
  
  /*	LDRB destReg, [baseReg, 'u' immediate12bitValue] u=0 -> - ARM_ARM v7
  	DDI10406 pp. A8-128-9
  	Note that this is a very low level interface that does not check the sign
  	of the immediate, nor validity. See for example #concretizeMoveMbrR */
  
  	/* CogARMCompiler>>#ldrb:rn:plus:imm: */
  static sqInt NoDbgRegParms
  ldrbrnplusimm(AbstractInstruction * self_in_ldrbrnplusimm, sqInt destReg, sqInt baseReg, sqInt u, sqInt immediate12bitValue)
  {
  	return memMxrregbaseublimm(self_in_ldrbrnplusimm, AL, destReg, baseReg, u, 1, 1, immediate12bitValue);
  }
  
  
  /*	LDRB destReg, [baseReg, + offsetReg] - ARM_ARM v7 DDI10406 pp. A8-132-3
  	The contents of offsetReg are assumed to be correctly signed */
  
  	/* CogARMCompiler>>#ldrb:rn:rm: */
  static sqInt NoDbgRegParms
  ldrbrnrm(AbstractInstruction * self_in_ldrbrnrm, sqInt destReg, sqInt baseReg, sqInt offsetReg)
  {
  	return memMxrregbasepubwlrm(self_in_ldrbrnrm, AL, destReg, baseReg, 1, 1, 1, 0, 1, offsetReg);
  }
  
  
  /*	LDRH destReg, [baseReg, 'u' immediate8bitValue] u=0 -> subtract imm; =1 ->
  	add imm - ARM_ARM v7 DDI10406 pp. A8-152-3 */
  
  	/* CogARMCompiler>>#ldrh:rn:plus:imm: */
  static sqInt NoDbgRegParms
  ldrhrnplusimm(AbstractInstruction * self_in_ldrhrnplusimm, sqInt destReg, sqInt baseReg, sqInt u, sqInt immediate8bitValue)
  {
  	return memM16xrregbasepuwloffset(self_in_ldrhrnplusimm, AL, destReg, baseReg, 1, u, 0, 1, immediate8bitValue);
  }
  
  
  /*	LDRH destReg, [baseReg, +offsetReg] - ARM_ARM v7 DDI10406 pp. A8-156-7
  	The contents of offsetReg are assumed to be correctly signed */
  
  	/* CogARMCompiler>>#ldrh:rn:rm: */
  static sqInt NoDbgRegParms
  ldrhrnrm(AbstractInstruction * self_in_ldrhrnrm, sqInt destReg, sqInt baseReg, sqInt offsetReg)
  {
  	return memM16xrregbasepuwlrm(self_in_ldrhrnrm, AL, destReg, baseReg, 1, 1, 0, 1, offsetReg);
  }
  
  
  /*	LDR destReg, [baseReg, +immediate12bitValue] - ARM_ARM v7 DDI10406 pp.
  	A8-120-1 
   */
  
  	/* CogARMCompiler>>#ldr:rn:plusImm: */
  static sqInt NoDbgRegParms
  ldrrnplusImm(AbstractInstruction * self_in_ldrrnplusImm, sqInt destReg, sqInt baseReg, sqInt immediate12bitValue)
  {
  	return memMxrregbaseublimm(self_in_ldrrnplusImm, AL, destReg, baseReg, 1, 0, 1, immediate12bitValue);
  }
  
  
  /*	LDR destReg, [baseReg, immediate12bitValue] u=0 -> subtract imm; =1 -> add
  	imm - ARM_ARM v7 DDI10406 pp. A8-120-1 */
  
  	/* CogARMCompiler>>#ldr:rn:plus:imm: */
  static sqInt NoDbgRegParms
  ldrrnplusimm(AbstractInstruction * self_in_ldrrnplusimm, sqInt destReg, sqInt baseReg, sqInt u, sqInt immediate12bitValue)
  {
  	return memMxrregbaseublimm(self_in_ldrrnplusimm, AL, destReg, baseReg, u, 0, 1, immediate12bitValue);
  }
  
  
  /*	LDR destReg, [baseReg, + offsetReg] - ARM_ARM v7 DDI10406 pp. A8-124-5
  	The contents of offsetReg are assumed to be correctly signed */
  
  	/* CogARMCompiler>>#ldr:rn:rm: */
  static sqInt NoDbgRegParms
  ldrrnrm(AbstractInstruction * self_in_ldrrnrm, sqInt destReg, sqInt baseReg, sqInt offsetReg)
  {
  	return memMxrregbasepubwlrm(self_in_ldrrnrm, AL, destReg, baseReg, 1, 1, 0, 0, 1, offsetReg);
  }
  
  
  /*	Load the operand into the destination register, answering
  	the size of the instructions generated to do so. */
  
  	/* CogARMCompiler>>#loadCwInto: */
  static sqInt NoDbgRegParms
  loadCwInto(AbstractInstruction * self_in_loadCwInto, sqInt destReg)
  {
      sqInt aWord;
      sqInt aWord1;
      sqInt distance;
      sqInt i;
      sqInt immediate;
      sqInt negate;
      usqInt operand;
      sqInt rot;
      sqInt value;
  
  	operand = ((self_in_loadCwInto->operands))[0];
  	if ((addressIsInInstructions(((AbstractInstruction *) operand)))
  	 || ((((AbstractInstruction *) operand)) == (methodLabel()))) {
  		operand = ((((AbstractInstruction *) operand))->address);
  	}
  	if (addressIsInCurrentCompilation(operand)) {
  		distance = operand - (((self_in_loadCwInto->address)) + 8);
  		/* begin rotateable8bitSignedImmediate:ifTrue:ifFalse: */
  		value = distance;
  		while (1) {
  			if ((value & 0xFF) == value) {
  				negate = distance != value;
  				/* begin machineCodeAt:put: */
  				aWord = (negate
  					? subrnimmror(self_in_loadCwInto, destReg, PC, value, 0)
  					: addrnimmror(self_in_loadCwInto, destReg, PC, value, 0));
  				((self_in_loadCwInto->machineCode))[0 / 4] = aWord;
  				return 4;
  				goto l2;
  			}
  			for (i = 2; i <= 30; i += 2) {
  				if ((value & (((0xFFU << i) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i)))) == value) {
  					rot = 32 - i;
  					immediate = (((usqInt)(value)) >> i) | ((((sqInt)((usqInt)(value) << (32 - i)))) & 0xFFFFFFFFU);
  					negate = distance != value;
  					/* begin machineCodeAt:put: */
  					aWord = (negate
  						? subrnimmror(self_in_loadCwInto, destReg, PC, immediate, rot)
  						: addrnimmror(self_in_loadCwInto, destReg, PC, immediate, rot));
  					((self_in_loadCwInto->machineCode))[0 / 4] = aWord;
  					return 4;
  					goto l2;
  				}
  			}
  			if (!((value == distance)
  			 && (distance != 0))) break;
  			value = -distance;
  		}
  		assert(!((isAnInstruction(self_in_loadCwInto, ((AbstractInstruction *) (((self_in_loadCwInto->operands))[0]))))));
  	l2:	/* end rotateable8bitSignedImmediate:ifTrue:ifFalse: */;
  	}
  	/* begin moveCw:intoR: */
  	assert(addressIsInCurrentCompilation((((self_in_loadCwInto->dependent))->address)));
  	assert((SQABS((((((self_in_loadCwInto->dependent))->address)) - (((self_in_loadCwInto->address)) + 8)))) < (4096));
  	/* begin machineCodeAt:put: */
  	aWord1 = ldrrnplusimm(self_in_loadCwInto, destReg, PC, (((((self_in_loadCwInto->dependent))->address)) >= (((self_in_loadCwInto->address)) + 8)
  		? 1
  		: 0), SQABS((((((self_in_loadCwInto->dependent))->address)) - (((self_in_loadCwInto->address)) + 8))));
  	((self_in_loadCwInto->machineCode))[0 / 4] = aWord1;
  	return 4;
  }
  
  
  /*	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. */
  
  	/* CogARMCompiler>>#loadPICLiteralByteSize */
  static sqInt NoDbgRegParms
  loadPICLiteralByteSize(AbstractInstruction * self_in_loadPICLiteralByteSize)
  {
  	return 4;
  }
  
  	/* CogARMCompiler>>#machineCodeWords */
  static sqInt NoDbgRegParms
  machineCodeWords(AbstractInstruction * self_in_machineCodeWords)
  {
  	return 8 /* machineCodeBytes */ / 4;
  }
  
  
  /*	build an ARM [base +/- offset8] half-word memory instruction
  	p -> pre-index (1) or post-index (0) the offset. Combines with W to do
  	some odd things.
  	u -> up (1) or down (0) ie + or - for the offset
  	b -> byte(1) or word (0)
  	w -> write-back (1) if pre-indexing. 
  	l -> load (1) or store (0) */
  
  	/* CogARMCompiler>>#memM16xr:reg:base:p:u:w:l:offset: */
  static sqInt NoDbgRegParms
  memM16xrregbasepuwloffset(AbstractInstruction * self_in_memM16xrregbasepuwloffset, sqInt cond, sqInt destReg, sqInt baseReg, sqInt postpreoffset, sqInt updown, sqInt weirdstuff, sqInt loadstore, sqInt offset8)
  {
  	return (((sqInt)((usqInt)(cond) << 28))) | ((0) | ((((sqInt)((usqInt)(postpreoffset) << 24))) | ((((sqInt)((usqInt)(updown) << 23))) | ((0x400000) | ((((sqInt)((usqInt)(weirdstuff) << 21))) | ((((sqInt)((usqInt)(loadstore) << 20))) | ((((sqInt)((usqInt)(baseReg) << 16))) | ((((sqInt)((usqInt)(destReg) << 12))) | ((((sqInt)((usqInt)((offset8 & 240)) << 4))) | ((176) | (offset8 & 15)))))))))));
  }
  
  
  /*	build an ARM [base +/- offsetReg] memory instruction
  	p -> pre-index (1) or post-index (0) the offset. Combines with W to do
  	some odd things.
  	u -> up (1) or down (0) ie + or - for the offset
  	b -> byte(1) or word (0)
  	w -> write-back (1) if pre-indexing. 
  	l -> load (1) or store (0)
   */
  
  	/* CogARMCompiler>>#memM16xr:reg:base:p:u:w:l:rm: */
  static sqInt NoDbgRegParms
  memM16xrregbasepuwlrm(AbstractInstruction * self_in_memM16xrregbasepuwlrm, sqInt cond, sqInt destReg, sqInt baseReg, sqInt postpreoffset, sqInt updown, sqInt weirdstuff, sqInt loadstore, sqInt offsetReg)
  {
  	return (((sqInt)((usqInt)(cond) << 28))) | ((0) | ((((sqInt)((usqInt)(postpreoffset) << 24))) | ((((sqInt)((usqInt)(updown) << 23))) | ((0) | ((((sqInt)((usqInt)(weirdstuff) << 21))) | ((((sqInt)((usqInt)(loadstore) << 20))) | ((((sqInt)((usqInt)(baseReg) << 16))) | ((((sqInt)((usqInt)(destReg) << 12))) | (176 | offsetReg)))))))));
  }
  
  
  /*	build an ARM [base +/- offset] memory instruction
  	p -> pre-index (1) or post-index (0) the offset. Combines with W to do
  	some odd things.
  	u -> up (1) or down (0) ie + or - for the offset
  	b -> byte(1) or word (0)
  	w -> write-back (1) if pre-indexing. 
  	l -> load (1) or store (0)
   */
  
  	/* CogARMCompiler>>#memMxr:reg:base:p:u:b:w:l:imm: */
  static sqInt NoDbgRegParms
  memMxrregbasepubwlimm(AbstractInstruction * self_in_memMxrregbasepubwlimm, sqInt cond, sqInt destReg, sqInt baseReg, sqInt postpreoffset, sqInt updown, sqInt byteword, sqInt weirdstuff, sqInt loadstore, sqInt offset)
  {
  	return (((sqInt)((usqInt)(cond) << 28))) | ((0x4000000) | ((((sqInt)((usqInt)(postpreoffset) << 24))) | ((((sqInt)((usqInt)(updown) << 23))) | ((((sqInt)((usqInt)(byteword) << 22))) | ((((sqInt)((usqInt)(weirdstuff) << 21))) | ((((sqInt)((usqInt)(loadstore) << 20))) | ((((sqInt)((usqInt)(baseReg) << 16))) | ((((sqInt)((usqInt)(destReg) << 12))) | offset))))))));
  }
  
  
  /*	build an ARM [base +/- offsetReg lsl #2] memory instruction - see also
  	#memMxr:reg:base:p:u:b:w:l:rm: and keep them correlated properly
  	p -> pre-index (1) or post-index (0) the offset. Combines with W to do
  	some odd things.
  	u -> up (1) or down (0) ie + or - for the offset
  	b -> byte(1) or word (0)
  	w -> write-back (1) if pre-indexing. 
  	l -> load (1) or store (0)
   */
  
  	/* CogARMCompiler>>#memMxr:reg:base:p:u:b:w:l:rmLsl2: */
  static sqInt NoDbgRegParms
  memMxrregbasepubwlrmLsl2(AbstractInstruction * self_in_memMxrregbasepubwlrmLsl2, sqInt cond, sqInt destReg, sqInt baseReg, sqInt postpreoffset, sqInt updown, sqInt byteword, sqInt weirdstuff, sqInt loadstore, sqInt offsetReg)
  {
  	return (((sqInt)((usqInt)((cond & 15)) << 28))) | ((100663296) | ((((sqInt)((usqInt)((postpreoffset & 1)) << 24))) | ((((sqInt)((usqInt)((updown & 1)) << 23))) | ((((sqInt)((usqInt)((byteword & 1)) << 22))) | ((((sqInt)((usqInt)((weirdstuff & 1)) << 21))) | ((((sqInt)((usqInt)((loadstore & 1)) << 20))) | ((((sqInt)((usqInt)((baseReg & 15)) << 16))) | ((((sqInt)((usqInt)((destReg & 15)) << 12))) | (256 | (offsetReg & 15))))))))));
  }
  
  
  /*	build an ARM [base +/- offsetReg] memory instruction
  	p -> pre-index (1) or post-index (0) the offset. Combines with W to do
  	some odd things.
  	u -> up (1) or down (0) ie + or - for the offset
  	b -> byte(1) or word (0)
  	w -> write-back (1) if pre-indexing. 
  	l -> load (1) or store (0)
   */
  
  	/* CogARMCompiler>>#memMxr:reg:base:p:u:b:w:l:rm: */
  static sqInt NoDbgRegParms
  memMxrregbasepubwlrm(AbstractInstruction * self_in_memMxrregbasepubwlrm, sqInt cond, sqInt destReg, sqInt baseReg, sqInt postpreoffset, sqInt updown, sqInt byteword, sqInt weirdstuff, sqInt loadstore, sqInt offsetReg)
  {
  	return (((sqInt)((usqInt)((cond & 15)) << 28))) | ((100663296) | ((((sqInt)((usqInt)((postpreoffset & 1)) << 24))) | ((((sqInt)((usqInt)((updown & 1)) << 23))) | ((((sqInt)((usqInt)((byteword & 1)) << 22))) | ((((sqInt)((usqInt)((weirdstuff & 1)) << 21))) | ((((sqInt)((usqInt)((loadstore & 1)) << 20))) | ((((sqInt)((usqInt)((baseReg & 15)) << 16))) | ((((sqInt)((usqInt)((destReg & 15)) << 12))) | (offsetReg & 15)))))))));
  }
  
  
  /*	This is the lowest level build of an ARM [base +/- immediate 12bit offset]
  	memory instruction
  	u -> up (1) or down (0) ie + or - for the offset
  	b -> byte(1) or word (0)
  	l -> load (1) or store (0)
   */
  
  	/* CogARMCompiler>>#memMxr:reg:base:u:b:l:imm: */
  static sqInt NoDbgRegParms
  memMxrregbaseublimm(AbstractInstruction * self_in_memMxrregbaseublimm, sqInt cond, sqInt destReg, sqInt baseReg, sqInt updown, sqInt byteword, sqInt loadstore, sqInt immediate12bitValue)
  {
  	return (((sqInt)((usqInt)((cond & 15)) << 28))) | ((83886080) | ((((sqInt)((usqInt)((updown & 1)) << 23))) | ((((sqInt)((usqInt)((byteword & 1)) << 22))) | ((((sqInt)((usqInt)((loadstore & 1)) << 20))) | ((((sqInt)((usqInt)((baseReg & 15)) << 16))) | ((((sqInt)((usqInt)((destReg & 15)) << 12))) | (immediate12bitValue & 0xFFF)))))));
  }
  
  
  /*	MOVS destReg, srcReg - ARM_ARM v7 DDI10406 pp. A8-196-7 */
  
  	/* CogARMCompiler>>#movs:rn: */
  static sqInt NoDbgRegParms
  movsrn(AbstractInstruction * self_in_movsrn, sqInt destReg, sqInt srcReg)
  {
  	return (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(MoveOpcode) << 21))) | (0x100000)))) | ((0) | (((sqInt)((usqInt)(destReg) << 12))))) | (srcReg & 0xFFF);
  }
  
  
  /*	Remember the ROR is doubled by the cpu so use 30>>1 etc.
  	MOV destReg, #immediate8BitValue ROR rot - ARM_ARM v7 DDI10406 pp.
  	A8-194-5 
   */
  
  	/* CogARMCompiler>>#mov:imm:ror: */
  static sqInt NoDbgRegParms
  movimmror(AbstractInstruction * self_in_movimmror, sqInt destReg, sqInt immediate8bitValue, sqInt rot)
  {
  	return (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(MoveOpcode) << 21))) | (0)))) | ((0) | (((sqInt)((usqInt)(destReg) << 12))))) | (((((sqInt)((usqInt)((((usqInt)(rot)) >> 1)) << 8))) | immediate8bitValue) & 0xFFF);
  }
  
  
  /*	MOV destReg, srcReg - ARM_ARM v7 DDI10406 pp. A8-196-7 */
  
  	/* CogARMCompiler>>#mov:rn: */
  static sqInt NoDbgRegParms
  movrn(AbstractInstruction * self_in_movrn, sqInt destReg, sqInt srcReg)
  {
  	return (((((int)((usqInt)(AL) << 28))) | ((0) | ((((int)((usqInt)(MoveOpcode) << 21))) | (0)))) | ((0) | (((sqInt)((usqInt)(destReg) << 12))))) | (srcReg & 0xFFF);
  }
  
  
  /*	Generate an MSR CPSR_f, #flags instruction.
  	Note that 
  	a) CPSR_f is equivalent to APSR_nzcvq (ARM ARM DDI0406A p A8-209 & A2-14)
  	b) We only have business with the NZCV flags so the generated instruction
  	shifts the flags value <<28 - which is a ROR 4
   */
  
  	/* CogARMCompiler>>#msr: */
  static sqInt NoDbgRegParms
  msr(AbstractInstruction * self_in_msr, sqInt flags)
  {
  	return (321450496) + (flags & 15);
  }
  
  
  /*	Remember the ROR is doubled by the cpu so use 30>>1 etc.
  	MVN destReg, #immediate8BitValue ROR rot - ARM_ARM v7 DDI10406 pp.
  	A8-214-5 
   */
  
  	/* CogARMCompiler>>#mvn:imm:ror: */
  static sqInt NoDbgRegParms
  mvnimmror(AbstractInstruction * self_in_mvnimmror, sqInt destReg, sqInt immediate8bitValue, sqInt rot)
  {
  	return (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(MoveNotOpcode) << 21))) | (0)))) | ((0) | (((sqInt)((usqInt)(destReg) << 12))))) | (((((sqInt)((usqInt)((((usqInt)(rot)) >> 1)) << 8))) | immediate8bitValue) & 0xFFF);
  }
  
  	/* CogARMCompiler>>#numIntRegArgs */
  static sqInt NoDbgRegParms
  numIntRegArgs(AbstractInstruction * self_in_numIntRegArgs)
  {
  	return 4;
  }
  
  
  /*	Remember the ROR is doubled by the cpu so use 30>>1 etc.
  	ORR destReg, #immediate8BitValue ROR rot - ARM_ARM v7 DDI10406 pp.
  	A8-228-9 
   */
  
  	/* CogARMCompiler>>#orr:imm:ror: */
  static sqInt NoDbgRegParms
  orrimmror(AbstractInstruction * self_in_orrimmror, sqInt destReg, sqInt immediate8bitValue, sqInt rot)
  {
  	return (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(OrOpcode) << 21))) | (0)))) | ((((sqInt)((usqInt)(destReg) << 16))) | (((sqInt)((usqInt)(destReg) << 12))))) | (((((sqInt)((usqInt)((((usqInt)(rot)) >> 1)) << 8))) | immediate8bitValue) & 0xFFF);
  }
  
  	/* CogARMCompiler>>#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) {
  		codeByteAtput(p, 0xFF);
  	}
  	return self_in_padIfPossibleWithStopsFromto;
  }
  
  
  /*	pop word off TOS
  	LDR srcReg, [sp] #4 - ARM_ARM v7 DDI10406 pp. A8-120-1 */
  
  	/* CogARMCompiler>>#popR: */
  static sqInt NoDbgRegParms
  popR(AbstractInstruction * self_in_popR, sqInt dstReg)
  {
  	return memMxrregbasepubwlimm(self_in_popR, AL, dstReg, SP, 0, 1, 0, 0, 1, 4);
  }
  
  	/* CogARMCompiler>>#pushLinkRegisterByteSize */
  static sqInt NoDbgRegParms
  pushLinkRegisterByteSize(AbstractInstruction * self_in_pushLinkRegisterByteSize)
  {
  	return 4;
  }
  
  
  /*	push word to TOS 
  	STR srcReg, [sp, #-4]! - ARM_ARM v7 DDI10406 pp. A8-382-3 */
  
  	/* CogARMCompiler>>#pushR: */
  static sqInt NoDbgRegParms
  pushR(AbstractInstruction * self_in_pushR, sqInt srcReg)
  {
  	return memMxrregbasepubwlimm(self_in_pushR, AL, srcReg, SP, 1, 0, 0, 1, 0, 4);
  }
  
  	/* CogARMCompiler>>#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 = longAt(retpc - 4);
  		assert((instructionIsB(self_in_relocateCallBeforeReturnPCby, instr))
  		 || (instructionIsBL(self_in_relocateCallBeforeReturnPCby, instr)));
  		distanceDiv4 = instr & 0xFFFFFF;
  		distanceDiv4 += delta / 4;
  		longAtput(retpc - 4, (instr & 0xFF000000U) | (distanceDiv4 & 0xFFFFFF));
  	}
  	return self_in_relocateCallBeforeReturnPCby;
  }
  
  
  /*	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. */
  
  	/* CogARMCompiler>>#rewriteCallAt:target: */
  static sqInt NoDbgRegParms
  rewriteCallAttarget(AbstractInstruction * self_in_rewriteCallAttarget, usqInt callSiteReturnAddress, usqInt callTargetAddress)
  {
  	return rewriteTransferAttarget(self_in_rewriteCallAttarget, callSiteReturnAddress, callTargetAddress);
  }
  
  
  /*	Rewrite a callFull instruction to jump to a different target. This variant
  	is used to rewrite cached primitive calls where we load the target address
  	into ip
  	and use the 'blx ip' instruction for the actual call.
  	Answer the extent of the
  	code change which is used to compute the range of the icache to flush. */
  
  	/* CogARMCompiler>>#rewriteCallFullAt:target: */
  static sqInt NoDbgRegParms
  rewriteCallFullAttarget(AbstractInstruction * self_in_rewriteCallFullAttarget, sqInt callSiteReturnAddress, sqInt callTargetAddress)
  {
  	return rewriteFullTransferAttargetexpectedInstruction(self_in_rewriteCallFullAttarget, callSiteReturnAddress, callTargetAddress, 3778019132U);
  }
  
  
  /*	Rewrite a full jump instruction to jump 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' instruction for the actual jump.
  	Answer the extent of the
  	code change which is used to compute the range of the icache to flush. */
  
  	/* CogARMCompiler>>#rewriteJumpFullAt:target: */
  static sqInt NoDbgRegParms
  rewriteJumpFullAttarget(AbstractInstruction * self_in_rewriteJumpFullAttarget, sqInt callSiteReturnAddress, sqInt callTargetAddress)
  {
  	return rewriteFullTransferAttargetexpectedInstruction(self_in_rewriteJumpFullAttarget, callSiteReturnAddress, callTargetAddress, 3778019100U);
  }
  
  
  /*	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. */
  
  	/* CogARMCompiler>>#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. */
  /*	for debug - [cogit disassembleFrom: callSiteReturnAddress - 10 to:
  	callSiteReturnAddress - 1].
   */
  
  	/* CogARMCompiler>>#rewriteTransferAt:target: */
  static sqInt NoDbgRegParms
  rewriteTransferAttarget(AbstractInstruction * self_in_rewriteTransferAttarget, usqInt callSiteReturnAddress, usqInt callTargetAddress)
  {
      usqInt callDistance;
      sqInt instr;
  
  	if (!(callTargetAddress >= (minCallAddress()))) {
  		error("linking callsite to invalid address");
  	}
  
  	/* pc offset */
  	/* return offset */
  	callDistance = ((usqInt) (callTargetAddress - ((callSiteReturnAddress + 8) - 4)));
  	assert(isInImmediateJumpRange(self_in_rewriteTransferAttarget, callDistance));
  	/* begin instructionBeforeAddress: */
  	instr = longAt(callSiteReturnAddress - 4);
  	assert((instructionIsB(self_in_rewriteTransferAttarget, instr))
  	 || (instructionIsBL(self_in_rewriteTransferAttarget, instr)));
  	longAtput(callSiteReturnAddress - 4, (instr & 0xFF000000U) | ((callDistance / 4) & 0xFFFFFF));
  	assert((callTargetFromReturnAddress(self_in_rewriteTransferAttarget, callSiteReturnAddress)) == callTargetAddress);
  	return 4;
  }
  
  
  /*	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
   */
  
  	/* CogARMCompiler>>#setsConditionCodesFor: */
  static sqInt NoDbgRegParms
  setsConditionCodesFor(AbstractInstruction * self_in_setsConditionCodesFor, sqInt aConditionalJumpOpcode)
  {
  	
  	switch ((self_in_setsConditionCodesFor->opcode)) {
  	case ArithmeticShiftRightCqR:
  	case ArithmeticShiftRightRR:
  	case LogicalShiftLeftCqR:
  	case LogicalShiftLeftRR:
  		return shiftSetsConditionCodesFor(self_in_setsConditionCodesFor, aConditionalJumpOpcode);
  
  	case XorRR:
  		return 1;
  
  	case ClzRR:
  		return 0;
  
  	default:
  		haltmsg("unhandled opcode in setsConditionCodesFor:");
  		return 0;
  
  	}
  }
  
  
  /*	check what flags the opcode needs setting - ARM doesn't set V when simply
  	MOVing 
   */
  
  	/* CogARMCompiler>>#shiftSetsConditionCodesFor: */
  static sqInt NoDbgRegParms
  shiftSetsConditionCodesFor(AbstractInstruction * self_in_shiftSetsConditionCodesFor, sqInt aConditionalJumpOpcode)
  {
  	
  	switch (aConditionalJumpOpcode) {
  	case JumpNegative:
  	case JumpZero:
  	case JumpLess:
  		return 1;
  
  	default:
  		haltmsg("unhandled opcode in setsConditionCodesFor:");
  		return 0;
  
  	}
  }
  
  
  /*	Return a minimum amount of headroom for each stack page (in bytes). In a
  	JIT the stack has to have room for interrupt handlers which will run on
  	the stack.
  	According to ARM architecture v5 reference manual chapter A2.6, the basic
  	interrupt procedure does not push anything onto the stack. It uses
  	SPSR_err and R14_err to preserve state. Afterwards, it calls an interrupt
  	procedure. So leave some room.
   */
  
  	/* CogARMCompiler>>#stackPageInterruptHeadroomBytes */
  static sqInt NoDbgRegParms
  stackPageInterruptHeadroomBytes(AbstractInstruction * self_in_stackPageInterruptHeadroomBytes)
  {
  	return 128;
  }
  
  	/* CogARMCompiler>>#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) {
  		codeLongAtput(addr, (((int)((usqInt)(AL) << 28))) | ((18874368) | (112)));
  	}
  	return self_in_stopsFromto;
  }
  
  
  /*	STRB destReg, [baseReg, 'u' immediate12bitValue] u=0 -> subtract imm; =1
  	-> add imm - ARM_ARM v7 DDI10406 pp. A8-388-9 */
  
  	/* CogARMCompiler>>#strb:rn:plus:imm: */
  static sqInt NoDbgRegParms
  strbrnplusimm(AbstractInstruction * self_in_strbrnplusimm, sqInt destReg, sqInt baseReg, sqInt u, sqInt immediate12bitValue)
  {
  	return memMxrregbaseublimm(self_in_strbrnplusimm, AL, destReg, baseReg, u, 1, 0, immediate12bitValue);
  }
  
  
  /*	STRB srcReg, [baseReg, + offsetReg] - ARM_ARM v7 DDI10406 pp. A8-390-1
  	The contents of offsetReg are assumed to be correctly signed */
  
  	/* CogARMCompiler>>#strb:rn:rm: */
  static sqInt NoDbgRegParms
  strbrnrm(AbstractInstruction * self_in_strbrnrm, sqInt srcReg, sqInt baseReg, sqInt offsetReg)
  {
  	return memMxrregbasepubwlrm(self_in_strbrnrm, AL, srcReg, baseReg, 1, 1, 1, 0, 0, offsetReg);
  }
  
  
  /*	STRH destReg, [baseReg, 'u' immediate8bitValue] u=0 -> subtract imm; =1 ->
  	add imm - ARM_ARM v7 DDI10406 pp. A8-408-9 */
  
  	/* CogARMCompiler>>#strh:rn:plus:imm: */
  static sqInt NoDbgRegParms
  strhrnplusimm(AbstractInstruction * self_in_strhrnplusimm, sqInt destReg, sqInt baseReg, sqInt u, sqInt immediate8bitValue)
  {
  	return memM16xrregbasepuwloffset(self_in_strhrnplusimm, AL, destReg, baseReg, 1, u, 0, 0, immediate8bitValue);
  }
  
  
  /*	STRH srcReg, [baseReg, +offsetReg] - ARM_ARM v7 DDI10406 pp. A8-410-1 */
  
  	/* CogARMCompiler>>#strh:rn:rm: */
  static sqInt NoDbgRegParms
  strhrnrm(AbstractInstruction * self_in_strhrnrm, sqInt srcReg, sqInt baseReg, sqInt offsetReg)
  {
  	return memM16xrregbasepuwlrm(self_in_strhrnrm, AL, srcReg, baseReg, 1, 1, 0, 0, offsetReg);
  }
  
  
  /*	STR srcReg, [baseReg, +immediate12bitValue] - ARM_ARM v7 DDI10406 pp.
  	A8-382-3 
   */
  
  	/* CogARMCompiler>>#str:rn:plusImm: */
  static sqInt NoDbgRegParms
  strrnplusImm(AbstractInstruction * self_in_strrnplusImm, sqInt srcReg, sqInt baseReg, sqInt immediate12bitValue)
  {
  	return memMxrregbaseublimm(self_in_strrnplusImm, AL, srcReg, baseReg, 1, 0, 0, immediate12bitValue);
  }
  
  
  /*	STR destReg, [baseReg, 'u' immediate12bitValue] u=0 -> subtract imm; =1 ->
  	add imm - ARM_ARM v7 DDI10406 pp. A8-382-3 */
  
  	/* CogARMCompiler>>#str:rn:plus:imm: */
  static sqInt NoDbgRegParms
  strrnplusimm(AbstractInstruction * self_in_strrnplusimm, sqInt destReg, sqInt baseReg, sqInt u, sqInt immediate12bitValue)
  {
  	return memMxrregbaseublimm(self_in_strrnplusimm, AL, destReg, baseReg, u, 0, 0, immediate12bitValue);
  }
  
  
  /*	STR srcReg, [baseReg, + offsetReg] - ARM_ARM v7 DDI10406 pp. A8-384-5
  	The contents of offsetReg are assumed to be correctly signed */
  
  	/* CogARMCompiler>>#str:rn:rm: */
  static sqInt NoDbgRegParms
  strrnrm(AbstractInstruction * self_in_strrnrm, sqInt srcReg, sqInt baseReg, sqInt offsetReg)
  {
  	return memMxrregbasepubwlrm(self_in_strrnrm, AL, srcReg, baseReg, 1, 1, 0, 0, 0, offsetReg);
  }
  
  
  /*	Remember the ROR is doubled by the cpu so use 30>>1 etc
  	SUBS destReg, srcReg, #immediate ROR rot - ARM_ARM v7 DDI10406 pp.
  	A8-418-9 
   */
  
  	/* CogARMCompiler>>#subs:rn:imm:ror: */
  static sqInt NoDbgRegParms
  subsrnimmror(AbstractInstruction * self_in_subsrnimmror, sqInt destReg, sqInt srcReg, sqInt immediate, sqInt rot)
  {
  	return (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(SubOpcode) << 21))) | (0x100000)))) | ((((sqInt)((usqInt)(srcReg) << 16))) | (((sqInt)((usqInt)(destReg) << 12))))) | (((((sqInt)((usqInt)((((usqInt)(rot)) >> 1)) << 8))) | immediate) & 0xFFF);
  }
  
  
  /*	Remember the ROR is doubled by the cpu so use 30>>1 etc
  	SUB destReg, srcReg, #immediate ROR rot - ARM_ARM v7 DDI10406 pp. A8-418-9 */
  
  	/* CogARMCompiler>>#sub:rn:imm:ror: */
  static sqInt NoDbgRegParms
  subrnimmror(AbstractInstruction * self_in_subrnimmror, sqInt destReg, sqInt srcReg, sqInt immediate, sqInt rot)
  {
  	return (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(SubOpcode) << 21))) | (0)))) | ((((sqInt)((usqInt)(srcReg) << 16))) | (((sqInt)((usqInt)(destReg) << 12))))) | (((((sqInt)((usqInt)((((usqInt)(rot)) >> 1)) << 8))) | immediate) & 0xFFF);
  }
  
  
  /*	Remember the ROR is doubled by the cpu so use 30>>1 etc */
  /*	also note that TST has no destReg
  	TST srcReg, #immediate ROR rot - ARM_ARM v7 DDI10406 pp. A8-452-3 */
  
  	/* CogARMCompiler>>#tst:rn:imm:ror: */
  static sqInt NoDbgRegParms
  tstrnimmror(AbstractInstruction * self_in_tstrnimmror, sqInt ignored, sqInt srcReg, sqInt immediate, sqInt rot)
  {
  	return (((((int)((usqInt)(AL) << 28))) | ((0x2000000) | ((((int)((usqInt)(TstOpcode) << 21))) | (0x100000)))) | ((((sqInt)((usqInt)(srcReg) << 16))) | (0))) | (((((sqInt)((usqInt)((((usqInt)(rot)) >> 1)) << 8))) | immediate) & 0xFFF);
  }
  
  
  /*	Answer if Call and JumpLong are relative and hence need to take the
  	caller's relocation delta into account during code compaction, rather than
  	just the
  	callee's delta. */
  
  	/* CogARMCompiler>>#zoneCallsAreRelative */
  static sqInt NoDbgRegParms
  zoneCallsAreRelative(AbstractInstruction * self_in_zoneCallsAreRelative)
  {
  	return 1;
  }
  
  	/* CogBlockMethod>>#cmHomeMethod */
  static CogMethod * NoDbgRegParms
  cmHomeMethod(CogBlockMethod * self_in_cmHomeMethod)
  {
  	return ((CogMethod *) ((((usqInt)self_in_cmHomeMethod)) - ((self_in_cmHomeMethod->homeOffset))));
  }
  
  	/* CogBytecodeDescriptor>>#isBranch */
  static sqInt NoDbgRegParms
  isBranch(BytecodeDescriptor * self_in_isBranch)
  {
  	return (((self_in_isBranch->spanFunction)) != null)
  	 && (!((self_in_isBranch->isBlockCreation)));
  }
  
  
  /*	destReg := (signed)srcReg >> quickConstant */
  
  	/* Cogit>>#ArithmeticShiftRightCq:R:R: */
  static AbstractInstruction * NoDbgRegParms
  gArithmeticShiftRightCqRR(sqInt quickConstant, sqInt srcReg, sqInt destReg)
  {
      AbstractInstruction * first;
  
  	return genoperandoperandoperand(ArithmeticShiftRightCqRR, quickConstant, srcReg, destReg);
  	first = genoperandoperand(MoveRR, srcReg, destReg);
  	genoperandoperand(ArithmeticShiftRightCqR, quickConstant, destReg);
  	return first;
  }
  
  	/* Cogit>>#abortOffset */
  sqInt
  abortOffset(void)
  {
  	return missOffset;
  }
  
  	/* Cogit>>#addCleanBlockStarts */
  static void
  addCleanBlockStarts(void)
  {
      sqInt i;
      sqInt iLimiT;
      sqInt lit;
      sqInt startPCOrNil;
  
  	for (i = 1, iLimiT = (literalCountOf(methodObj)); i <= iLimiT; i += 1) {
  		lit = fetchPointerofObject(i, methodObj);
  		startPCOrNil = startPCOrNilOfLiteralin(lit, methodObj);
  		if (!(startPCOrNil == null)) {
  			maxLitIndex = ((maxLitIndex < i) ? i : maxLitIndex);
  			addBlockStartAtnumArgsnumCopiedspan(startPCOrNil - 1, argumentCountOfClosure(lit), copiedValueCountOfClosure(lit), spanForCleanBlockStartingAt(startPCOrNil - 1));
  		}
  	}
  }
  
  
  /*	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 *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  }
  
  	/* Cogit>>#addressIsInCurrentCompilation: */
  static sqInt NoDbgRegParms
  addressIsInCurrentCompilation(sqInt address)
  {
  	return ((((usqInt)address)) >= ((methodLabel->address)))
  	 && ((((usqInt)address)) < ((((youngReferrers()) < (((methodLabel->address)) + MaxMethodSize)) ? (youngReferrers()) : (((methodLabel->address)) + MaxMethodSize))));
  }
  
  	/* Cogit>>#addressIsInFixups: */
  static sqInt NoDbgRegParms
  addressIsInFixups(BytecodeFixup *address)
  {
  	return (BytecodeFixup *)address >= fixups && (BytecodeFixup *)address < (fixups + numAbstractOpcodes);
  }
  
  
  /*	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));
  }
  
  
  /*	Align methodZoneBase to that for the start of a method. */
  
  	/* Cogit>>#alignMethodZoneBase */
  static void
  alignMethodZoneBase(void)
  {
      usqInt oldBase;
  
  	oldBase = methodZoneBase;
  	methodZoneBase = roundUpToMethodAlignment(backEnd(), methodZoneBase);
  	stopsFromto(backEnd, oldBase, methodZoneBase - 1);
  }
  
  	/* 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;
      sqInt 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)) == CMOpenPIC)) {
  			if (!(asserta((mapForperformUntilarg(cogMethod, checkIfValidOopRefAndTargetpccogMethod, ((sqInt)cogMethod))) == 0))) {
  				ok = 0;
  			}
  		}
  		if (((cogMethod->cmType)) == CMClosedPIC) {
  			if (!(asserta(noTargetsFreeInClosedPIC(cogMethod)))) {
  				ok = 0;
  			}
  		}
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((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 *) (roundUpToMethodAlignment(backEnd(), (((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)) {
  		setHasMovableLiteral(1);
  		if (isYoungObject(anOop)) {
  			setHasYoungReferent(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)))))))));
  }
  
  
  /*	{self firstInvalidDualZoneAddress. self firstInvalidDualZoneAddress +
  	codeToDataDelta }
   */
  /*	{self firstInvalidDualZoneAddress hex. (self firstInvalidDualZoneAddress +
  	codeToDataDelta) hex }
   */
  /*	{(objectMemory longAt: self firstInvalidDualZoneAddress) hex.
  	(objectMemory longAt: self firstInvalidDualZoneAddress + codeToDataDelta)
  	hex }
   */
  /*	self armDisassembleDualZoneAnomalies */
  /*	self armPrintDualZoneAnomalies */
  
  	/* Cogit>>#assertValidDualZone */
  static void
  assertValidDualZone(void)
  {
  }
  
  
  /*	Answer an unused abstract register in the registerMask, or NoReg if none. */
  
  	/* Cogit>>#availableRegisterOrNoneIn: */
  static sqInt NoDbgRegParms
  availableRegisterOrNoneIn(sqInt liveRegsMask)
  {
      sqInt reg;
  
  	if (liveRegsMask != 0) {
  		for (reg = 0; reg <= 0x1F; reg += 1) {
  			if (liveRegsMask & (1U << reg)) {
  				return reg;
  			}
  		}
  	}
  	return NoReg;
  }
  
  
  /*	Evaluate binaryFunction with the block start mcpc and supplied arg for
  	each entry in the block dispatch. If the function answers non-zero answer
  	the value
  	it answered. Used to update back-references to the home method in
  	compaction.  */
  
  	/* Cogit>>#blockDispatchTargetsFor:perform:arg: */
  static sqInt NoDbgRegParms
  blockDispatchTargetsForperformarg(CogMethod *cogMethod, usqInt (*binaryFunction)(sqInt mcpc, sqInt arg), sqInt arg)
  {
      sqInt blockEntry;
      usqInt end;
      sqInt pc;
      sqInt result;
      usqInt targetpc;
  
  	if (((cogMethod->blockEntryOffset)) == 0) {
  		return null;
  	}
  	blockEntry = ((cogMethod->blockEntryOffset)) + (((sqInt)cogMethod));
  	pc = blockEntry;
  	end = (mapEndFor(cogMethod)) - 1;
  	while (pc < end) {
  		if (isJumpAt(backEnd, pc)) {
  			targetpc = jumpTargetPCAt(backEnd, pc);
  			if (targetpc < blockEntry) {
  				result = binaryFunction(targetpc, arg);
  				if (result != 0) {
  					return result;
  				}
  			}
  		}
  		pc += 4 /* instructionSizeAt: */;
  	}
  	return 0;
  }
  
  
  /*	Answer the zero-relative bytecode pc matching the machine code pc argument
  	in cogMethod, given the start of the bytecodes for cogMethod's block or
  	method object. */
  
  	/* Cogit>>#bytecodePCFor:startBcpc:in: */
  sqInt
  bytecodePCForstartBcpcin(sqInt mcpc, sqInt startbcpc, CogBlockMethod *cogMethod)
  {
      sqInt aMethodHeader;
      sqInt aMethodHeader1;
      sqInt aMethodObj;
      sqInt annotation;
      sqInt bcpc;
      sqInt bsOffset;
      sqInt byte;
      BytecodeDescriptor *descriptor;
      sqInt distance;
      sqInt endbcpc;
      CogMethod *homeMethod;
      sqInt isBackwardBranch;
      sqInt isInBlock;
      sqInt latestContinuation;
      usqInt map;
      sqInt mapByte;
      usqInt mcpc1;
      sqInt nExts;
      sqInt nextBcpc;
      sqInt result;
      sqInt targetPC;
  
  	latestContinuation = 0;
  	/* begin mapFor:bcpc:performUntil:arg: */
  	assert(((cogMethod->stackCheckOffset)) > 0);
  
  	/* The stack check maps to the start of the first bytecode,
  	   the first bytecode being effectively after frame build. */
  	mcpc1 = (((usqInt)cogMethod)) + ((cogMethod->stackCheckOffset));
  	result = findIsBackwardBranchMcpcBcpcMatchingMcpc(null, (0 + (((int)((usqInt)(HasBytecodePC) << 1)))), (((char *) mcpc1)), startbcpc, (((void *)mcpc)));
  	if (result != 0) {
  		return result;
  	}
  
  	/* In both CMMethod and CMBlock cases find the start of the map and
  	   skip forward to the bytecode pc map entry for the stack check. */
  	bcpc = startbcpc;
  	if (((cogMethod->cmType)) == CMMethod) {
  		/* begin cmIsFullBlock */
  		isInBlock = 0;
  		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;
  		/* begin bytecodeSetOffsetForHeader: */
  		aMethodHeader = (homeMethod->methodHeader);
  		bsOffset = 
  #    if MULTIPLEBYTECODESETS
  			(headerIndicatesAlternateBytecodeSet(aMethodHeader)
  						? 256
  						: 0)
  #    else /* MULTIPLEBYTECODESETS */
  			0
  #    endif /* MULTIPLEBYTECODESETS */
  			;
  		bcpc += deltaToSkipPrimAndErrorStoreInheader(aMethodObj, (homeMethod->methodHeader));
  	}
  	else {
  		isInBlock = 1;
  		assert(bcpc == ((cogMethod->startpc)));
  		homeMethod = cmHomeMethod(cogMethod);
  		map = findMapLocationForMcpcinMethod((((usqInt)cogMethod)) + (sizeof(CogBlockMethod)), homeMethod);
  		assert(map != 0);
  		annotation = ((usqInt)((byteAt(map)))) >> AnnotationShift;
  		assert(((((usqInt)(annotation)) >> AnnotationShift) == HasBytecodePC)
  		 || ((((usqInt)(annotation)) >> AnnotationShift) == IsDisplacementX2N));
  		while (((annotation = ((usqInt)((byteAt(map)))) >> AnnotationShift)) != HasBytecodePC) {
  			map -= 1;
  		}
  
  		/* skip fiducial; i.e. the map entry for the pc immediately following the method header. */
  		map -= 1;
  		aMethodObj = (homeMethod->methodObject);
  		bcpc = startbcpc - (
  #if MULTIPLEBYTECODESETS
  	(headerIndicatesAlternateBytecodeSet((homeMethod->methodHeader))
  		? AltBlockCreationBytecodeSize
  		: BlockCreationBytecodeSize)
  #else /* MULTIPLEBYTECODESETS */
  	BlockCreationBytecodeSize
  #endif /* MULTIPLEBYTECODESETS */
  	);
  		/* begin bytecodeSetOffsetForHeader: */
  		aMethodHeader1 = (homeMethod->methodHeader);
  		bsOffset = 
  #    if MULTIPLEBYTECODESETS
  			(headerIndicatesAlternateBytecodeSet(aMethodHeader1)
  						? 256
  						: 0)
  #    else /* MULTIPLEBYTECODESETS */
  			0
  #    endif /* MULTIPLEBYTECODESETS */
  			;
  		byte = (fetchByteofObject(bcpc, aMethodObj)) + bsOffset;
  		descriptor = generatorAt(byte);
  		endbcpc = (bcpc + ((descriptor->numBytes))) + (((descriptor->isBlockCreation)
  	? (/* begin spanFor:at:exts:in: */
  		((descriptor->spanFunction))(descriptor, bcpc, -1, aMethodObj))
  	: 0));
  		bcpc = startbcpc;
  	}
  	nExts = 0;
  	while ((((usqInt)((byteAt(map)))) >> AnnotationShift) != HasBytecodePC) {
  		map -= 1;
  	}
  	map -= 1;
  	while (((mapByte = byteAt(map))) != MapEnd) {
  
  		/* defensive; we exit on bcpc */
  		if (mapByte >= FirstAnnotation) {
  			annotation = ((usqInt)(mapByte)) >> AnnotationShift;
  			mcpc1 += (mapByte & DisplacementMask) * 4 /* codeGranularity */;
  			if (annotation >= HasBytecodePC) {
  				if ((annotation == IsSendCall)
  				 && ((((usqInt)(((mapByte = byteAt(map - 1))))) >> AnnotationShift) == IsAnnotationExtension)) {
  					annotation += mapByte & DisplacementMask;
  					map -= 1;
  				}
  				while (1) {
  					byte = (fetchByteofObject(bcpc, aMethodObj)) + bsOffset;
  					descriptor = generatorAt(byte);
  					if (isInBlock) {
  						if (bcpc >= endbcpc) {
  							return 0;
  						}
  					}
  					else {
  						if (((descriptor->isReturn))
  						 && (bcpc >= latestContinuation)) {
  							return 0;
  						}
  						if ((isBranch(descriptor))
  						 || ((descriptor->isBlockCreation))) {
  							/* begin latestContinuationPCFor:at:exts:in: */
  							distance = ((descriptor->spanFunction))(descriptor, bcpc, nExts, aMethodObj);
  							targetPC = (bcpc + ((descriptor->numBytes))) + (((distance < 0) ? 0 : distance));
  							latestContinuation = ((latestContinuation < targetPC) ? targetPC : latestContinuation);
  						}
  						/* latestContinuation = */ latestContinuation;
  					}
  					nextBcpc = (bcpc + ((descriptor->numBytes))) + (((descriptor->isBlockCreation)
  	? (/* begin spanFor:at:exts:in: */
  		((descriptor->spanFunction))(descriptor, bcpc, nExts, aMethodObj))
  	: 0));
  					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 *) mcpc1)), ((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 < (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift)))) {
  				mcpc1 += (((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))) * 4 /* codeGranularity */;
  			}
  		}
  		map -= 1;
  	}
  	return 0;
  }
  
  	/* Cogit>>#CallFullRT:registersToBeSavedMask: */
  static AbstractInstruction * NoDbgRegParms
  CallFullRTregistersToBeSavedMask(sqInt callTarget, sqInt registersToBeSaved)
  {
      sqInt callerSavedRegsToBeSaved;
      AbstractInstruction *lastInst;
  
  	callerSavedRegsToBeSaved = CallerSavedRegisterMask & registersToBeSaved;
  	/* begin genPushRegisterMask: */
  	if (callerSavedRegsToBeSaved == 0) {
  		genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	}
  	else {
  		genoperand(PushSTM, callerSavedRegsToBeSaved);
  	}
  	/* begin gen:literal: */
  	lastInst = checkLiteralforInstruction(callTarget, genoperand(CallFull, callTarget));
  	/* begin genPopRegisterMask: */
  	return (callerSavedRegsToBeSaved == 0
  		? genoperandoperand(Label, (labelCounter += 1), bytecodePC)
  		: genoperand(PopLDM, callerSavedRegsToBeSaved));
  }
  
  
  /*	Big assumption here that calls and jumps look the same as regards their
  	displacement. This works on at least x86, ARM and x86_64. */
  
  	/* Cogit>>#CallRT: */
  static AbstractInstruction * NoDbgRegParms
  CallRT(sqInt callTarget)
  {
      AbstractInstruction *abstractInstruction;
  
  	/* begin annotateCall: */
  	abstractInstruction = genoperand(Call, callTarget);
  	(abstractInstruction->annotation = IsRelativeCall);
  	return abstractInstruction;
  }
  
  	/* Cogit>>#Call: */
  static AbstractInstruction * NoDbgRegParms
  gCall(sqInt callTarget)
  {
  	return genoperand(Call, callTarget);
  }
  
  
  /*	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 cacheTag;
      sqInt errorSelectorOrNil;
      sqInt methodOrSelectorIndex;
      sqInt newTargetMethodOrNil;
      sqInt outerReturn;
      sqInt result;
      sqInt selector;
  
  	outerReturn = stackTop();
  	assert(!(((inlineCacheTagAt(backEnd, outerReturn)) == (picAbortDiscriminatorValue()))));
  	if (((cPIC->cPICNumCases)) < MaxCPICCases) {
  		/* begin lookup:for:methodAndErrorSelectorInto: */
  		selector = (cPIC->selector);
  		methodOrSelectorIndex = lookupOrdinaryreceiver(selector, receiver);
  		if ((((usqInt)methodOrSelectorIndex)) > (maxLookupNoMNUErrorCode())) {
  			if (!(isOopCompiledMethod(methodOrSelectorIndex))) {
  				newTargetMethodOrNil = methodOrSelectorIndex;
  				errorSelectorOrNil = SelectorCannotInterpret;
  				goto l1;
  			}
  			if ((!(methodHasCogMethod(methodOrSelectorIndex)))
  			 && (methodShouldBeCogged(methodOrSelectorIndex))) {
  
  				/* We assume cog:selector: will *not* reclaim the method zone */
  				cogselector(methodOrSelectorIndex, selector);
  			}
  			newTargetMethodOrNil = methodOrSelectorIndex;
  			errorSelectorOrNil = null;
  			goto l1;
  		}
  		if (methodOrSelectorIndex == SelectorDoesNotUnderstand) {
  			methodOrSelectorIndex = lookupMNUreceiver(splObj(SelectorDoesNotUnderstand), receiver);
  			if ((((usqInt)methodOrSelectorIndex)) > (maxLookupNoMNUErrorCode())) {
  				assert(isOopCompiledMethod(methodOrSelectorIndex));
  				if ((!(methodHasCogMethod(methodOrSelectorIndex)))
  				 && (methodShouldBeCogged(methodOrSelectorIndex))) {
  
  					/* We assume cog:selector: will *not* reclaim the method zone */
  					cogselector(methodOrSelectorIndex, splObj(SelectorDoesNotUnderstand));
  				}
  				newTargetMethodOrNil = methodOrSelectorIndex;
  				errorSelectorOrNil = SelectorDoesNotUnderstand;
  				goto l1;
  			}
  			newTargetMethodOrNil = null;
  			errorSelectorOrNil = SelectorDoesNotUnderstand;
  			goto l1;
  		}
  		newTargetMethodOrNil = null;
  		errorSelectorOrNil = methodOrSelectorIndex;
  	l1:	/* end lookup:for:methodAndErrorSelectorInto: */;
  	}
  	else {
  		newTargetMethodOrNil = (errorSelectorOrNil = null);
  	}
  	assert(outerReturn == (stackTop()));
  	cacheTag = inlineCacheTagForInstance(receiver);
  	if ((((cPIC->cPICNumCases)) >= MaxCPICCases)
  	 || (((errorSelectorOrNil != null)
  	 && (errorSelectorOrNil != SelectorDoesNotUnderstand))
  	 || ((inlineCacheTagIsYoung(cacheTag))
  	 || ((newTargetMethodOrNil == null)
  	 || (isYoung(newTargetMethodOrNil)))))) {
  		result = patchToOpenPICFornumArgsreceiver((cPIC->selector), (cPIC->cmNumArgs), receiver);
  		assert(!result);
  		return ceSendFromInLineCacheMiss(cPIC);
  	}
  	cogExtendPICCaseNMethodtagisMNUCase(cPIC, newTargetMethodOrNil, cacheTag, errorSelectorOrNil == SelectorDoesNotUnderstand);
  	executeCogPICfromLinkedSendWithReceiverandCacheTag(cPIC, receiver, longAt(pcRelativeAddressAt(backEnd, ((usqInt)(outerReturn - 8)))));
  	return null;
  }
  
  	/* 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;
      sqInt entryPoint;
      sqInt errorSelectorOrNil;
      sqInt extent;
      usqInt innerReturn;
      sqInt methodOrSelectorIndex;
      sqInt newTargetMethodOrNil;
      usqInt outerReturn;
      CogMethod *pic;
      sqInt result;
      sqInt selector;
      CogMethod *targetMethod;
  
  
  	/* Whether we can relink to a PIC or not we need to pop off the inner return and identify the target method. */
  	innerReturn = ((usqInt)(popStack()));
  	targetMethod = ((CogMethod *) (innerReturn - missOffset));
  	outerReturn = ((usqInt)(stackTop()));
  	assert(((outerReturn >= methodZoneBase) && (outerReturn <= (freeStart()))));
  	entryPoint = callTargetFromReturnAddress(backEnd, outerReturn);
  	assert(((targetMethod->selector)) != (nilObject()));
  	assert(((((sqInt)targetMethod)) + cmEntryOffset) == entryPoint);
  	/* begin lookup:for:methodAndErrorSelectorInto: */
  	selector = (targetMethod->selector);
  	methodOrSelectorIndex = lookupOrdinaryreceiver(selector, receiver);
  	if ((((usqInt)methodOrSelectorIndex)) > (maxLookupNoMNUErrorCode())) {
  		if (!(isOopCompiledMethod(methodOrSelectorIndex))) {
  			newTargetMethodOrNil = methodOrSelectorIndex;
  			errorSelectorOrNil = SelectorCannotInterpret;
  			goto l1;
  		}
  		if ((!(methodHasCogMethod(methodOrSelectorIndex)))
  		 && (methodShouldBeCogged(methodOrSelectorIndex))) {
  
  			/* We assume cog:selector: will *not* reclaim the method zone */
  			cogselector(methodOrSelectorIndex, selector);
  		}
  		newTargetMethodOrNil = methodOrSelectorIndex;
  		errorSelectorOrNil = null;
  		goto l1;
  	}
  	if (methodOrSelectorIndex == SelectorDoesNotUnderstand) {
  		methodOrSelectorIndex = lookupMNUreceiver(splObj(SelectorDoesNotUnderstand), receiver);
  		if ((((usqInt)methodOrSelectorIndex)) > (maxLookupNoMNUErrorCode())) {
  			assert(isOopCompiledMethod(methodOrSelectorIndex));
  			if ((!(methodHasCogMethod(methodOrSelectorIndex)))
  			 && (methodShouldBeCogged(methodOrSelectorIndex))) {
  
  				/* We assume cog:selector: will *not* reclaim the method zone */
  				cogselector(methodOrSelectorIndex, splObj(SelectorDoesNotUnderstand));
  			}
  			newTargetMethodOrNil = methodOrSelectorIndex;
  			errorSelectorOrNil = SelectorDoesNotUnderstand;
  			goto l1;
  		}
  		newTargetMethodOrNil = null;
  		errorSelectorOrNil = SelectorDoesNotUnderstand;
  		goto l1;
  	}
  	newTargetMethodOrNil = null;
  	errorSelectorOrNil = methodOrSelectorIndex;
  	l1:	/* end lookup:for:methodAndErrorSelectorInto: */;
  	assert(outerReturn == (stackTop()));
  	cacheTag = inlineCacheTagForInstance(receiver);
  	if (((errorSelectorOrNil != null)
  	 && (errorSelectorOrNil != SelectorDoesNotUnderstand))
  	 || ((inlineCacheTagIsYoung(cacheTag))
  	 || (((longAt(pcRelativeAddressAt(backEnd, ((usqInt)(outerReturn - 8))))) == 0 /* picAbortDiscriminatorValue */)
  	 || ((newTargetMethodOrNil == null)
  	 || (isYoung(newTargetMethodOrNil)))))) {
  		result = patchToOpenPICFornumArgsreceiver((targetMethod->selector), (targetMethod->cmNumArgs), receiver);
  		assert(!result);
  		return ceSendFromInLineCacheMiss(targetMethod);
  	}
  	pic = openPICWithSelector((targetMethod->selector));
  	if ((pic == null)
  	 || (!1)) {
  
  		/* otherwise attempt to create a closed PIC for the two cases. */
  		pic = cogPICSelectornumArgsCase0MethodCase1MethodtagisMNUCase((targetMethod->selector), (targetMethod->cmNumArgs), targetMethod, newTargetMethodOrNil, cacheTag, errorSelectorOrNil == SelectorDoesNotUnderstand);
  		if ((((((sqInt)pic)) >= MaxNegativeErrorCode) && ((((sqInt)pic)) <= -1))) {
  
  			/* For some reason the PIC couldn't be generated, most likely a lack of code memory.
  			   Continue as if this is an unlinked send. */
  			if ((((sqInt)pic)) == InsufficientCodeSpace) {
  				callForCogCompiledCodeCompaction();
  			}
  			return ceSendFromInLineCacheMiss(targetMethod);
  		}
  		flushICacheFromto(backEnd, ((usqInt)pic), (((usqInt)pic)) + closedPICSize);
  	}
  
  	/* This also implicitly flushes the read/write mapped dual zone to the read/execute zone. */
  	extent = (((pic->cmType)) == CMOpenPIC
  		? rewriteInlineCacheAttagtarget(backEnd, outerReturn, inlineCacheValueForSelectorin(backEnd, (targetMethod->selector), mframeHomeMethodExport()), (((sqInt)pic)) + cmEntryOffset)
  		: rewriteCallAttarget(backEnd, outerReturn, (((sqInt)pic)) + cmEntryOffset));
  	flushICacheFromto(backEnd, (((usqInt)outerReturn)) - extent, ((usqInt)outerReturn));
  	executeCogPICfromLinkedSendWithReceiverandCacheTag(pic, receiver, longAt(pcRelativeAddressAt(backEnd, ((usqInt)(outerReturn - 8)))));
  	return null;
  }
  
  	/* Cogit>>#checkAssertsEnabledInCogit */
  void
  checkAssertsEnabledInCogit(void)
  {
      sqInt assertsAreEnabledInCogit;
  
  	assertsAreEnabledInCogit = 0;
  	assert(assertsAreEnabledInCogit);
  }
  
  
  /*	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)
  {
      sqInt cacheTag1;
      sqInt entryPoint;
      sqInt entryPoint1;
      sqInt literal;
      sqInt offset1;
      sqInt *sendTable1;
      sqInt tagCouldBeObj;
      CogMethod *targetMethod1;
  
  	if (annotation == IsObjectReference) {
  		literal = longAt(((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: */
  		cacheTag1 = longAt(pcRelativeAddressAt(backEnd, ((usqInt)((((sqInt)mcpc)) - 8))));
  
  		/* in-line cache tags are the selectors of sends if sends are unlinked,
  		   the selectors of super sends (entry offset = cmNoCheckEntryOffset),
  		   the selectors of open PIC sends (entry offset = cmEntryOffset, target is an Open PIC)
  		   or in-line cache tags (classes, class indices, immediate bit patterns, etc).
  		   Note that selectors can be immediate so there is no guarantee that they
  		   are markable/remappable objects. */
  		entryPoint1 = callTargetFromReturnAddress(backEnd, ((sqInt)mcpc));
  		tagCouldBeObj = 1;
  		entryPoint = entryPoint1;
  		if (tagCouldBeObj) {
  			if (couldBeObject(cacheTag1)) {
  				if (!(asserta(checkValidOopReference(cacheTag1)))) {
  					return 4;
  				}
  			}
  			else {
  				if (!(asserta(validInlineCacheTag(cacheTag1)))) {
  					return 5;
  				}
  			}
  			if ((couldBeObject(cacheTag1))
  			 && (isReallyYoungObject(cacheTag1))) {
  				if (!(asserta(((((CogMethod *) cogMethod))->cmRefersToYoung)))) {
  					return 6;
  				}
  			}
  		}
  		else {
  			if (!(asserta(validInlineCacheTag(cacheTag1)))) {
  				return 9;
  			}
  		}
  		if (entryPoint > methodZoneBase) {
  
  			/* It's a linked send; find which kind. */
  			/* begin targetMethodAndSendTableFor:annotation:into: */
  			if (annotation == IsSendCall) {
  				offset1 = cmEntryOffset;
  				sendTable1 = ordinarySendTrampolines;
  			}
  			else {
  				assert(annotation == IsSuperSend);
  				offset1 = cmNoCheckEntryOffset;
  				sendTable1 = superSendTrampolines;
  			}
  			targetMethod1 = ((CogMethod *) (entryPoint - offset1));
  			if (!(asserta((((targetMethod1->cmType)) == CMMethod)
  				 || ((((targetMethod1->cmType)) == CMClosedPIC)
  				 || (((targetMethod1->cmType)) == CMOpenPIC))))) {
  				return 10;
  			}
  		}
  	}
  	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 offset1;
      sqInt selectorOrCacheTag;
      sqInt *sendTable;
  
  	if (annotation == IsObjectReference) {
  		literal = longAt(((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) {
  				offset1 = cmEntryOffset;
  				sendTable = ordinarySendTrampolines;
  			}
  			else {
  				assert(annotation == IsSuperSend);
  				offset1 = cmNoCheckEntryOffset;
  				sendTable = superSendTrampolines;
  			}
  			offset = offset1;
  		}
  		selectorOrCacheTag = longAt(pcRelativeAddressAt(backEnd, ((usqInt)((((sqInt)mcpc)) - 8))));
  		if ((entryPoint > methodZoneBase)
  		 && ((offset != cmNoCheckEntryOffset)
  		 && ((((((CogMethod *) (entryPoint - offset)))->cmType)) != CMOpenPIC))) {
  
  			/* linked non-super send, cacheTag is a cacheTag */
  			if (!(validInlineCacheTag(selectorOrCacheTag))) {
  				print("cache tag leak in CM ");
  				printHex(((sqInt)cogMethod));
  				print(" @ ");
  				printHex(((sqInt)mcpc));
  				cr();
  				return 1;
  			}
  		}
  		else {
  
  			/* unlinked send or super send; cacheTag is a selector unless 64-bit, in which case it is an index. */
  			if (!(checkValidOopReference(selectorOrCacheTag))) {
  				print("selector leak in CM ");
  				printHex(((sqInt)cogMethod));
  				print(" @ ");
  				printHex(((sqInt)mcpc));
  				cr();
  				return 1;
  			}
  		}
  	}
  	return 0;
  }
  
  
  /*	Answer if all references to objects in machine-code are valid. */
  
  	/* Cogit>>#checkIntegrityOfObjectReferencesInCode: */
  sqInt
  checkIntegrityOfObjectReferencesInCode(sqInt gcModes)
  {
      CogMethod *cogMethod;
      sqInt count;
      sqInt 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 (gcModes & GCModeNewSpace) {
  					if (((isYoungObject((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)) == CMClosedPIC) {
  					if (!(checkValidObjectReferencesInClosedPIC(cogMethod))) {
  						ok = 0;
  					}
  				}
  				else {
  					if (((cogMethod->cmType)) == CMOpenPIC) {
  						if ((mapForperformUntilarg(cogMethod, checkIfValidOopRefpccogMethod, ((sqInt)cogMethod))) != 0) {
  							ok = 0;
  						}
  					}
  				}
  			}
  		}
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((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;
      sqInt ok;
      sqInt pc;
  
  	ok = 1;
  
  	/* first we check the obj ref at the beginning of the CPIC */
  	pc = (((sqInt)cPIC)) + firstCPICCaseOffset;
  	if (!(checkMaybeObjRefInClosedPIC(literalBeforeFollowingAddress(backEnd, pc - 4 /* jumpLongByteSize */)))) {
  		print("object leak in CPIC ");
  		printHex(((sqInt)cPIC));
  		print(" @ ");
  		printHex(pc - 4 /* jumpLongByteSize */);
  		cr();
  		ok = 0;
  	}
  
  	/* For each case we check any object reference at the end address - sizeof(conditional instruction) and then increment the end address by case size */
  	pc = addressOfEndOfCaseinCPIC((cPIC->cPICNumCases), cPIC);
  	for (i = 2; i <= ((cPIC->cPICNumCases)); i += 1) {
  		if (!(checkMaybeObjRefInClosedPIC(literal32BeforeFollowingAddress(backEnd, pc - (jumpLongConditionalByteSize(backEnd)))))) {
  			print("object leak in CPIC ");
  			printHex(((sqInt)cPIC));
  			print(" @ ");
  			printHex((pc - (jumpLongConditionalByteSize(backEnd))) - 4 /* loadLiteralByteSize */);
  			cr();
  			ok = 0;
  		}
  		if (!(checkMaybeObjRefInClosedPIC(literalBeforeFollowingAddress(backEnd, (pc - (jumpLongConditionalByteSize(backEnd))) - 8 /* cmpC32RTempByteSize */)))) {
  			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)) == CMClosedPIC) {
  			(cogMethod->methodObject = 0);
  		}
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((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)))
  		 || (isMarked((cPIC->selector))))) {
  		return 1;
  	}
  	pc = addressOfEndOfCaseinCPIC(1, cPIC);
  	if (couldBeObject((object = literalBeforeFollowingAddress(backEnd, pc - 4 /* jumpLongByteSize */)))) {
  		if (!(isMarked(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 = literal32BeforeFollowingAddress(backEnd, pc - (jumpLongConditionalByteSize(backEnd)))))) {
  			if (!(isMarked(object))) {
  				return 1;
  			}
  		}
  		if (couldBeObject((object = literalBeforeFollowingAddress(backEnd, (pc - (jumpLongConditionalByteSize(backEnd))) - 8 /* cmpC32RTempByteSize */)))) {
  			if (!(isMarked(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;
  
  
  	/* + 3 for start, freeStart and end */
  	count = (trampolineTableIndex / 2) + 3;
  	cogMethod = ((CogMethod *) methodZoneBase);
  	while (cogMethod < (limitZony())) {
  		if (((cogMethod->cmType)) != CMFree) {
  			count += 1;
  		}
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  	constituents = instantiateClassindexableSize(classArray(), count * 2);
  	if (!(constituents)) {
  		return constituents;
  	}
  	pushRemappableOop(constituents);
  	if ((((label = stringForCString("CogCode"))) == null)
  	 || (((value = positive32BitIntegerFor(codeBase))) == null)) {
  		popRemappableOop();
  		return null;
  	}
  	storePointerUncheckedofObjectwithValue(0, topRemappableOop(), label);
  	storePointerUncheckedofObjectwithValue(1, topRemappableOop(), value);
  	for (i = 0; i < trampolineTableIndex; i += 2) {
  		if ((((label = stringForCString(trampolineAddresses[i]))) == null)
  		 || (((value = positive32BitIntegerFor(((usqInt)(trampolineAddresses[i + 1]))))) == null)) {
  			popRemappableOop();
  			return null;
  		}
  		storePointerUncheckedofObjectwithValue(2 + i, topRemappableOop(), label);
  		storePointerUncheckedofObjectwithValue(3 + i, topRemappableOop(), value);
  	}
  	count = trampolineTableIndex + 2;
  	cogMethod = ((CogMethod *) methodZoneBase);
  	while (cogMethod < (limitZony())) {
  		if (((cogMethod->cmType)) != CMFree) {
  			profileData = (((cogMethod->cmType)) == CMMethod
  				? (cogMethod->methodObject)
  				: (withDetails
  					 && (((cogMethod->cmType)) == CMClosedPIC)
  						? createCPICData(cogMethod)
  						: (cogMethod->selector)));
  			if (!(profileData)) {
  				return cleanUpFailingCogCodeConstituents(cogMethod);
  			}
  			storePointerUncheckedofObjectwithValue(count, topRemappableOop(), profileData);
  			if (withDetails) {
  				value = collectCogMethodConstituent(cogMethod);
  			}
  			else {
  				value = positive32BitIntegerFor(((usqInt)cogMethod));
  			}
  			if (!(value)) {
  				return cleanUpFailingCogCodeConstituents(cogMethod);
  			}
  			storePointerUncheckedofObjectwithValue(count + 1, topRemappableOop(), value);
  			count += 2;
  		}
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  	if ((((label = stringForCString("CCFree"))) == null)
  	 || (((value = positive32BitIntegerFor(mzFreeStart))) == null)) {
  		popRemappableOop();
  		return null;
  	}
  	storePointerUncheckedofObjectwithValue(count, topRemappableOop(), label);
  	storePointerUncheckedofObjectwithValue(count + 1, topRemappableOop(), value);
  	if ((((label = stringForCString("CCEnd"))) == null)
  	 || (((value = positive32BitIntegerFor(limitAddress))) == null)) {
  		popRemappableOop();
  		return null;
  	}
  	storePointerUncheckedofObjectwithValue(count + 2, topRemappableOop(), label);
  	storePointerUncheckedofObjectwithValue(count + 3, topRemappableOop(), 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 void NoDbgRegParms
  cogExtendPICCaseNMethodtagisMNUCase(CogMethod *cPIC, sqInt caseNMethod, sqInt caseNTag, sqInt isMNUCase)
  {
      sqInt address;
      usqInt addressFollowingJump;
      sqInt endAddress;
      sqInt operand;
      CogBlockMethod * self_in_cpicHasMNUCase;
      sqInt startAddress;
      sqInt target;
  
  	compilationBreakpointclassTagisMNUCase((cPIC->selector), caseNTag, isMNUCase);
  	assert(!(inlineCacheTagIsYoung(caseNTag)));
  	assert((caseNMethod != null)
  	 && (!(isYoung(caseNMethod))));
  	if ((!isMNUCase)
  	 && (methodHasCogMethod(caseNMethod))) {
  
  		/* this isn't an MNU and we have an already cogged method to jump to */
  		operand = 0;
  		target = (((sqInt)(cogMethodOf(caseNMethod)))) + cmNoCheckEntryOffset;
  	}
  	else {
  		operand = caseNMethod;
  		if (isMNUCase) {
  
  			/* this is an MNU so tag the CPIC header and setup a jump to the MNUAbort */
  			/* begin cpicHasMNUCase: */
  			self_in_cpicHasMNUCase = ((CogBlockMethod *) (((CogMethod *) ((((usqInt)cPIC)) + codeToDataDelta))));
  			(self_in_cpicHasMNUCase->cpicHasMNUCaseOrCMIsFullBlock) = 1;
  			target = (((sqInt)cPIC)) + (sizeof(CogMethod));
  		}
  		else {
  
  			/* setup a jump to the interpretAborth so we can cog the target method */
  			target = (((sqInt)cPIC)) + (picInterpretAbortOffset());
  		}
  	}
  	address = addressOfEndOfCaseinCPIC(((cPIC->cPICNumCases)) + 1, cPIC);
  	rewriteCPICCaseAttagobjReftarget(address, caseNTag, operand, target);
  	/* begin rewriteCPIC:caseJumpTo: */
  	addressFollowingJump = (((((sqInt)cPIC)) + firstCPICCaseOffset) - 4 /* jumpLongByteSize */) - 4 /* loadLiteralByteSize */;
  	rewriteTransferAttarget(((AbstractInstruction *) backEnd), addressFollowingJump, address - cPICCaseSize);
  	flushICacheFromto(backEnd, ((usqInt)cPIC), (((usqInt)cPIC)) + closedPICSize);
  	((((CogMethod *) ((((usqInt)cPIC)) + codeToDataDelta)))->cPICNumCases = ((cPIC->cPICNumCases)) + 1);
  	/* begin assertValidDualZoneFrom:to: */
  	startAddress = ((usqInt)cPIC);
  	endAddress = (((usqInt)cPIC)) + closedPICSize;
  	
  #  if DUAL_MAPPED_CODE_ZONE
  	assertCoherentCodeAtdelta(backEnd, startAddress + cmNoCheckEntryOffset, codeToDataDelta);
  #  endif /* DUAL_MAPPED_CODE_ZONE */
  }
  
  	/* Cogit>>#cogitPostGCAction: */
  void
  cogitPostGCAction(sqInt gcMode)
  {
  	if ((gcMode == GCModeFull)
  	 && (1)) {
  		voidYoungReferrersPostTenureAll();
  	}
  	
  #  if SPURVM
  	if (gcMode == GCModeBecome) {
  		followForwardedLiteralsInOpenPICList();
  	}
  #  endif /* SPURVM */
  	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)) & 1))) {
  			return 11;
  		}
  		if (!(couldBeObject((cogMethod->methodObject)))) {
  			return 12;
  		}
  		if ((((cogMethod->stackCheckOffset)) > 0)
  		 && (((cogMethod->stackCheckOffset)) < cmNoCheckEntryOffset)) {
  			return 13;
  		}
  		return 0;
  	}
  	if (((cogMethod->cmType)) == CMOpenPIC) {
  		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(((void *)((cogMethod->methodObject))))))))))) {
  				return 23;
  			}
  		}
  		if (((cogMethod->stackCheckOffset)) != 0) {
  			return 24;
  		}
  		return 0;
  	}
  	if (((cogMethod->cmType)) == CMClosedPIC) {
  		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;
  }
  
  
  /*	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 * actualPIC;
      sqInt endAddress;
      usqInt startAddress;
      CogMethod * writablePIC;
  
  	if ((isYoung(selector))
  	 || ((inlineCacheTagForInstance(rcvr)) == 0 /* picAbortDiscriminatorValue */)) {
  		return 0;
  	}
  	compilationBreakpointclassTagisMNUCase(selector, fetchClassTagOf(rcvr), 1);
  	assert(endCPICCase0 != null);
  	startAddress = allocate(closedPICSize);
  	if (startAddress == 0) {
  		callForCogCompiledCodeCompaction();
  		return 0;
  	}
  	maybeBreakGeneratingFromto(startAddress, (startAddress + closedPICSize) - 1);
  
  	/* memcpy the prototype across to our allocated space; because anything else would be silly */
  	writablePIC = ((CogMethod *) ((((usqInt)startAddress)) + codeToDataDelta));
  	codeMemcpy(writablePIC, cPICPrototype, closedPICSize);
  	/* begin fillInCPICHeader:numArgs:numCases:hasMNUCase:selector: */
  	assert(!(isYoung(selector)));
  	(writablePIC->cmType = CMClosedPIC);
  	(writablePIC->objectHeader = 0);
  	(writablePIC->blockSize = closedPICSize);
  	(writablePIC->methodObject = 0);
  	(writablePIC->methodHeader = 0);
  	(writablePIC->selector = selector);
  	(writablePIC->cmNumArgs = numArgs);
  	(writablePIC->cmHasMovableLiteral = 0);
  	(writablePIC->cmRefersToYoung = 0);
  	(writablePIC->cmUsageCount = initialClosedPICUsageCount());
  	/* begin cpicHasMNUCase: */
  	((((CogBlockMethod *) writablePIC))->cpicHasMNUCaseOrCMIsFullBlock) = 1;
  	(writablePIC->cPICNumCases = 1);
  	(writablePIC->blockEntryOffset = 0);
  	assert(((writablePIC->cmType)) == CMClosedPIC);
  	assert(((writablePIC->selector)) == selector);
  	assert(((writablePIC->cmNumArgs)) == numArgs);
  	assert(((writablePIC->cPICNumCases)) == 1);
  	assert(closedPICSize == (roundUpLength(closedPICSize)));
  	/* begin maybeEnableSingleStep */
  	configureMNUCPICmethodOperandnumArgsdelta((actualPIC = ((CogMethod *) startAddress)), methodOperand, numArgs, startAddress - (((usqInt)cPICPrototype)));
  	flushICacheFromto(backEnd, startAddress, startAddress + closedPICSize);
  	assert((callTargetFromReturnAddress(backEnd, startAddress + missOffset)) == (picAbortTrampolineFor(numArgs)));
  	/* begin assertValidDualZoneFrom:to: */
  	endAddress = startAddress + closedPICSize;
  	
  #  if DUAL_MAPPED_CODE_ZONE
  	assertCoherentCodeAtdelta(backEnd, startAddress + cmNoCheckEntryOffset, codeToDataDelta);
  #  endif /* DUAL_MAPPED_CODE_ZONE */
  	return actualPIC;
  }
  
  
  /*	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 endAddress;
      sqInt fixupSize;
      sqInt mapSize;
      sqInt opcodeSize;
      CogMethod *pic;
      usqInt startAddress;
  
  	compilationBreakpointisMNUCase(selector, 0);
  	startAddress = allocate(openPICSize);
  	if (startAddress == 0) {
  		return ((CogMethod *) InsufficientCodeSpace);
  	}
  	(methodLabel->address = startAddress);
  	(methodLabel->dependent = null);
  	/* begin allocateOpcodes:bytecodes: */
  	numAbstractOpcodes = 100;
  	opcodeSize = (sizeof(CogAbstractInstruction)) * numAbstractOpcodes;
  	fixupSize = (sizeof(CogBytecodeFixup)) * numAbstractOpcodes;
  	abstractOpcodes = alloca(opcodeSize + fixupSize);
  	bzero(abstractOpcodes, opcodeSize + fixupSize);
  	fixups = ((void *)((((usqInt)abstractOpcodes)) + opcodeSize));
  	zeroOpcodeIndexForNewOpcodes();
  	labelCounter = 0;
  	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: */
  	pic = ((CogMethod *) ((((usqInt)startAddress)) + codeToDataDelta));
  	(pic->cmType = CMOpenPIC);
  	(pic->objectHeader = 0);
  	(pic->blockSize = openPICSize);
  	addToOpenPICList(pic);
  	(pic->methodHeader = 0);
  	(pic->selector = selector);
  	(pic->cmNumArgs = numArgs);
  	(pic->cmHasMovableLiteral = isNonImmediate(selector));
  	if ((pic->cmRefersToYoung = isYoung(selector))) {
  		addToYoungReferrers(pic);
  	}
  	(pic->cmUsageCount = initialOpenPICUsageCount());
  	/* begin cpicHasMNUCase: */
  	((((CogBlockMethod *) pic))->cpicHasMNUCaseOrCMIsFullBlock) = 0;
  	(pic->cPICNumCases = 0);
  	(pic->blockEntryOffset = 0);
  	flushICacheFromto(backEnd, (((usqInt)pic)) - codeToDataDelta, ((((usqInt)pic)) - codeToDataDelta) + openPICSize);
  	assert(((pic->cmType)) == CMOpenPIC);
  	assert(((pic->selector)) == selector);
  	assert(((pic->cmNumArgs)) == numArgs);
  	assert((callTargetFromReturnAddress(backEnd, ((((sqInt)pic)) - codeToDataDelta) + missOffset)) == (picAbortTrampolineFor(numArgs)));
  	assert(openPICSize == (roundUpLength(openPICSize)));
  	/* begin assertValidDualZoneFrom:to: */
  	endAddress = ((((usqInt)pic)) - codeToDataDelta) + openPICSize;
  	
  #  if DUAL_MAPPED_CODE_ZONE
  	assertCoherentCodeAtdelta(backEnd, ((((usqInt)pic)) - codeToDataDelta) + cmNoCheckEntryOffset, codeToDataDelta);
  #  endif /* DUAL_MAPPED_CODE_ZONE */
  	/* begin maybeEnableSingleStep */
  	return ((CogMethod *) startAddress);
  }
  
  
  /*	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 * actualPIC;
      sqInt endAddress;
      usqInt startAddress;
      CogMethod * writablePIC;
  
  	if (isYoung(selector)) {
  		return ((CogMethod *) YoungSelectorInPIC);
  	}
  	compilationBreakpointclassTagisMNUCase(selector, case1Tag, isMNUCase);
  	startAddress = allocate(closedPICSize);
  	if (startAddress == 0) {
  		return ((CogMethod *) InsufficientCodeSpace);
  	}
  	maybeBreakGeneratingFromto(startAddress, (startAddress + closedPICSize) - 1);
  
  	/* memcpy the prototype across to our allocated space; because anything else would be silly */
  	writablePIC = ((CogMethod *) ((((usqInt)startAddress)) + codeToDataDelta));
  	codeMemcpy(writablePIC, cPICPrototype, closedPICSize);
  	/* begin fillInCPICHeader:numArgs:numCases:hasMNUCase:selector: */
  	assert(!(isYoung(selector)));
  	(writablePIC->cmType = CMClosedPIC);
  	(writablePIC->objectHeader = 0);
  	(writablePIC->blockSize = closedPICSize);
  	(writablePIC->methodObject = 0);
  	(writablePIC->methodHeader = 0);
  	(writablePIC->selector = selector);
  	(writablePIC->cmNumArgs = numArgs);
  	(writablePIC->cmHasMovableLiteral = 0);
  	(writablePIC->cmRefersToYoung = 0);
  	(writablePIC->cmUsageCount = initialClosedPICUsageCount());
  	/* begin cpicHasMNUCase: */
  	((((CogBlockMethod *) writablePIC))->cpicHasMNUCaseOrCMIsFullBlock) = isMNUCase;
  	(writablePIC->cPICNumCases = 2);
  	(writablePIC->blockEntryOffset = 0);
  	assert(((writablePIC->cmType)) == CMClosedPIC);
  	assert(((writablePIC->selector)) == selector);
  	assert(((writablePIC->cmNumArgs)) == numArgs);
  	assert(((writablePIC->cPICNumCases)) == 2);
  	assert(closedPICSize == (roundUpLength(closedPICSize)));
  	/* begin maybeEnableSingleStep */
  	configureCPICCase0Case1MethodtagisMNUCasenumArgsdelta((actualPIC = ((CogMethod *) startAddress)), case0CogMethod, case1MethodOrNil, case1Tag, isMNUCase, numArgs, startAddress - (((usqInt)cPICPrototype)));
  	flushICacheFromto(backEnd, startAddress, startAddress + closedPICSize);
  	assert((callTargetFromReturnAddress(backEnd, startAddress + missOffset)) == (picAbortTrampolineFor(numArgs)));
  	/* begin assertValidDualZoneFrom:to: */
  	endAddress = startAddress + closedPICSize;
  	
  #  if DUAL_MAPPED_CODE_ZONE
  	assertCoherentCodeAtdelta(backEnd, startAddress + cmNoCheckEntryOffset, codeToDataDelta);
  #  endif /* DUAL_MAPPED_CODE_ZONE */
  	return actualPIC;
  }
  
  
  /*	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;
  
  
  	/* inline exclude:selector: */
  	assert(!((methodHasCogMethod(aMethodObj))));
  	assert(!((isOopCompiledMethod(ultimateLiteralOf(aMethodObj)))));
  
  	/* coInterpreter stringOf: selector */
  	selector = (aSelectorOop == (nilObject())
  		? maybeSelectorOfMethod(aMethodObj)
  		: aSelectorOop);
  	if (!(selector == null)) {
  		compilationBreakpointisMNUCase(selector, 0);
  	}
  	if (aMethodObj == breakMethod) {
  		haltmsg("Compilation of breakMethod");
  	}
  	if (methodUsesAlternateBytecodeSet(aMethodObj)) {
  		if ((numElementsIn(generatorTable)) <= 256) {
  			return null;
  		}
  		bytecodeSetOffset = 256;
  	}
  	else {
  		bytecodeSetOffset = 0;
  	}
  	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;
  	}
  	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 offset1;
      sqInt *sendTable1;
      CogMethod *targetMethod1;
  
  	if (!(descriptor)) {
  		return 0;
  	}
  	if (!((descriptor->isMapped))) {
  		return 0;
  	}
  	address = positive32BitIntegerFor(((usqInt)mcpc));
  	if (!(address)) {
  		return PrimErrNoMemory;
  	}
  	storePointerUncheckedofObjectwithValue(cogConstituentIndex, topRemappableOop(), address);
  	storePointerUncheckedofObjectwithValue(cogConstituentIndex + 1, topRemappableOop(), (((usqInt)bcpc << 1) | 1));
  
  	/* Collect any first case classTags for closed PICs. */
  	cogConstituentIndex += 2;
  	if (((isBackwardBranchAndAnnotation & 1) == 0)
  	 && (((((usqInt)(isBackwardBranchAndAnnotation)) >> 1) >= IsSendCall)
  	 || (0))) {
  		entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt)mcpc));
  		if (entryPoint > methodZoneBase) {
  
  			/* send is linked */
  			/* begin targetMethodAndSendTableFor:annotation:into: */
  			annotation = ((usqInt)(isBackwardBranchAndAnnotation)) >> 1;
  			/* begin offsetAndSendTableFor:annotation:into: */
  			if (annotation == IsSendCall) {
  				offset1 = cmEntryOffset;
  				sendTable1 = ordinarySendTrampolines;
  			}
  			else {
  				assert(annotation == IsSuperSend);
  				offset1 = cmNoCheckEntryOffset;
  				sendTable1 = superSendTrampolines;
  			}
  			targetMethod1 = ((CogMethod *) (entryPoint - offset1));
  			if (((targetMethod1->cmType)) == CMClosedPIC) {
  				(targetMethod1->methodObject = classForInlineCacheTag(longAt(pcRelativeAddressAt(backEnd, ((usqInt)(mcpc - 8))))));
  			}
  		}
  	}
  	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 aMethodHeader;
      sqInt aMethodHeader1;
      sqInt aMethodObj;
      sqInt annotation;
      sqInt bcpc;
      sqInt bsOffset;
      sqInt byte;
      sqInt cm;
      CogBlockMethod *cogBlockMethod;
      sqInt data;
      BytecodeDescriptor *descriptor;
      sqInt distance;
      sqInt endbcpc;
      sqInt errCode;
      CogMethod *homeMethod;
      sqInt isBackwardBranch;
      sqInt isInBlock;
      sqInt latestContinuation;
      usqInt map;
      sqInt mapByte;
      usqInt mcpc;
      sqInt nExts;
      sqInt nextBcpc;
      sqInt nSlots;
      sqInt result;
      sqInt startbcpc;
      sqInt targetPC;
  
  	latestContinuation = 0;
  	if (!(((cogMethod->cmType)) == CMMethod)) {
  		return positive32BitIntegerFor(((usqInt)cogMethod));
  	}
  	cogBlockMethod = ((CogBlockMethod *) cogMethod);
  	if (((cogBlockMethod->stackCheckOffset)) == 0) {
  
  		/* isFrameless ? */
  		return positive32BitIntegerFor(((usqInt)cogMethod));
  	}
  	cm = (cogMethod->methodObject);
  
  	/* +1 for first address */
  	nSlots = ((((byteSizeOf(cm)) - (startPCOfMethod(cm))) * 2) + (minSlotsForShortening())) + 1;
  	data = instantiateClassindexableSize(splObj(ClassArray), nSlots);
  	if (!(data)) {
  		return null;
  	}
  	pushRemappableOop(data);
  	address = positive32BitIntegerFor(((usqInt)cogMethod));
  	if (!(address)) {
  		popRemappableOop();
  		return null;
  	}
  	storePointerUncheckedofObjectwithValue(0, topRemappableOop(), address);
  	cogConstituentIndex = 1;
  	/* begin mapFor:bcpc:performUntil:arg: */
  	startbcpc = startPCOfMethod((cogMethod->methodObject));
  	assert(((cogBlockMethod->stackCheckOffset)) > 0);
  
  	/* The stack check maps to the start of the first bytecode,
  	   the first bytecode being effectively after frame build. */
  	mcpc = (((usqInt)cogBlockMethod)) + ((cogBlockMethod->stackCheckOffset));
  	result = collectCogConstituentForAnnotationMcpcBcpcMethod(null, (0 + (((int)((usqInt)(HasBytecodePC) << 1)))), (((char *) mcpc)), startbcpc, (((void *)cogMethod)));
  	if (result != 0) {
  		errCode = result;
  		goto l7;
  	}
  
  	/* In both CMMethod and CMBlock cases find the start of the map and
  	   skip forward to the bytecode pc map entry for the stack check. */
  	bcpc = startbcpc;
  	if (((cogBlockMethod->cmType)) == CMMethod) {
  		/* begin cmIsFullBlock */
  		isInBlock = 0;
  		homeMethod = ((CogMethod *) cogBlockMethod);
  		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;
  		/* begin bytecodeSetOffsetForHeader: */
  		aMethodHeader = (homeMethod->methodHeader);
  		bsOffset = 
  #    if MULTIPLEBYTECODESETS
  			(headerIndicatesAlternateBytecodeSet(aMethodHeader)
  						? 256
  						: 0)
  #    else /* MULTIPLEBYTECODESETS */
  			0
  #    endif /* MULTIPLEBYTECODESETS */
  			;
  		bcpc += deltaToSkipPrimAndErrorStoreInheader(aMethodObj, (homeMethod->methodHeader));
  	}
  	else {
  		isInBlock = 1;
  		assert(bcpc == ((cogBlockMethod->startpc)));
  		homeMethod = cmHomeMethod(cogBlockMethod);
  		map = findMapLocationForMcpcinMethod((((usqInt)cogBlockMethod)) + (sizeof(CogBlockMethod)), homeMethod);
  		assert(map != 0);
  		annotation = ((usqInt)((byteAt(map)))) >> AnnotationShift;
  		assert(((((usqInt)(annotation)) >> AnnotationShift) == HasBytecodePC)
  		 || ((((usqInt)(annotation)) >> AnnotationShift) == IsDisplacementX2N));
  		while (((annotation = ((usqInt)((byteAt(map)))) >> AnnotationShift)) != HasBytecodePC) {
  			map -= 1;
  		}
  
  		/* skip fiducial; i.e. the map entry for the pc immediately following the method header. */
  		map -= 1;
  		aMethodObj = (homeMethod->methodObject);
  		bcpc = startbcpc - (
  #if MULTIPLEBYTECODESETS
  	(headerIndicatesAlternateBytecodeSet((homeMethod->methodHeader))
  		? AltBlockCreationBytecodeSize
  		: BlockCreationBytecodeSize)
  #else /* MULTIPLEBYTECODESETS */
  	BlockCreationBytecodeSize
  #endif /* MULTIPLEBYTECODESETS */
  	);
  		/* begin bytecodeSetOffsetForHeader: */
  		aMethodHeader1 = (homeMethod->methodHeader);
  		bsOffset = 
  #    if MULTIPLEBYTECODESETS
  			(headerIndicatesAlternateBytecodeSet(aMethodHeader1)
  						? 256
  						: 0)
  #    else /* MULTIPLEBYTECODESETS */
  			0
  #    endif /* MULTIPLEBYTECODESETS */
  			;
  		byte = (fetchByteofObject(bcpc, aMethodObj)) + bsOffset;
  		descriptor = generatorAt(byte);
  		endbcpc = (bcpc + ((descriptor->numBytes))) + (((descriptor->isBlockCreation)
  	? (/* begin spanFor:at:exts:in: */
  		((descriptor->spanFunction))(descriptor, bcpc, -1, aMethodObj))
  	: 0));
  		bcpc = startbcpc;
  	}
  	nExts = 0;
  	while ((((usqInt)((byteAt(map)))) >> AnnotationShift) != HasBytecodePC) {
  		map -= 1;
  	}
  	map -= 1;
  	while (((mapByte = byteAt(map))) != MapEnd) {
  
  		/* defensive; we exit on bcpc */
  		if (mapByte >= FirstAnnotation) {
  			annotation = ((usqInt)(mapByte)) >> AnnotationShift;
  			mcpc += (mapByte & DisplacementMask) * 4 /* codeGranularity */;
  			if (annotation >= HasBytecodePC) {
  				if ((annotation == IsSendCall)
  				 && ((((usqInt)(((mapByte = byteAt(map - 1))))) >> AnnotationShift) == IsAnnotationExtension)) {
  					annotation += mapByte & DisplacementMask;
  					map -= 1;
  				}
  				while (1) {
  					byte = (fetchByteofObject(bcpc, aMethodObj)) + bsOffset;
  					descriptor = generatorAt(byte);
  					if (isInBlock) {
  						if (bcpc >= endbcpc) {
  							errCode = 0;
  							goto l7;
  						}
  					}
  					else {
  						if (((descriptor->isReturn))
  						 && (bcpc >= latestContinuation)) {
  							errCode = 0;
  							goto l7;
  						}
  						if ((isBranch(descriptor))
  						 || ((descriptor->isBlockCreation))) {
  							/* begin latestContinuationPCFor:at:exts:in: */
  							distance = ((descriptor->spanFunction))(descriptor, bcpc, nExts, aMethodObj);
  							targetPC = (bcpc + ((descriptor->numBytes))) + (((distance < 0) ? 0 : distance));
  							latestContinuation = ((latestContinuation < targetPC) ? targetPC : latestContinuation);
  						}
  						/* latestContinuation = */ latestContinuation;
  					}
  					nextBcpc = (bcpc + ((descriptor->numBytes))) + (((descriptor->isBlockCreation)
  	? (/* begin spanFor:at:exts:in: */
  		((descriptor->spanFunction))(descriptor, bcpc, nExts, aMethodObj))
  	: 0));
  					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 l7;
  				}
  				bcpc = nextBcpc;
  				nExts = ((descriptor->isExtension)
  					? nExts + 1
  					: 0);
  			}
  		}
  		else {
  			assert(((((usqInt)(mapByte)) >> AnnotationShift) == IsDisplacementX2N)
  			 || ((((usqInt)(mapByte)) >> AnnotationShift) == IsAnnotationExtension));
  			if (mapByte < (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift)))) {
  				mcpc += (((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))) * 4 /* codeGranularity */;
  			}
  		}
  		map -= 1;
  	}
  	errCode = 0;
  	l7:	/* end mapFor:bcpc:performUntil:arg: */;
  	if (errCode != 0) {
  		popRemappableOop();
  		return null;
  	}
  	if (cogConstituentIndex < nSlots) {
  		shortentoIndexableSize(topRemappableOop(), cogConstituentIndex);
  	}
  	return popRemappableOop();
  }
  
  	/* Cogit>>#compactCogCompiledCode */
  void
  compactCogCompiledCode(void)
  {
  	assertValidDualZone();
  	assert(noCogMethodsMaximallyMarked());
  	markActiveMethodsAndReferents();
  	freeOlderMethodsForCompaction();
  	compactPICsWithFreedTargets();
  	planCompaction();
  	updateStackZoneReferencesToCompiledCodePreCompaction();
  	relocateMethodsPreCompaction();
  	assertValidDualZone();
  	compactCompiledCode();
  	stopsFromto(backEnd, freeStart(), (youngReferrers()) - 1);
  	flushICacheFromto(backEnd, ((usqInt)methodZoneBase), ((usqInt)(youngReferrers())));
  	assert(allMethodsHaveCorrectHeader());
  	assert(kosherYoungReferrers());
  	assertValidDualZone();
  }
  
  	/* Cogit>>#compactPICsWithFreedTargets */
  static void
  compactPICsWithFreedTargets(void)
  {
      CogMethod *cogMethod;
      sqInt count;
  
  	cogMethod = ((CogMethod *) methodZoneBase);
  	count = 0;
  	while (cogMethod < (limitZony())) {
  		if ((((cogMethod->cmType)) == CMClosedPIC)
  		 && (cPICCompactAndIsNowEmpty(cogMethod))) {
  			((((CogMethod *) ((((usqInt)cogMethod)) + codeToDataDelta)))->cmType = CMFree);
  		}
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((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;
  	
  	/* If there is a link register it must be saved (pushed onto the stack) before it
  	   is smashed by the abort call, and hence needs to be manually handled here */
  	sendMiss = genoperand(PushR, LinkReg);
  	/* begin Call: */
  	callTarget = methodAbortTrampolineFor(methodOrBlockNumArgs);
  	return genoperand(Call, callTarget);
  }
  
  	/* Cogit>>#compileBlockDispatchFrom:to: */
  static sqInt NoDbgRegParms
  compileBlockDispatchFromto(sqInt lowBlockStartIndex, sqInt highBlockStartIndex)
  {
      AbstractInstruction *anInstruction;
      BlockStart *blockStart;
      sqInt halfWay;
      AbstractInstruction *jmp;
      sqInt literal;
  
  	if (lowBlockStartIndex == highBlockStartIndex) {
  		blockStart = blockStartAt(lowBlockStartIndex);
  		genoperand(Jump, ((sqInt)((blockStart->entryLabel))));
  		return null;
  	}
  	halfWay = (highBlockStartIndex + lowBlockStartIndex) / 2;
  	assert(((halfWay >= lowBlockStartIndex) && (halfWay <= highBlockStartIndex)));
  
  	/* N.B. FLAGS := TempReg - startpc */
  	blockStart = blockStartAt(halfWay);
  	/* begin checkQuickConstant:forInstruction: */
  	literal = (((usqInt)(((blockStart->startpc)) + 1) << 1) | 1);
  	anInstruction = genoperandoperand(CmpCqR, (((usqInt)(((blockStart->startpc)) + 1) << 1) | 1), TempReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(literal));
  	}
  	if (lowBlockStartIndex == halfWay) {
  		genConditionalBranchoperand(JumpLessOrEqual, ((sqInt)((blockStart->entryLabel))));
  		compileBlockDispatchFromto(halfWay + 1, highBlockStartIndex);
  		return null;
  	}
  	if ((halfWay + 1) == highBlockStartIndex) {
  		blockStart = blockStartAt(highBlockStartIndex);
  		genConditionalBranchoperand(JumpGreater, ((sqInt)((blockStart->entryLabel))));
  		return compileBlockDispatchFromto(lowBlockStartIndex, halfWay);
  	}
  	jmp = genConditionalBranchoperand(JumpGreater, ((sqInt)0));
  	compileBlockDispatchFromto(lowBlockStartIndex, halfWay);
  	if (halfWay == highBlockStartIndex) {
  		blockStart = blockStartAt(highBlockStartIndex);
  		jmpTarget(jmp, (blockStart->entryLabel));
  	}
  	else {
  		jmpTarget(jmp, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  		compileBlockDispatchFromto(halfWay + 1, highBlockStartIndex);
  	}
  	return 0;
  }
  
  
  /*	Compile a block's entry. This looks like a dummy CogBlockMethod header
  	(for frame parsing)
  	followed by either a frame build, if a frame is required, or nothing. The
  	CogMethodHeader's objectHeader field is a back pointer to the method, but
  	this can't be filled in until code generation. */
  
  	/* Cogit>>#compileBlockEntry: */
  static void NoDbgRegParms
  compileBlockEntry(BlockStart *blockStart)
  {
      AbstractInstruction *abstractInstruction;
      sqInt alignment;
  
  	/* begin AlignmentNops: */
  	alignment = blockAlignment();
  	genoperand(AlignmentNops, alignment);
  	(blockStart->fakeHeader = genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	
  	switch (sizeof(CogBlockMethod)) {
  	case 8:
  		genoperand(Fill32, 0);
  		genoperand(Fill32, 0);
  		break;
  	case 12:
  		genoperand(Fill32, 0);
  		genoperand(Fill32, 0);
  		genoperand(Fill32, 0);
  		break;
  	case 16:
  		genoperand(Fill32, 0);
  		genoperand(Fill32, 0);
  		genoperand(Fill32, 0);
  		genoperand(Fill32, 0);
  		break;
  	default:
  		error("Case not found and no otherwise clause");
  	}
  	(blockStart->entryLabel = genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	if (needsFrame) {
  		compileBlockFrameBuild(blockStart);
  		if (recordBlockTrace()) {
  			/* begin CallRT: */
  			abstractInstruction = genoperand(Call, ceTraceBlockActivationTrampoline);
  			(abstractInstruction->annotation = IsRelativeCall);
  		}
  	}
  	else {
  		compileBlockFramelessEntry(blockStart);
  	}
  }
  
  
  /*	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)
  {
      AbstractInstruction *anInstruction;
      const int cStackAlignment = STACK_ALIGN_BYTES;
      sqInt delta;
      sqInt numRegsPushed;
      sqInt operand1;
      usqInt regMaskCopy;
      sqInt regsToSave;
      sqInt wordsPushedModAlignment;
  
  	regsToSave = (resultRegOrNone == NoReg
  		? regMask
  		: ((regMask | (1U << resultRegOrNone)) - (1U << resultRegOrNone)));
  	if (cStackAlignment > BytesPerWord) {
  		/* begin genAlignCStackSavingRegisters:numArgs:wordAlignment: */
  		regMaskCopy = ((usqInt)regsToSave);
  		numRegsPushed = 0;
  		while (regMaskCopy != 0) {
  			numRegsPushed += regMaskCopy & 1;
  			regMaskCopy = ((regMaskCopy) >> 1);
  		}
  		if ((numRegsPushed == 0)
  		 && (4 /* numIntRegArgs */ >= numArgs)) {
  			goto l4;
  		}
  		wordsPushedModAlignment = (numRegsPushed + ((((numArgs - 4 /* numIntRegArgs */) < 0) ? 0 : (numArgs - 4 /* numIntRegArgs */)))) % (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));
  			}
  		}
  	l4:	/* end genAlignCStackSavingRegisters:numArgs:wordAlignment: */;
  	}
  	/* begin genSaveRegs: */
  	if (regsToSave == 0) {
  		genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	}
  	else {
  		genoperand(PushSTM, regsToSave);
  	}
  	genMarshallNArgsargargargarg(backEnd, numArgs, regOrConst0, regOrConst1, regOrConst2, regOrConst3);
  	/* begin gen:literal: */
  	operand1 = ((usqInt)aRoutine);
  	checkLiteralforInstruction(operand1, genoperand(CallFull, operand1));
  	genWriteCResultIntoReg(backEnd, resultRegOrNone);
  	/* begin genRemoveNArgsFromStack: */
  	assert(numArgs <= 4);
  	/* begin genRestoreRegs: */
  	if (regsToSave == 0) {
  		genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	}
  	else {
  		genoperand(PopLDM, regsToSave);
  	}
  }
  
  
  /*	Compile the cache tag computation and the first comparison. Answer the
  	address of that comparison. */
  
  	/* Cogit>>#compileCPICEntry */
  static AbstractInstruction *
  compileCPICEntry(void)
  {
  	entry = genGetInlineCacheClassTagFromintoforEntry(ReceiverResultReg, TempReg, 1);
  	/* begin CmpR:R: */
  	assert(!((ClassReg == SPReg)));
  	genoperandoperand(CmpRR, ClassReg, TempReg);
  	return genConditionalBranchoperand(JumpNonZero, ((sqInt)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 = genGetInlineCacheClassTagFromintoforEntry(ReceiverResultReg, TempReg, 1);
  	/* begin CmpR:R: */
  	assert(!((ClassReg == SPReg)));
  	genoperandoperand(CmpRR, ClassReg, TempReg);
  	genConditionalBranchoperand(JumpNonZero, ((sqInt)sendMiss));
  	noCheckEntry = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	if (compileSendTrace()) {
  		/* begin saveAndRestoreLinkRegAround: */
  		inst = genoperand(PushR, LinkReg);
  		/* begin CallRT: */
  		abstractInstruction = genoperand(Call, ceTraceLinkedSendTrampoline);
  		(abstractInstruction->annotation = IsRelativeCall);
  		genoperand(PopR, LinkReg);
  	}
  }
  
  
  /*	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 /* picAbortDiscriminatorValue */, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(0 /* picAbortDiscriminatorValue */));
  	}
  	picMNUAbort = anInstruction;
  	
  	/* If there is a link register it must be saved (pushed onto the stack) before it
  	   is smashed by the abort call, and hence needs to be manually handled here */
  	picInterpretAbort = genoperand(PushR, LinkReg);
  	/* begin Call: */
  	callTarget = picAbortTrampolineFor(numArgs);
  	genoperand(Call, callTarget);
  	return 0;
  }
  
  
  /*	Compile the compare of stackLimit against the stack pointer, jumping to
  	the stackOverflowCall if
  	the stack pointer is below the limit. Answer a bytecode annotated label
  	that follows the sequence.
  	
  	The stack check functions both as a genuine stack limit check to prevent
  	calls overflowing stack pages,
  	and as an event/context-switch break out. To cause an event check
  	(including a check for a required
  	context switch), stackLimit is set to the highest possible value, and
  	hence all stack limit checks will
  	fail. A path in the stack overflow abort then arranges to call event
  	checking if it has been requested.
  	
  	Certain block activations (e.g. valueNoContextSwitch:) must not context
  	switch, and in that
  	case, SendNumArgs is set to zero to communicate to the stack overflow
  	abort that it should
  	not perform event/context-switch (yet). */
  
  	/* Cogit>>#compileStackOverflowCheck: */
  static AbstractInstruction * NoDbgRegParms
  compileStackOverflowCheck(sqInt canContextSwitch)
  {
      sqInt address;
      AbstractInstruction *anInstruction;
      AbstractInstruction * jumpSkip;
      AbstractInstruction * label;
  
  	/* begin MoveAw:R: */
  	address = stackLimitAddress();
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(address, genoperandoperand(MoveAwR, address, TempReg));
  	/* begin CmpR:R: */
  	assert(!((TempReg == SPReg)));
  	genoperandoperand(CmpRR, TempReg, SPReg);
  	if (canContextSwitch) {
  		genConditionalBranchoperand(JumpBelow, ((sqInt)stackOverflowCall));
  		label = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	}
  	else {
  		jumpSkip = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt)0));
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction = genoperandoperand(MoveCqR, 0, SendNumArgsReg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(0));
  		}
  		genoperand(Jump, ((sqInt)stackOverflowCall));
  		jmpTarget(jumpSkip, (label = genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
  	}
  	/* begin annotateBytecode: */
  	(label->annotation = HasBytecodePC);
  	return label;
  }
  
  
  /*	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);
  	genTrampolineReturn(pushLinkReg);
  }
  
  
  /*	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 cmNoCheckEntryOffset */
  /*	stack allocate the various collections so that they
  	are effectively garbage collected on return. */
  
  	/* Cogit>>#computeEntryOffsets */
  static void
  computeEntryOffsets(void)
  {
      sqInt fixupSize;
      sqInt opcodeSize;
      AbstractInstruction *sendMissCall;
  
  	/* begin allocateOpcodes:bytecodes: */
  	numAbstractOpcodes = 24;
  	opcodeSize = (sizeof(CogAbstractInstruction)) * numAbstractOpcodes;
  	fixupSize = (sizeof(CogBytecodeFixup)) * numAbstractOpcodes;
  	abstractOpcodes = alloca(opcodeSize + fixupSize);
  	bzero(abstractOpcodes, opcodeSize + fixupSize);
  	fixups = ((void *)((((usqInt)abstractOpcodes)) + opcodeSize));
  	zeroOpcodeIndexForNewOpcodes();
  	labelCounter = 0;
  	methodOrBlockNumArgs = 0;
  	sendMissCall = compileAbort();
  	compileEntry();
  	computeMaximumSizes();
  	generateInstructionsAt(methodZoneBase + (sizeof(CogMethod)));
  	cmEntryOffset = ((entry->address)) - methodZoneBase;
  	cmNoCheckEntryOffset = ((noCheckEntry->address)) - methodZoneBase;
  	missOffset = (((sendMissCall->address)) + ((sendMissCall->machineCodeSize))) - methodZoneBase;
  	entryPointMask = BytesPerWord - 1;
  	while ((cmEntryOffset & entryPointMask) == (cmNoCheckEntryOffset & entryPointMask)) {
  		entryPointMask = (entryPointMask + entryPointMask) + 1;
  	}
  	if (entryPointMask >= (roundUpToMethodAlignment(backEnd(), 1))) {
  		error("cannot differentiate checked and unchecked entry-points with current cog method alignment");
  	}
  	checkedEntryAlignment = cmEntryOffset & entryPointMask;
  	uncheckedEntryAlignment = cmNoCheckEntryOffset & entryPointMask;
  	assert(checkedEntryAlignment != uncheckedEntryAlignment);
  }
  
  
  /*	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 cmNoCheckEntryOffset */
  /*	stack allocate the various collections so that they
  	are effectively garbage collected on return. */
  
  	/* Cogit>>#computeFullBlockEntryOffsets */
  static void
  computeFullBlockEntryOffsets(void)
  {
  	}
  
  
  /*	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;
      sqInt 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:numArgs:delta: */
  static sqInt NoDbgRegParms
  configureCPICCase0Case1MethodtagisMNUCasenumArgsdelta(CogMethod *cPIC, CogMethod *case0CogMethod, sqInt case1Method, sqInt case1Tag, sqInt isMNUCase, sqInt numArgs, sqInt addrDelta)
  {
      sqInt caseEndAddress;
      sqInt operand;
      sqInt targetEntry;
  
  	assert(case1Method != null);
  	rewriteCallAttarget(backEnd, (((sqInt)cPIC)) + missOffset, picAbortTrampolineFor(numArgs));
  	assert(!(inlineCacheTagIsYoung(case1Tag)));
  	if ((!isMNUCase)
  	 && (methodHasCogMethod(case1Method))) {
  		operand = 0;
  		targetEntry = (((sqInt)(cogMethodOf(case1Method)))) + cmNoCheckEntryOffset;
  	}
  	else {
  
  		/* We do not scavenge PICs, hence we cannot cache the MNU method if it is in new space. */
  		operand = ((case1Method == null)
  		 || (isYoungObject(case1Method))
  			? 0
  			: case1Method);
  		targetEntry = (case1Method == null
  			? (((sqInt)cPIC)) + (sizeof(CogMethod))
  			: (((sqInt)cPIC)) + (picInterpretAbortOffset()));
  	}
  	rewriteJumpLongAttarget(backEnd, (((sqInt)cPIC)) + firstCPICCaseOffset, (((sqInt)case0CogMethod)) + cmNoCheckEntryOffset);
  
  	/* update the cpic case */
  	caseEndAddress = addressOfEndOfCaseinCPIC(2, cPIC);
  	rewriteCPICCaseAttagobjReftarget(caseEndAddress, case1Tag, operand, ((sqInt)((isMNUCase
  	? (((sqInt)cPIC)) + (sizeof(CogMethod))
  	: targetEntry))));
  	relocateMethodReferenceBeforeAddressby(backEnd, ((((sqInt)cPIC)) + cPICEndOfCodeOffset) - 4 /* jumpLongByteSize */, addrDelta);
  	rewriteJumpLongAttarget(backEnd, (((sqInt)cPIC)) + cPICEndOfCodeOffset, cPICMissTrampolineFor(numArgs));
  	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. */
  /*	adjust the jump at missOffset, the ceAbortXArgs */
  
  	/* Cogit>>#configureMNUCPIC:methodOperand:numArgs:delta: */
  static sqInt NoDbgRegParms
  configureMNUCPICmethodOperandnumArgsdelta(CogMethod *cPIC, sqInt methodOperand, sqInt numArgs, sqInt addrDelta)
  {
      usqInt addressFollowingJump;
      int operand;
      sqInt target;
  
  	rewriteCallAttarget(backEnd, (((sqInt)cPIC)) + missOffset, picAbortTrampolineFor(numArgs));
  
  	/* set the jump to the case0 method */
  	operand = ((methodOperand == null)
  	 || (isYoungObject(methodOperand))
  		? 0
  		: methodOperand);
  	rewriteJumpLongAttarget(backEnd, (((sqInt)cPIC)) + firstCPICCaseOffset, (((sqInt)cPIC)) + (sizeof(CogMethod)));
  	storeLiteralbeforeFollowingAddress(backEnd, operand, ((((sqInt)cPIC)) + firstCPICCaseOffset) - 4 /* jumpLongByteSize */);
  	rewriteJumpLongAttarget(backEnd, (((sqInt)cPIC)) + cPICEndOfCodeOffset, cPICMissTrampolineFor(numArgs));
  	relocateMethodReferenceBeforeAddressby(backEnd, ((((sqInt)cPIC)) + cPICEndOfCodeOffset) - 4 /* jumpLongByteSize */, addrDelta);
  	/* begin rewriteCPIC:caseJumpTo: */
  	target = addressOfEndOfCaseinCPIC(2, cPIC);
  	/* begin rewriteCPICJumpAt:target: */
  	addressFollowingJump = (((((sqInt)cPIC)) + firstCPICCaseOffset) - 4 /* jumpLongByteSize */) - 4 /* loadLiteralByteSize */;
  	rewriteTransferAttarget(((AbstractInstruction *) backEnd), addressFollowingJump, target);
  	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)
  {
      usqInt addressFollowingJump;
      usqInt addressFollowingJump1;
      sqInt entryPoint;
      sqInt followingAddress;
      sqInt i;
      sqInt methods[MaxCPICCases];
      sqInt pc;
      int tags[MaxCPICCases];
      CogMethod *targetMethod;
      sqInt targets[MaxCPICCases];
      sqInt used;
      sqInt 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);
  		}
  
  		/* Collect all target triples except for triples whose entry-point is a freed method */
  		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))
  	: 0));
  			targets[used] = entryPoint;
  			methods[used] = (literalBeforeFollowingAddress(backEnd, pc - ((i == 1
  	? /* begin jumpLongByteSize */ 4
  	: (jumpLongConditionalByteSize(backEnd)) + 8 /* cmpC32RTempByteSize */))));
  			used += 1;
  		}
  	}
  	if (used == ((cPIC->cPICNumCases))) {
  		return 0;
  	}
  	if (used == 0) {
  		return 1;
  	}
  	((((CogMethod *) ((((usqInt)cPIC)) + codeToDataDelta)))->cPICNumCases = used);
  	if (used == 1) {
  		pc = addressOfEndOfCaseinCPIC(2, cPIC);
  		/* begin rewriteCPIC:caseJumpTo: */
  		addressFollowingJump = (((((sqInt)cPIC)) + firstCPICCaseOffset) - 4 /* jumpLongByteSize */) - 4 /* loadLiteralByteSize */;
  		rewriteTransferAttarget(((AbstractInstruction *) backEnd), addressFollowingJump, pc);
  		return 0;
  	}
  	for (i = 1; i < used; i += 1) {
  		pc = addressOfEndOfCaseinCPIC(i + 1, cPIC);
  		rewriteCPICCaseAttagobjReftarget(pc, tags[i], methods[i], targets[i]);
  	}
  	/* begin rewriteCPIC:caseJumpTo: */
  	addressFollowingJump1 = (((((sqInt)cPIC)) + firstCPICCaseOffset) - 4 /* jumpLongByteSize */) - 4 /* loadLiteralByteSize */;
  	rewriteTransferAttarget(((AbstractInstruction *) backEnd), addressFollowingJump1, 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);
  		}
  		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 usqInt
  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;
  
  	/* Since this is a fast test doing simple compares we don't need to care that some
  	   cases have nonsense addresses in there. Just zip on through. */
  	/* First jump is unconditional; subsequent ones are conditional */
  	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) {
  
  			/* first case may have been collected and stored here by collectCogConstituentFor:Annotation:Mcpc:Bcpc:Method: */
  			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);
  		}
  		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);
  }
  
  
  /*	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 1310720;
  }
  
  
  /*	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 bsOffset;
      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;
  		}
  	}
  	/* begin bytecodeSetOffsetFor: */
  	bsOffset = 
  #  if MULTIPLEBYTECODESETS
  		(methodUsesAlternateBytecodeSet(aMethod)
  				? 256
  				: 0)
  #  else /* MULTIPLEBYTECODESETS */
  		(assert(!((methodUsesAlternateBytecodeSet(aMethod)))),
  			0)
  #  endif /* MULTIPLEBYTECODESETS */
  		;
  	nExts = 0;
  	end = numBytesOf(aMethod);
  	while (pc <= end) {
  		byte = fetchByteofObject(pc, aMethod);
  		descriptor = generatorAt(byte + bsOffset);
  		if (((descriptor->isReturn))
  		 && (pc >= latestContinuation)) {
  			end = pc;
  		}
  		if ((isBranch(descriptor))
  		 || ((descriptor->isBlockCreation))) {
  			distance = ((descriptor->spanFunction))(descriptor, pc, nExts, aMethod);
  			targetPC = (pc + ((descriptor->numBytes))) + distance;
  			latestContinuation = ((latestContinuation < targetPC) ? targetPC : latestContinuation);
  			if ((descriptor->isBlockCreation)) {
  				pc += distance;
  			}
  		}
  		else {
  			/* latestContinuation = */ latestContinuation;
  		}
  		nExts = ((descriptor->isExtension)
  			? nExts + 1
  			: 0);
  		pc += (descriptor->numBytes);
  	}
  	return end;
  }
  
  
  /*	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??");
  }
  
  
  /*	Answer if the entryPoint's tag is expected to be a selector reference, as
  	opposed to a class tag.
   */
  
  	/* Cogit>>#entryPointTagIsSelector: */
  static sqInt NoDbgRegParms
  entryPointTagIsSelector(sqInt entryPoint)
  {
  	return (entryPoint < methodZoneBase)
  	 || (((entryPoint & entryPointMask) == uncheckedEntryAlignment)
  	 || (((entryPoint & entryPointMask) == checkedEntryAlignment)
  	 && ((((((CogMethod *) (entryPoint - cmEntryOffset)))->cmType)) == CMOpenPIC)));
  }
  
  
  /*	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;
      sqInt errors;
      sqInt i;
      sqInt methodObjPC;
      sqInt object;
      sqInt pc;
  
  	errors = 0;
  
  	/* First jump is unconditional; subsequent ones are conditional */
  	pc = (((usqInt)cPIC)) + firstCPICCaseOffset;
  	object = literalBeforeFollowingAddress(backEnd, pc - 4 /* jumpLongByteSize */);
  	if (!(asserta(object == (firstPrototypeMethodOop())))) {
  		errors = 1;
  	}
  	entryPoint = jumpLongTargetBeforeFollowingAddress(backEnd, pc);
  	if (!(asserta(entryPoint == ((cPICPrototypeCaseOffset()) + 13262352)))) {
  		errors += 2;
  	}
  	for (i = 1; i < MaxCPICCases; i += 1) {
  
  		/* verify information in case is as expected. */
  		pc += cPICCaseSize;
  		methodObjPC = (pc - (jumpLongConditionalByteSize(backEnd))) - 8 /* cmpC32RTempByteSize */;
  		object = literalBeforeFollowingAddress(backEnd, methodObjPC);
  		if (!(asserta(object == ((subsequentPrototypeMethodOop()) + i)))) {
  			errors = errors | 4;
  		}
  		classTagPC = pc - (jumpLongConditionalByteSize(backEnd));
  		/* begin literal32BeforeFollowingAddress: */
  		classTag = literalBeforeFollowingAddress(((AbstractInstruction *) backEnd), classTagPC);
  		if (!(asserta(classTag == (3133021973U + i)))) {
  			errors = errors | 8;
  		}
  		/* begin jumpLongConditionalTargetBeforeFollowingAddress: */
  		entryPoint = jumpLongTargetBeforeFollowingAddress(((AbstractInstruction *) backEnd), pc);
  		if (!(asserta(entryPoint == (((cPICPrototypeCaseOffset()) + 13262352) + (i * 16))))) {
  			errors = errors | 16;
  		}
  		rewriteCPICCaseAttagobjReftarget(pc, classTag ^ 1515870810, object ^ 2779096485U, entryPoint ^ 5614160);
  		object = literalBeforeFollowingAddress(backEnd, methodObjPC);
  		if (!(asserta(object == (((subsequentPrototypeMethodOop()) + i) ^ 2779096485U)))) {
  			errors = errors | 32;
  		}
  		/* begin literal32BeforeFollowingAddress: */
  		classTag = literalBeforeFollowingAddress(((AbstractInstruction *) backEnd), classTagPC);
  		if (!(asserta(classTag == ((3133021973U + i) ^ 1515870810)))) {
  			errors = errors | 64;
  		}
  		/* begin jumpLongConditionalTargetBeforeFollowingAddress: */
  		entryPoint = jumpLongTargetBeforeFollowingAddress(((AbstractInstruction *) backEnd), pc);
  		if (!(asserta(entryPoint == ((((cPICPrototypeCaseOffset()) + 13262352) + (i * 16)) ^ 5614160)))) {
  			errors = errors | 128;
  		}
  		rewriteCPICCaseAttagobjReftarget(pc, classTag ^ 1515870810, object ^ 2779096485U, entryPoint ^ 5614160);
  	}
  	entryPoint = jumpLongTargetBeforeFollowingAddress(backEnd, (((usqInt)cPIC)) + cPICEndOfCodeOffset);
  	if (!(asserta(entryPoint == (cPICMissTrampolineFor(0))))) {
  		errors += 256;
  	}
  	return errors;
  }
  
  
  /*	Fill in the block headers now we know the exact layout of the code. */
  
  	/* Cogit>>#fillInBlockHeadersAt: */
  static sqInt NoDbgRegParms
  fillInBlockHeadersAt(sqInt startAddress)
  {
      sqInt aCogMethodOrInteger;
      CogBlockMethod *blockHeader;
      BlockStart *blockStart;
      sqInt i;
  
  	if (!(needsFrame
  		 && (blockCount > 0))) {
  		return null;
  	}
  	if (blockNoContextSwitchOffset == null) {
  		blockNoContextSwitchOffset = ((blockEntryLabel->address)) - ((blockEntryNoContextSwitch->address));
  	}
  	else {
  		assert(blockNoContextSwitchOffset == (((blockEntryLabel->address)) - ((blockEntryNoContextSwitch->address))));
  	}
  	for (i = 0; i < blockCount; i += 1) {
  		blockStart = blockStartAt(i);
  		/* begin writableBlockMethodFor: */
  		aCogMethodOrInteger = (((blockStart->fakeHeader))->address);
  		blockHeader = ((CogBlockMethod *) ((((usqInt)aCogMethodOrInteger)) + codeToDataDelta));
  		(blockHeader->homeOffset = ((((blockStart->fakeHeader))->address)) - startAddress);
  		(blockHeader->startpc = (blockStart->startpc));
  		(blockHeader->cmType = CMBlock);
  		(blockHeader->cmNumArgs = (blockStart->numArgs));
  		(blockHeader->cbUsesInstVars = (blockStart->hasInstVarRef));
  		(blockHeader->stackCheckOffset = (((blockStart->stackCheckLabel)) == null
  			? 0
  			: ((((blockStart->stackCheckLabel))->address)) - ((((blockStart->fakeHeader))->address))));
  	}
  	return 0;
  }
  
  
  /*	Fill in the header for theCogMehtod method. This may be located at the
  	writable mapping. */
  
  	/* Cogit>>#fillInMethodHeader:size:selector: */
  static void NoDbgRegParms
  fillInMethodHeadersizeselector(CogMethod *method, sqInt size, sqInt selector)
  {
      sqInt actualMethodLocation;
      sqInt endAddress;
      CogMethod *originalMethod;
      sqInt rawHeader;
  
  	actualMethodLocation = (((usqInt)method)) - codeToDataDelta;
  	(method->cmType = CMMethod);
  	(method->objectHeader = nullHeaderForMachineCodeMethod());
  	(method->blockSize = size);
  	(method->methodObject = methodObj);
  
  	/* If the method has already been cogged (e.g. Newspeak accessors) then
  	   leave the original method attached to its cog method, but get the right header. */
  	rawHeader = rawHeaderOf(methodObj);
  	if (isCogMethodReference(rawHeader)) {
  		originalMethod = ((CogMethod *) rawHeader);
  		assert(((originalMethod->blockSize)) == size);
  		assert(methodHeader == ((originalMethod->methodHeader)));
  			}
  	else {
  		rawHeaderOfput(methodObj, actualMethodLocation);
  			}
  	(method->methodHeader = methodHeader);
  	(method->selector = selector);
  	(method->cmNumArgs = argumentCountOfMethodHeader(methodHeader));
  	(method->cmHasMovableLiteral = hasMovableLiteral);
  	if ((method->cmRefersToYoung = hasYoungReferent)) {
  		addToYoungReferrers(method);
  	}
  	(method->cmUsageCount = initialMethodUsageCount());
  	/* begin cpicHasMNUCase: */
  	((((CogBlockMethod *) method))->cpicHasMNUCaseOrCMIsFullBlock) = 0;
  	(method->cmUsesPenultimateLit = maxLitIndex >= ((literalCountOfMethodHeader(methodHeader)) - 2));
  	(method->blockEntryOffset = (blockEntryLabel != null
  		? ((blockEntryLabel->address)) - actualMethodLocation
  		: 0));
  	if (needsFrame) {
  		if (!((((stackCheckLabel->address)) - actualMethodLocation) <= MaxStackCheckOffset)) {
  			error("too much code for stack check offset");
  		}
  	}
  	(method->stackCheckOffset = (needsFrame
  		? ((stackCheckLabel->address)) - actualMethodLocation
  		: 0));
  	flushICacheFromto(backEnd, actualMethodLocation, actualMethodLocation + size);
  	assert((callTargetFromReturnAddress(backEnd, actualMethodLocation + missOffset)) == (methodAbortTrampolineFor((method->cmNumArgs))));
  	assert(size == (roundUpLength(size)));
  	/* begin assertValidDualZoneFrom:to: */
  	endAddress = actualMethodLocation + size;
  	
  #  if DUAL_MAPPED_CODE_ZONE
  	assertCoherentCodeAtdelta(backEnd, actualMethodLocation + cmNoCheckEntryOffset, codeToDataDelta);
  #  endif /* DUAL_MAPPED_CODE_ZONE */
  	/* begin maybeEnableSingleStep */
  }
  
  	/* 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);
  }
  
  	/* Cogit>>#findBlockMethodWithEntry:startBcpc: */
  static usqInt NoDbgRegParms
  findBlockMethodWithEntrystartBcpc(sqInt blockEntryMcpc, sqInt startBcpc)
  {
      CogBlockMethod *cogBlockMethod;
  
  	cogBlockMethod = ((CogBlockMethod *) (blockEntryMcpc - (sizeof(CogBlockMethod))));
  	if (((cogBlockMethod->startpc)) == startBcpc) {
  		return ((usqInt)cogBlockMethod);
  	}
  	return 0;
  }
  
  	/* Cogit>>#findMapLocationForMcpc:inMethod: */
  static usqInt NoDbgRegParms
  findMapLocationForMcpcinMethod(usqInt targetMcpc, CogMethod *cogMethod)
  {
      sqInt annotation;
      usqInt map;
      sqInt mapByte;
      sqInt mcpc;
  
  	mcpc = (((usqInt)cogMethod)) + cmNoCheckEntryOffset;
  	map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
  	if (mcpc == targetMcpc) {
  		return map;
  	}
  	while (((mapByte = byteAt(map))) != MapEnd) {
  		annotation = ((usqInt)(mapByte)) >> AnnotationShift;
  		if (annotation != IsAnnotationExtension) {
  			mcpc += 4 /* codeGranularity */ * ((annotation == IsDisplacementX2N
  	? ((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))
  	: mapByte & DisplacementMask));
  		}
  		if (mcpc >= targetMcpc) {
  			assert(mcpc == targetMcpc);
  			if (annotation == IsDisplacementX2N) {
  				map -= 1;
  				mapByte = byteAt(map);
  				annotation = ((usqInt)(mapByte)) >> AnnotationShift;
  				assert(annotation > IsAnnotationExtension);
  			}
  			return map;
  		}
  		map -= 1;
  	}
  	return 0;
  }
  
  
  /*	Find the CMMethod or CMBlock that has zero-relative startbcpc as its first
  	bytecode pc.
  	As this is for cannot resume processing and/or conversion to machine-code
  	on backward
  	branch, it doesn't have to be fast. Enumerate block returns and map to
  	bytecode pcs. */
  
  	/* Cogit>>#findMethodForStartBcpc:inHomeMethod: */
  CogBlockMethod *
  findMethodForStartBcpcinHomeMethod(sqInt startbcpc, CogMethod *cogMethod)
  {
  	assert(((cogMethod->cmType)) == CMMethod);
  	if (startbcpc == (startPCOfMethodHeader((cogMethod->methodHeader)))) {
  		return ((CogBlockMethod *) cogMethod);
  	}
  	assert(((cogMethod->blockEntryOffset)) != 0);
  	return ((CogBlockMethod *) (blockDispatchTargetsForperformarg(cogMethod, findBlockMethodWithEntrystartBcpc, startbcpc)));
  }
  
  
  /*	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);
  }
  
  	/* Cogit>>#firstMappedPCFor: */
  static sqInt NoDbgRegParms
  firstMappedPCFor(CogMethod *cogMethod)
  {
  	return (((usqInt)cogMethod)) + cmNoCheckEntryOffset;
  }
  
  
  /*	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 (addressIsInCurrentCompilation(99282957)
  		? 212332557
  		: 99282957);
  }
  
  	/* Cogit>>#fixupAt: */
  static BytecodeFixup * NoDbgRegParms
  fixupAt(sqInt fixupPC)
  {
  	return fixupAtIndex(fixupPC - initialPC);
  }
  
  
  /*	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;
  }
  
  	/* Cogit>>#genCheckForInterruptsTrampoline */
  static usqInt
  genCheckForInterruptsTrampoline(void)
  {
      sqInt address;
  
  	zeroOpcodeIndex();
  	/* begin MoveR:Aw: */
  	address = instructionPointerAddress();
  	/* begin gen:operand:literal: */
  	checkLiteralforInstruction(address, genoperandoperand(MoveRAw, LinkReg, address));
  	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(ceCheckForInterrupts, "ceCheckForInterruptsTrampoline", 0, null, null, null, null, 0 /* emptyRegisterMask */, 0, NoReg, 1);
  }
  
  	/* Cogit>>#genConditionalBranch:operand: */
  static AbstractInstruction * NoDbgRegParms
  genConditionalBranchoperand(sqInt opcode, sqInt operandOne)
  {
      AbstractInstruction *branch;
  
  	/* begin noteFollowingConditionalBranch: */
  	branch = genoperand(opcode, operandOne);
  	return branch;
  }
  
  
  /*	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;
      usqInt 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));
  	}
  	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, PCReg);
  	}
  }
  
  
  /*	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 routine assumes the system's frame pointer is the same as that used
  	in generated code. */
  
  	/* Cogit>>#generateCaptureCStackPointers: */
  static void NoDbgRegParms NeverInline
  generateCaptureCStackPointers(sqInt captureFramePointer)
  {
      sqInt address;
      sqInt address1;
      sqInt address2;
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      sqInt callerSavedReg;
      sqInt fixupSize;
      sqInt offset;
      sqInt opcodeSize;
      sqInt pushedVarBaseReg;
      sqInt quickConstant;
      usqInt startAddress;
  
  	/* begin allocateOpcodes:bytecodes: */
  	numAbstractOpcodes = 32;
  	opcodeSize = (sizeof(CogAbstractInstruction)) * numAbstractOpcodes;
  	fixupSize = (sizeof(CogBytecodeFixup)) * numAbstractOpcodes;
  	abstractOpcodes = alloca(opcodeSize + fixupSize);
  	bzero(abstractOpcodes, opcodeSize + fixupSize);
  	fixups = ((void *)((((usqInt)abstractOpcodes)) + opcodeSize));
  	zeroOpcodeIndexForNewOpcodes();
  	labelCounter = 0;
  
  	/* Must happen first; value may be used in accessing any of the following addresses */
  	startAddress = methodZoneBase;
  	callerSavedReg = 0;
  	pushedVarBaseReg = 0;
  	if (!(CallerSavedRegisterMask & (1U << VarBaseReg))) {
  
  		/* VarBaseReg is not caller-saved; must save and restore it, either by using an available caller-saved reg or push/pop. */
  
  		/* TempReg used below */
  		callerSavedReg = availableRegisterOrNoneIn(((ABICallerSavedRegisterMask | (1U << TempReg)) - (1U << TempReg)));
  		if (callerSavedReg == NoReg) {
  			gNativePushR(VarBaseReg);
  			pushedVarBaseReg = 1;
  		}
  		else {
  			/* begin MoveR:R: */
  			genoperandoperand(MoveRR, VarBaseReg, callerSavedReg);
  		}
  	}
  	/* begin MoveCq:R: */
  	quickConstant = varBaseAddress();
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(MoveCqR, quickConstant, VarBaseReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(quickConstant));
  	}
  	if (captureFramePointer) {
  		/* begin MoveR:Aw: */
  		address = cFramePointerAddress();
  		/* begin gen:operand:literal: */
  		checkLiteralforInstruction(address, genoperandoperand(MoveRAw, FPReg, address));
  	}
  	if (pushedVarBaseReg) {
  		/* begin LoadEffectiveAddressMw:r:R: */
  		if (pushedVarBaseReg) {
  			offset = 0 /* leafCallStackPointerDelta */ + BytesPerWord;
  		}
  		else {
  			/* begin leafCallStackPointerDelta */
  			offset = 0;
  		}
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction1 = genoperandoperandoperand(LoadEffectiveAddressMwrR, offset, NativeSPReg, TempReg);
  		if (usesOutOfLineLiteral(anInstruction1)) {
  			(anInstruction1->dependent = locateLiteral(offset));
  		}
  		/* begin MoveR:Aw: */
  		address1 = cStackPointerAddress();
  		/* begin gen:operand:literal: */
  		checkLiteralforInstruction(address1, genoperandoperand(MoveRAw, TempReg, address1));
  	}
  	else {
  		/* begin MoveR:Aw: */
  		address2 = cStackPointerAddress();
  		/* begin gen:operand:literal: */
  		checkLiteralforInstruction(address2, genoperandoperand(MoveRAw, NativeSPReg, address2));
  	}
  	if (!(CallerSavedRegisterMask & (1U << VarBaseReg))) {
  		if (pushedVarBaseReg) {
  			gNativePopR(VarBaseReg);
  		}
  		else {
  			/* begin MoveR:R: */
  			genoperandoperand(MoveRR, callerSavedReg, VarBaseReg);
  		}
  	}
  	gNativeRetN(0);
  	outputInstructionsForGeneratedRuntimeAt(startAddress);
  	flushICacheFromto(backEnd, ((usqInt)startAddress), ((usqInt)methodZoneBase));
  	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 *anInstruction;
      sqInt anInstruction1;
      AbstractInstruction *anInstruction2;
      CogMethod *cPIC;
      AbstractInstruction * cPICEndOfCodeLabel;
      sqInt endAddress;
      AbstractInstruction * endCPICCase1;
      sqInt fixupSize;
      sqInt h;
      AbstractInstruction *jumpNext;
      sqInt jumpTarget;
      sqInt jumpTarget1;
      sqInt jumpTarget2;
      sqInt numArgs;
      sqInt opcode;
      sqInt opcodeSize;
      sqInt operandOne;
      sqInt wordConstant;
      sqInt wordConstant1;
  
  
  	/* stack allocate the various collections so that they
  	   are effectively garbage collected on return. */
  	/* begin allocateOpcodes:bytecodes: */
  	numAbstractOpcodes = MaxCPICCases * 9;
  	opcodeSize = (sizeof(CogAbstractInstruction)) * numAbstractOpcodes;
  	fixupSize = (sizeof(CogBytecodeFixup)) * numAbstractOpcodes;
  	abstractOpcodes = alloca(opcodeSize + fixupSize);
  	bzero(abstractOpcodes, opcodeSize + fixupSize);
  	fixups = ((void *)((((usqInt)abstractOpcodes)) + opcodeSize));
  	zeroOpcodeIndexForNewOpcodes();
  	labelCounter = 0;
  	(methodLabel->address = methodZoneBase);
  	(methodLabel->dependent = null);
  	/* begin compileClosedPICPrototype */
  	compilePICAbort((numArgs = 0));
  
  	/* At the end of the entry code we need to jump to the first case code, which is actually the last chunk.
  	   On each entension we must update this jump to move back one case. */
  	jumpNext = compileCPICEntry();
  	/* begin MoveUniqueCw:R: */
  	wordConstant1 = firstPrototypeMethodOop();
  	/* begin uniqueLiteral:forInstruction: */
  	anInstruction2 = genoperandoperand(MoveCwR, wordConstant1, SendNumArgsReg);
  	assert(usesOutOfLineLiteral(anInstruction2));
  	(anInstruction2->dependent = allocateLiteral(wordConstant1));
  	/* begin JumpLong: */
  	jumpTarget1 = (((methodZoneBase + (youngReferrers())) / 2) - 13262352) + 13262352;
  	genoperand(JumpLong, jumpTarget1);
  	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));
  		/* begin gen:literal32:operand: */
  		opcode = CmpCwR;
  		/* begin checkLiteral32:forInstruction: */
  		anInstruction1 = ((sqInt) (genoperandoperand(opcode, 3133021973U + h, TempReg)));
  		checkLiteralforInstruction(3133021973U + h, anInstruction1);
  		/* begin JumpLongZero: */
  		jumpTarget = ((((methodZoneBase + (youngReferrers())) / 2) - 13262352) + 13262352) + (h * 16);
  		genConditionalBranchoperand(JumpLongZero, ((sqInt)jumpTarget));
  		if (h == 1) {
  			endCPICCase1 = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  		}
  	}
  	/* begin gen:literal:operand: */
  	operandOne = (methodLabel->address);
  	checkLiteralforInstruction(operandOne, genoperandoperand(MoveCwR, operandOne, ClassReg));
  	/* begin JumpLong: */
  	jumpTarget2 = cPICMissTrampolineFor(numArgs);
  	genoperand(JumpLong, jumpTarget2);
  	cPICEndOfCodeLabel = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	dumpLiterals(0);
  	computeMaximumSizes();
  	cPIC = ((CogMethod *) methodZoneBase);
  	closedPICSize = (sizeof(CogMethod)) + (generateInstructionsAt(methodZoneBase + (sizeof(CogMethod))));
  	endAddress = outputInstructionsAt(methodZoneBase + (sizeof(CogMethod)));
  	assert((methodZoneBase + closedPICSize) == endAddress);
  	firstCPICCaseOffset = ((endCPICCase0->address)) - methodZoneBase;
  	cPICEndOfCodeOffset = ((cPICEndOfCodeLabel->address)) - methodZoneBase;
  	cPICCaseSize = ((endCPICCase1->address)) - ((endCPICCase0->address));
  	cPICEndSize = closedPICSize - (((MaxCPICCases - 1) * cPICCaseSize) + firstCPICCaseOffset);
  	closedPICSize = roundUpToMethodAlignment(backEnd(), closedPICSize);
  	assert(((picInterpretAbort->address)) == (((methodLabel->address)) + (picInterpretAbortOffset())));
  	assert((expectedClosedPICPrototype(cPIC)) == 0);
  	storeLiteralbeforeFollowingAddress(backEnd, 0, ((endCPICCase0->address)) - 4 /* jumpLongByteSize */);
  	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>>#generateCogMethod: */
  static CogMethod * NoDbgRegParms
  generateCogMethod(sqInt selector)
  {
      sqInt codeSize;
      usqIntptr_t headerSize;
      sqInt mapSize;
      CogMethod *method;
      sqInt result;
      usqInt startAddress;
      sqInt totalSize;
  
  	headerSize = sizeof(CogMethod);
  	(methodLabel->address = freeStart());
  	computeMaximumSizes();
  	concretizeAt(methodLabel, freeStart());
  	codeSize = generateInstructionsAt(((methodLabel->address)) + headerSize);
  	mapSize = generateMapAtstart(null, ((methodLabel->address)) + cmNoCheckEntryOffset);
  	totalSize = roundUpToMethodAlignment(backEnd(), (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)));
  	result = outputInstructionsAt(startAddress + headerSize);
  	assert(((startAddress + headerSize) + codeSize) == result);
  	padIfPossibleWithStopsFromto(backEnd, result, ((startAddress + totalSize) - mapSize) - 1);
  	generateMapAtstart((startAddress + totalSize) - 1, startAddress + cmNoCheckEntryOffset);
  	fillInBlockHeadersAt(startAddress);
  	fillInMethodHeadersizeselector(((CogMethod *) ((((usqInt)startAddress)) + codeToDataDelta)), totalSize, selector);
  	method = ((CogMethod *) startAddress);
  	if (!(postCompileHook == null)) {
  		postCompileHook(method);
  		postCompileHook = null;
  	}
  	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;
      sqInt 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));
  			mcpc = (((instruction->opcode)) == Literal
  				? (instruction->address)
  				: ((instruction->address)) + ((instruction->machineCodeSize)));
  			while (((delta = (mcpc - location) / 4 /* codeGranularity */)) > DisplacementMask) {
  				maxDelta = (((((delta < MaxX2NDisplacement) ? delta : MaxX2NDisplacement)) | DisplacementMask) - DisplacementMask);
  				assert((((usqInt)(maxDelta)) >> AnnotationShift) <= DisplacementMask);
  				if (!(addressOrNull == null)) {
  					/* begin addToMap:instruction:byte:at:for: */
  					codeByteAtput(addressOrNull - length, (((usqInt)(maxDelta)) >> AnnotationShift) + DisplacementX2N);
  				}
  				location += maxDelta * 4 /* codeGranularity */;
  				length += 1;
  			}
  			if (!(addressOrNull == null)) {
  				mapEntry = delta + (((sqInt)((usqInt)((((annotation < IsSendCall) ? annotation : IsSendCall))) << AnnotationShift)));
  				/* begin addToMap:instruction:byte:at:for: */
  				codeByteAtput(addressOrNull - length, mapEntry);
  			}
  			location += delta * 4 /* codeGranularity */;
  			length += 1;
  			if (annotation > IsSendCall) {
  
  				/* Add the necessary IsAnnotationExtension */
  				if (!(addressOrNull == null)) {
  					mapEntry = (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift))) + (annotation - IsSendCall);
  					/* begin addToMap:instruction:byte:at:for: */
  					codeByteAtput(addressOrNull - length, mapEntry);
  				}
  				length += 1;
  			}
  		}
  	}
  	if (!(addressOrNull == null)) {
  		/* begin addToMap:instruction:byte:at:for: */
  		codeByteAtput(addressOrNull - length, MapEnd);
  	}
  	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 fixupSize;
      sqInt mapSize;
      sqInt opcodeSize;
  
  	/* begin allocateOpcodes:bytecodes: */
  	numAbstractOpcodes = 100;
  	opcodeSize = (sizeof(CogAbstractInstruction)) * numAbstractOpcodes;
  	fixupSize = (sizeof(CogBytecodeFixup)) * numAbstractOpcodes;
  	abstractOpcodes = alloca(opcodeSize + fixupSize);
  	bzero(abstractOpcodes, opcodeSize + fixupSize);
  	fixups = ((void *)((((usqInt)abstractOpcodes)) + opcodeSize));
  	zeroOpcodeIndexForNewOpcodes();
  	labelCounter = 0;
  	(methodLabel->address = methodZoneBase);
  	(methodLabel->dependent = null);
  	compileOpenPICnumArgs(specialSelector(0), 1 /* numRegArgs */);
  	computeMaximumSizes();
  	concretizeAt(methodLabel, methodZoneBase);
  	codeSize = generateInstructionsAt(methodZoneBase + (sizeof(CogMethod)));
  	mapSize = generateMapAtstart(null, methodZoneBase + cmNoCheckEntryOffset);
  	openPICSize = (roundUpLength((sizeof(CogMethod)) + codeSize)) + (roundUpToMethodAlignment(backEnd(), mapSize));
  }
  
  
  /*	Generate the run-time entries at the base of the native code zone and
  	update the base.
   */
  
  	/* Cogit>>#generateRunTimeTrampolines */
  static void
  generateRunTimeTrampolines(void)
  {
  	ceSendMustBeBooleanAddFalseTrampoline = genMustBeBooleanTrampolineForcalled(falseObject(), "ceSendMustBeBooleanAddFalseTrampoline");
  	ceSendMustBeBooleanAddTrueTrampoline = genMustBeBooleanTrampolineForcalled(trueObject(), "ceSendMustBeBooleanAddTrueTrampoline");
  	ceNonLocalReturnTrampoline = genNonLocalReturnTrampoline();
  
  	/* Neither of the context inst var access trampolines save registers.  Their operation could cause
  	   arbitrary update of stack frames, so the assumption is that callers flush the stack before calling
  	   the context inst var access trampolines, and that everything except the result is dead afterwards. */
  	ceCheckForInterruptTrampoline = genCheckForInterruptsTrampoline();
  	ceFetchContextInstVarTrampoline = genTrampolineForcalledargargresult(ceContextinstVar, "ceFetchContextInstVarTrampoline", ReceiverResultReg, SendNumArgsReg, SendNumArgsReg);
  	ceStoreContextInstVarTrampoline = genTrampolineForcalledargargargresult(ceContextinstVarvalue, "ceStoreContextInstVarTrampoline", ReceiverResultReg, SendNumArgsReg, ClassReg, ReceiverResultReg);
  
  	/* ceInvokeInterpreter is an optimization and a work-around. Historically we used setjmp/longjmp to reenter the
  	   interpreter at the current C stack base.  The C stack base is set at start-up and on each callback enter and
  	   callback return. The interpreter must be invoked whenever a non-machine-code method must be run.  That might
  	   be when invoking an interpreter method from one of the send linking routines (ceSend:...), or on continuing from
  	   an evaluation primitive such as primitiveExecuteMethod.  The problem here is that such primitives could have
  	   been invoked by the interpreter or by machine code.  So some form of non-local jump is required. But at least as
  	   early as MSVC Community 2017, the Microshaft longjmp performs stack unwinding which gets hoplessly confused
  	   (bless its little heart) by any stack switch between machine code and C stack, and raises a spurious
  	   Stack cookie instrumentation code detected a stack-based buffer overrun
  	   error from the bowels of gs_report.c _GSHandlerCheck.
  	   Since the CoInterpreter maintains the base of the C stack in CFramePointer & CStackPointer, it is straight-forward
  	   for us to simply call interpret after doing the switch to the C stack, avoiding the stack unwind issue altogether. */
  	ceCannotResumeTrampoline = genTrampolineForcalled(ceCannotResume, "ceCannotResumeTrampoline");
  
  	/* These two are unusual; they are reached by return instructions. */
  	ceInvokeInterpret = genInvokeInterpretTrampoline();
  	ceReturnToInterpreterTrampoline = genReturnToInterpreterTrampoline();
  	ceBaseFrameReturnTrampoline = genReturnTrampolineForcalledarg(ceBaseFrameReturn, "ceBaseFrameReturnTrampoline", 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)
  {
      usqInt oldMethodZoneBase;
      sqInt oldTrampolineTableIndex;
  
  
  	/* For the benefit of the following assert, assume the minimum at first. */
  	cFramePointerInUse = 0;
  	assertCStackWellAligned();
  	oldMethodZoneBase = methodZoneBase;
  	oldTrampolineTableIndex = trampolineTableIndex;
  	generateCaptureCStackPointers(1);
  	ceCaptureCStackPointers();
  	if (!((cFramePointerInUse = checkIfCFramePointerInUse()))) {
  		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 fixupSize;
      usqInt methodZoneStart;
      sqInt opcodeSize;
  
  	methodZoneStart = methodZoneBase;
  	(methodLabel->address = methodZoneStart);
  	/* begin allocateOpcodes:bytecodes: */
  	numAbstractOpcodes = 80;
  	opcodeSize = (sizeof(CogAbstractInstruction)) * numAbstractOpcodes;
  	fixupSize = (sizeof(CogBytecodeFixup)) * numAbstractOpcodes;
  	abstractOpcodes = alloca(opcodeSize + fixupSize);
  	bzero(abstractOpcodes, opcodeSize + fixupSize);
  	fixups = ((void *)((((usqInt)abstractOpcodes)) + opcodeSize));
  	zeroOpcodeIndexForNewOpcodes();
  	labelCounter = 0;
  	setHasYoungReferent(0);
  	generateSendTrampolines();
  	generateMissAbortTrampolines();
  	generateObjectRepresentationTrampolines();
  	generateRunTimeTrampolines();
  	generateEnilopmarts();
  	generateTracingTrampolines();
  	recordGeneratedRunTimeaddress("methodZoneBase", methodZoneBase);
  }
  
  	/* Cogit>>#generatorForPC: */
  static BytecodeDescriptor * NoDbgRegParms
  generatorForPC(sqInt pc)
  {
  	return generatorAt(bytecodeSetOffset + (fetchByteofObject(pc, methodObj)));
  }
  
  
  /*	Generate a pair of routines that answer the frame pointer, and the stack
  	pointer immediately
  	after a leaf call, used for checking stack pointer alignment, frame
  	pointer usage, etc. N.B.
  	these are exported to the CoInterpreter et al via Cogit
  	class>>mustBeGlobal:. 
   */
  
  	/* Cogit>>#genGetLeafCallStackPointers */
  static void
  genGetLeafCallStackPointers(void)
  {
      sqInt fixupSize;
      sqInt opcodeSize;
      usqInt startAddress;
  
  	/* begin allocateOpcodes:bytecodes: */
  	numAbstractOpcodes = 4;
  	opcodeSize = (sizeof(CogAbstractInstruction)) * numAbstractOpcodes;
  	fixupSize = (sizeof(CogBytecodeFixup)) * numAbstractOpcodes;
  	abstractOpcodes = alloca(opcodeSize + fixupSize);
  	bzero(abstractOpcodes, opcodeSize + fixupSize);
  	fixups = ((void *)((((usqInt)abstractOpcodes)) + opcodeSize));
  	zeroOpcodeIndexForNewOpcodes();
  	labelCounter = 0;
  	startAddress = methodZoneBase;
  	genoperandoperand(MoveRR, FPReg, ABIResultReg);
  	genoperand(RetN, 0);
  	outputInstructionsForGeneratedRuntimeAt(startAddress);
  	recordGeneratedRunTimeaddress("ceGetFP", startAddress);
  	ceGetFP = ((usqIntptr_t (*)(void)) startAddress);
  	startAddress = methodZoneBase;
  	zeroOpcodeIndex();
  	genoperandoperand(MoveRR, NativeSPReg, ABIResultReg);
  	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 usqInt NoDbgRegParms
  genInnerPICAbortTrampoline(char *name)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *jumpMNUCase;
  
  	/* begin CmpCq:R: */
  	anInstruction = genoperandoperand(CmpCqR, 0 /* picAbortDiscriminatorValue */, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(0 /* picAbortDiscriminatorValue */));
  	}
  	jumpMNUCase = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	compileTrampolineFornumArgsargargargargregsToSavepushLinkRegresultReg(ceInterpretMethodFromPICreceiver, 2, SendNumArgsReg, ReceiverResultReg, null, null, 0 /* emptyRegisterMask */, 0, NoReg);
  	jmpTarget(jumpMNUCase, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(ceMNUFromPICMNUMethodreceiver, name, 2, SendNumArgsReg, ReceiverResultReg, null, null, 0 /* emptyRegisterMask */, 0, NoReg, 1);
  }
  
  
  /*	Switch to the C stack (do *not* save the Smalltalk stack pointers;
  	this is the caller's responsibility), and invoke interpret PDQ. */
  
  	/* Cogit>>#genInvokeInterpretTrampoline */
  static usqInt
  genInvokeInterpretTrampoline(void)
  {
      sqInt address;
      AbstractInstruction *anInstruction;
      sqInt jumpTarget;
      sqInt quickConstant;
      usqInt startAddress;
  
  	startAddress = methodZoneBase;
  	zeroOpcodeIndex();
  	/* begin MoveCq:R: */
  	quickConstant = varBaseAddress();
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(MoveCqR, quickConstant, VarBaseReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(quickConstant));
  	}
  	if (cFramePointerInUse) {
  		genLoadCStackPointers(backEnd);
  	}
  	else {
  		genLoadCStackPointer(backEnd);
  	}
  	genMarshallNArgsargargargarg(backEnd, 0, null, null, null, null);
  	/* begin MoveAw:R: */
  	address = cReturnAddressAddress();
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(address, genoperandoperand(MoveAwR, address, LinkReg));
  	/* begin JumpFull: */
  	jumpTarget = ((usqInt)interpret);
  	/* begin gen:literal: */
  	checkLiteralforInstruction(((sqInt)jumpTarget), genoperand(JumpFull, ((sqInt)jumpTarget)));
  	outputInstructionsForGeneratedRuntimeAt(startAddress);
  	recordGeneratedRunTimeaddress("ceInvokeInterpret", startAddress);
  	return startAddress;
  }
  
  
  /*	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;
      AbstractInstruction *existingInst;
      sqInt i;
      sqInt iLimiT;
      sqInt initialNumLiterals;
      AbstractInstruction * literalInstruction;
      AbstractInstruction *litInst;
      AbstractInstruction *newInst;
      AbstractInstruction *newLiterals;
      sqInt opcode;
      sqInt selector;
  
  	assert((selectorIndex < 0
  		? (((-selectorIndex) >= 1) && ((-selectorIndex) <= (numSpecialSelectors())))
  		: ((selectorIndex >= 0) && (selectorIndex <= ((literalCountOf(methodObj)) - 1)))));
  	selector = (selectorIndex < 0
  		? specialSelector(-1 - selectorIndex)
  		: getLiteral(selectorIndex));
  	assert(addressCouldBeOop(selector));
  	if (isNonImmediate(selector)) {
  		setHasMovableLiteral(1);
  	}
  	if (isYoung(selector)) {
  		setHasYoungReferent(1);
  	}
  	cacheValue = selector;
  	/* begin gen:uniqueLiteral32:operand: */
  	opcode = MoveCwR;
  	/* begin uniqueLiteral32:forInstruction: */
  	anInstruction = genoperandoperand(opcode, cacheValue, ClassReg);
  	assert(usesOutOfLineLiteral(anInstruction));
  	/* begin allocateLiteral: */
  	if (nextLiteralIndex >= literalsSize) {
  		/* begin allocateLiterals: */
  		initialNumLiterals = literalsSize + 8;
  		if (initialNumLiterals > literalsSize) {
  
  			/* Must copy across state (not using realloc, cuz...) and
  			   must also update existing instructions to refer to the new ones...
  			   It's either this or modify all generation routines to be able to retry
  			   with more literals after running out of literals. */
  			newLiterals = calloc(initialNumLiterals, sizeof(CogAbstractInstruction));
  			if (!(literals == null)) {
  				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;
  		}
  	}
  	litInst = literalInstructionAt(nextLiteralIndex);
  	initializeUniqueLiteral(litInst, cacheValue);
  
  	/* Record the opcodeIndex of the first dependent instruction (the first instruction that references an out-of-line literal) */
  	nextLiteralIndex += 1;
  	if (firstOpcodeIndex > opcodeIndex) {
  		firstOpcodeIndex = opcodeIndex - 1;
  	}
  	literalInstruction = litInst;
  	/* begin setLiteralSize: */
  	(anInstruction->dependent = literalInstruction);
  }
  
  	/* Cogit>>#genNonLocalReturnTrampoline */
  static usqInt
  genNonLocalReturnTrampoline(void)
  {
      sqInt address;
  
  	zeroOpcodeIndex();
  	/* begin MoveR:Aw: */
  	address = instructionPointerAddress();
  	/* begin gen:operand:literal: */
  	checkLiteralforInstruction(address, genoperandoperand(MoveRAw, LinkReg, address));
  	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(ceNonLocalReturn, "ceNonLocalReturnTrampoline", 1, ReceiverResultReg, null, null, null, 0 /* emptyRegisterMask */, 0, NoReg, 1);
  }
  
  	/* Cogit>>#genReturnToInterpreterTrampoline */
  static usqInt
  genReturnToInterpreterTrampoline(void)
  {
  	zeroOpcodeIndex();
  	genoperand(PushR, ReceiverResultReg);
  	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(ceEnterInterpreterOnReturnFromCogCode, "ceEnterInterpreterOnReturnFromCogCode", 0, null, null, null, null, 0 /* emptyRegisterMask */, 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 usqInt NoDbgRegParms
  genReturnTrampolineForcalledarg(void *aRoutine, char *aString, sqInt regOrConst0)
  {
  	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(aRoutine, aString, 1, regOrConst0, null, null, null, 0 /* emptyRegisterMask */, 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 usqInt NoDbgRegParms
  genTrampolineForcalled(void *aRoutine, char *aString)
  {
  	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(aRoutine, aString, 0, null, null, null, null, 0 /* emptyRegisterMask */, 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 usqInt NoDbgRegParms
  genTrampolineForcalledarg(void *aRoutine, char *aString, sqInt regOrConst0)
  {
  	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(aRoutine, aString, 1, regOrConst0, null, null, null, 0 /* emptyRegisterMask */, 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 usqInt NoDbgRegParms
  genTrampolineForcalledargargargresult(void *aRoutine, char *aString, sqInt regOrConst0, sqInt regOrConst1, sqInt regOrConst2, sqInt resultReg)
  {
  	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(aRoutine, aString, 3, regOrConst0, regOrConst1, regOrConst2, null, 0 /* emptyRegisterMask */, 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 usqInt 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 usqInt NoDbgRegParms
  genTrampolineForcalledargargresult(void *aRoutine, char *aString, sqInt regOrConst0, sqInt regOrConst1, sqInt resultReg)
  {
  	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(aRoutine, aString, 2, regOrConst0, regOrConst1, null, null, 0 /* emptyRegisterMask */, 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 usqInt 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:regsToSave:result: */
  static usqInt NoDbgRegParms
  genTrampolineForcalledargregsToSaveresult(void *aRoutine, char *aString, sqInt regOrConst0, sqInt regMask, sqInt resultReg)
  {
  	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(aRoutine, aString, 1, regOrConst0, null, null, null, regMask, 1, resultReg, 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 usqInt NoDbgRegParms
  genTrampolineForcalledargresult(void *aRoutine, char *aString, sqInt regOrConst0, sqInt resultReg)
  {
  	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(aRoutine, aString, 1, regOrConst0, null, null, null, 0 /* emptyRegisterMask */, 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 usqInt NoDbgRegParms
  genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(void *aRoutine, char *trampolineName, sqInt numArgs, sqInt regOrConst0, sqInt regOrConst1, sqInt regOrConst2, sqInt regOrConst3, sqInt regMask, sqInt pushLinkReg, sqInt resultRegOrNone, sqInt appendBoolean)
  {
      usqInt startAddress;
  
  	startAddress = methodZoneBase;
  	if (!appendBoolean) {
  		zeroOpcodeIndex();
  	}
  	compileTrampolineFornumArgsargargargargregsToSavepushLinkRegresultReg(aRoutine, numArgs, regOrConst0, regOrConst1, regOrConst2, regOrConst3, regMask, pushLinkReg, resultRegOrNone);
  	outputInstructionsForGeneratedRuntimeAt(startAddress);
  	recordGeneratedRunTimeaddress(trampolineName, startAddress);
  	recordRunTimeObjectReferences();
  	/* begin assertValidDualZoneFrom:to: */
  	
  #  if DUAL_MAPPED_CODE_ZONE
  	assertCoherentCodeAtdelta(backEnd, codeBase + cmNoCheckEntryOffset, codeToDataDelta);
  #  endif /* DUAL_MAPPED_CODE_ZONE */
  	return startAddress;
  }
  
  
  /*	Generate a trampoline with no arguments */
  
  	/* Cogit>>#genTrampolineFor:called:regsToSave: */
  static usqInt NoDbgRegParms
  genTrampolineForcalledregsToSave(void *aRoutine, char *aString, sqInt regMask)
  {
  	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(aRoutine, aString, 0, null, null, null, null, regMask, 1, NoReg, 0);
  }
  
  
  /*	To return from a trampoline call we have to take the return address off
  	the stack,
  	iof it has been saved */
  
  	/* Cogit>>#genTrampolineReturn: */
  static void NoDbgRegParms
  genTrampolineReturn(sqInt lnkRegWasPushed)
  {
  	if (lnkRegWasPushed
  	 && (1)) {
  		genoperand(PopR, PCReg);
  	}
  	else {
  		genoperand(RetN, 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> */
  /*	<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> */
  /*	<Integer|CogAbstractInstruction> */
  /*	<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> */
  /*	<Integer|CogAbstractInstruction> */
  /*	<Integer|CogAbstractInstruction> */
  /*	<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;
  }
  
  	/* Cogit>>#getLiteral: */
  static sqInt NoDbgRegParms
  getLiteral(sqInt litIndex)
  {
  	if (maxLitIndex < litIndex) {
  		maxLitIndex = litIndex;
  	}
  	return literalofMethod(litIndex, methodObj);
  }
  
  
  /*	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 offset1;
      sqInt *sendTable1;
      CogMethod *targetMethod1;
  
  	if (annotation >= IsSendCall) {
  		assert(annotation != IsNSSendCall);
  		entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt)mcpc));
  		if (entryPoint > methodZoneBase) {
  
  			/* It's a linked send. */
  			/* begin targetMethodAndSendTableFor:annotation:into: */
  			if (annotation == IsSendCall) {
  				offset1 = cmEntryOffset;
  				sendTable1 = ordinarySendTrampolines;
  			}
  			else {
  				assert(annotation == IsSuperSend);
  				offset1 = cmNoCheckEntryOffset;
  				sendTable1 = superSendTrampolines;
  			}
  			targetMethod1 = ((CogMethod *) (entryPoint - offset1));
  			if (((targetMethod1->cmUsageCount)) < (CMMaxUsageCount / 2)) {
  				((((CogMethod *) ((((usqInt)targetMethod1)) + codeToDataDelta)))->cmUsageCount = ((targetMethod1->cmUsageCount)) + 1);
  			}
  		}
  	}
  	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) {
  
  		/* Must copy across state (not using realloc, cuz...) and
  		   must also update existing instructions to refer to the new ones...
  		   It's either this or modify all generation routines to be able to retry
  		   with more literals after running out of literals. */
  		newLiterals = calloc(4, sizeof(CogAbstractInstruction));
  		if (!(literals == null)) {
  			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;
  	}
  	/* begin resetLiterals */
  
  	/* an impossibly high value */
  	firstOpcodeIndex = 65536;
  	nextLiteralIndex = (lastDumpedLiteralIndex = 0);
  }
  
  	/* Cogit>>#initializeCodeZoneFrom:upTo: */
  void
  initializeCodeZoneFromupTo(sqInt startAddress, sqInt endAddress)
  {
      sqInt fixupSize;
      sqInt numberOfAbstractOpcodes;
      sqInt opcodeSize;
      usqInt startAddress1;
      sqInt v;
  
  	v = 0;
  	initializeBackend();
  	sqMakeMemoryExecutableFromToCodeToDataDelta(startAddress, endAddress, 
  #  if DUAL_MAPPED_CODE_ZONE
  		(&codeToDataDelta)
  #  else /* DUAL_MAPPED_CODE_ZONE */
  		null
  #  endif /* DUAL_MAPPED_CODE_ZONE */
  		);
  	stopsFromto(backEnd, startAddress, endAddress - 1);
  	codeBase = (methodZoneBase = startAddress);
  	minValidCallAddress = (((((codeBase < (interpretAddress())) ? codeBase : (interpretAddress()))) < (primitiveFailAddress())) ? (((codeBase < (interpretAddress())) ? codeBase : (interpretAddress()))) : (primitiveFailAddress()));
  	/* begin manageFrom:to: */
  	mzFreeStart = (baseAddress = methodZoneBase);
  	youngReferrers = (limitAddress = endAddress);
  	openPICList = null;
  	methodBytesFreedSinceLastCompaction = 0;
  	methodCount = 0;
  	assertValidDualZone();
  	/* begin maybeGenerateCheckFeatures */
  	/* begin maybeGenerateCheckLZCNT */
  	/* begin maybeGenerateCacheFlush */
  	
  #  if DUAL_MAPPED_CODE_ZONE
  	
  #  endif /* DUAL_MAPPED_CODE_ZONE */
  	/* begin generateVMOwnerLockFunctions */
  	
  #  if COGMTVM
  	/* begin allocateOpcodes:bytecodes: */
  	numberOfAbstractOpcodes = numLowLevelLockOpcodes(backEnd);
  	numAbstractOpcodes = numberOfAbstractOpcodes;
  	opcodeSize = (sizeof(CogAbstractInstruction)) * numAbstractOpcodes;
  	fixupSize = (sizeof(CogBytecodeFixup)) * numAbstractOpcodes;
  	abstractOpcodes = alloca(opcodeSize + fixupSize);
  	bzero(abstractOpcodes, opcodeSize + fixupSize);
  	fixups = ((void *)((((usqInt)abstractOpcodes)) + opcodeSize));
  	zeroOpcodeIndexForNewOpcodes();
  	labelCounter = 0;
  	zeroOpcodeIndex();
  	startAddress1 = methodZoneBase;
  	generateLowLevelTryLock(backEnd, vmOwnerLockAddress());
  	outputInstructionsForGeneratedRuntimeAt(startAddress1);
  	recordGeneratedRunTimeaddress("ceTryLockVMOwner", startAddress1);
  	ceTryLockVMOwner = ((usqIntptr_t (*)(void)) startAddress1);
  	zeroOpcodeIndex();
  	initialPC = 0;
  	endPC = numAbstractOpcodes - 1;
  	startAddress1 = methodZoneBase;
  	generateLowLevelUnlock(backEnd, vmOwnerLockAddress());
  	outputInstructionsForGeneratedRuntimeAt(startAddress1);
  	recordGeneratedRunTimeaddress("ceUnlockVMOwner", startAddress1);
  	ceUnlockVMOwner = ((void (*)(void)) startAddress1);
  #  endif /* COGMTVM */
  	genGetLeafCallStackPointers();
  	generateStackPointerCapture();
  	generateTrampolines();
  	computeEntryOffsets();
  	computeFullBlockEntryOffsets();
  	generateClosedPICPrototype();
  	alignMethodZoneBase();
  	maybeFlushWritableZoneFromto(startAddress, ((usqInt)methodZoneBase));
  	/* begin manageFrom:to: */
  	mzFreeStart = (baseAddress = methodZoneBase);
  	youngReferrers = (limitAddress = endAddress);
  	openPICList = null;
  	methodBytesFreedSinceLastCompaction = 0;
  	methodCount = 0;
  	generateOpenPICPrototype();
  }
  
  
  /*	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 (!(primitiveGeneratorOrNil())) {
  		return 2;
  	}
  	return 3;
  }
  
  
  /*	Answer a usage count that reflects likely long-term usage. */
  
  	/* Cogit>>#initialOpenPICUsageCount */
  static sqInt
  initialOpenPICUsageCount(void)
  {
  	return CMMaxUsageCount - 1;
  }
  
  	/* 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;
  }
  
  
  /*	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 genoperand(JumpFPEqual, ((sqInt)jumpTarget));
  }
  
  
  /*	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 genoperand(JumpFPGreaterOrEqual, ((sqInt)jumpTarget));
  }
  
  
  /*	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 genoperand(JumpFPGreater, ((sqInt)jumpTarget));
  }
  
  
  /*	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 genoperand(JumpFPNotEqual, ((sqInt)jumpTarget));
  }
  
  
  /*	destReg := srcReg << quickConstant */
  
  	/* Cogit>>#LogicalShiftLeftCq:R:R: */
  static AbstractInstruction * NoDbgRegParms
  gLogicalShiftLeftCqRR(sqInt quickConstant, sqInt srcReg, sqInt destReg)
  {
      AbstractInstruction * first;
  
  	return genoperandoperandoperand(LogicalShiftLeftCqRR, quickConstant, srcReg, destReg);
  	first = genoperandoperand(MoveRR, srcReg, destReg);
  	genoperandoperand(LogicalShiftLeftCqR, quickConstant, destReg);
  	return first;
  }
  
  	/* 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 extent;
      sqInt inlineCacheTag;
  
  	assert((theEntryOffset == cmEntryOffset)
  	 || (theEntryOffset == cmNoCheckEntryOffset));
  	assert(((callSiteReturnAddress >= methodZoneBase) && (callSiteReturnAddress <= (freeStart()))));
  	if (theEntryOffset == cmNoCheckEntryOffset) {
  
  		/* no need to change selector cache tag */
  		extent = rewriteCallAttarget(backEnd, callSiteReturnAddress, (((sqInt)targetMethod)) + cmNoCheckEntryOffset);
  	}
  	else {
  		inlineCacheTag = inlineCacheTagForInstance(receiver);
  		if (inlineCacheTagIsYoung(inlineCacheTag)) {
  			ensureInYoungReferrers(sendingMethod);
  		}
  		extent = rewriteInlineCacheAttagtarget(backEnd, callSiteReturnAddress, inlineCacheTag, (((sqInt)targetMethod)) + theEntryOffset);
  	}
  	flushICacheFromto(backEnd, (((usqInt)callSiteReturnAddress)) - extent, ((usqInt)callSiteReturnAddress));
  }
  
  	/* Cogit>>#loadBytesAndGetDescriptor */
  static BytecodeDescriptor *
  loadBytesAndGetDescriptor(void)
  {
      BytecodeDescriptor *descriptor;
  
  	byte0 = (fetchByteofObject(bytecodePC, methodObj)) + bytecodeSetOffset;
  	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) {
  					notYetImplemented();
  				}
  			}
  		}
  	}
  }
  
  
  /*	N.B. On certain targets (including X64) this instruction may smash TempReg
  	if the target reg is either FPReg or SPReg.
   */
  
  	/* Cogit>>#MoveAw:R: */
  static AbstractInstruction * NoDbgRegParms
  gMoveAwR(sqInt address, sqInt reg)
  {
  	/* begin gen:literal:operand: */
  	return checkLiteralforInstruction(address, genoperandoperand(MoveAwR, address, reg));
  }
  
  	/* Cogit>>#MoveCw:R: */
  static AbstractInstruction * NoDbgRegParms
  gMoveCwR(sqInt wordConstant, sqInt reg)
  {
  	/* begin gen:literal:operand: */
  	return checkLiteralforInstruction(wordConstant, genoperandoperand(MoveCwR, wordConstant, reg));
  }
  
  	/* Cogit>>#MoveMw:r:R: */
  static AbstractInstruction * NoDbgRegParms
  gMoveMwrR(sqInt offset, sqInt baseReg, sqInt destReg)
  {
      AbstractInstruction *anInstruction;
  
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperandoperand(MoveMwrR, offset, baseReg, destReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(offset));
  	}
  	return anInstruction;
  }
  
  
  /*	Answer the address of the null byte at the end of the method map. */
  
  	/* Cogit>>#mapEndFor: */
  static usqInt NoDbgRegParms
  mapEndFor(CogMethod *cogMethod)
  {
      usqInt end;
  
  	end = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
  	while ((byteAt(end)) != MapEnd) {
  		end -= 1;
  		assert(end > (firstMappedPCFor(cogMethod)));
  	}
  	return end;
  }
  
  
  /*	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 = (((usqInt)cogMethod)) + cmNoCheckEntryOffset;
  	map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
  	while (((mapByte = byteAt(map))) != MapEnd) {
  		if (mapByte >= FirstAnnotation) {
  
  			/* If this is an IsSendCall annotation, peek ahead for an IsAnnotationExtension, and consume it. */
  			mcpc += (mapByte & DisplacementMask) * 4 /* codeGranularity */;
  			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 < (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift)))) {
  				mcpc += (((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))) * 4 /* codeGranularity */;
  			}
  		}
  		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;
  
  
  	/* first we check the potential method oop load at the beginning of the CPIC */
  	pc = addressOfEndOfCaseinCPIC(1, cPIC);
  
  	/* We find the end address of the cPICNumCases'th case and can then just step forward by the case size thereafter */
  	refersToYoung = remapMaybeObjRefInClosedPICAt(pc - 4 /* jumpLongByteSize */);
  
  	/* Next we check the potential class ref in the compare instruction, and the potential method oop load for each case. */
  	pc = addressOfEndOfCaseinCPIC((cPIC->cPICNumCases), cPIC);
  	for (i = 2; i <= ((cPIC->cPICNumCases)); i += 1) {
  		if (remapMaybeObjRefInClosedPICAt(pc - (jumpLongConditionalByteSize(backEnd)))) {
  			refersToYoung = 1;
  		}
  		if (remapMaybeObjRefInClosedPICAt((pc - (jumpLongConditionalByteSize(backEnd))) - 8 /* cmpC32RTempByteSize */)) {
  			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 = longAt(mcpc);
  		mappedLiteral = remapObject(literal);
  		if (mappedLiteral != literal) {
  			/* begin storeLiteral:atAnnotatedAddress:using: */
  			codeLongAtput(mcpc, mappedLiteral);
  			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;
      sqInt freedPIC;
      sqInt hasYoungObj;
      sqInt hasYoungObjPtr;
      usqInt map;
      sqInt mapByte;
      sqInt mcpc;
      sqInt remappedMethod;
      sqInt result;
      sqInt val;
      CogMethod * writableCogMethod;
  
  	val = 0;
  	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);
  			writableCogMethod = ((CogMethod *) ((((usqInt)cogMethod)) + codeToDataDelta));
  			(writableCogMethod->selector = remapOop((cogMethod->selector)));
  			if (((cogMethod->cmType)) == CMClosedPIC) {
  				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));
  							(writableCogMethod->methodHeader = rawHeaderOf(remappedMethod));
  							(writableCogMethod->methodObject = remappedMethod);
  							rawHeaderOfput(remappedMethod, ((sqInt)cogMethod));
  						}
  						else {
  							assert((noAssertMethodClassAssociationOf((cogMethod->methodObject))) == (nilObject()));
  							(writableCogMethod->methodHeader = rawHeaderOf(remappedMethod));
  							(writableCogMethod->methodObject = remappedMethod);
  						}
  					}
  					if (isYoung((cogMethod->methodObject))) {
  						hasYoungObj = 1;
  					}
  				}
  				/* begin mapFor:performUntil:arg: */
  				mcpc = (((usqInt)cogMethod)) + cmNoCheckEntryOffset;
  				map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
  				while (((mapByte = byteAt(map))) != MapEnd) {
  					if (mapByte >= FirstAnnotation) {
  
  						/* If this is an IsSendCall annotation, peek ahead for an IsAnnotationExtension, and consume it. */
  						mcpc += (mapByte & DisplacementMask) * 4 /* codeGranularity */;
  						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 l2;
  						}
  					}
  					else {
  						if (mapByte < (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift)))) {
  							mcpc += (((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))) * 4 /* codeGranularity */;
  						}
  					}
  					map -= 1;
  				}
  	l2:	/* end mapFor:performUntil:arg: */;
  				if (hasYoungObj) {
  					ensureInYoungReferrers(cogMethod);
  					hasYoungObj = 0;
  				}
  				else {
  					(cogMethod->cmRefersToYoung = 0);
  				}
  			}
  		}
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  	pruneYoungReferrers();
  	if (freedPIC) {
  		unlinkSendsToFree();
  	}
  	if (codeModified) {
  
  		/* After updating oops in inline caches we need to flush the icache. */
  		flushICacheFromto(backEnd, ((usqInt)codeBase), ((usqInt)(limitZony())));
  	}
  }
  
  
  /*	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;
      CogMethod * writableCogMethod;
  
  	codeModified = 0;
  	mapObjectReferencesInGeneratedRuntime();
  	cogMethod = ((CogMethod *) methodZoneBase);
  	while (cogMethod < (limitZony())) {
  		if (((cogMethod->cmType)) != CMFree) {
  			assert((cogMethodDoesntLookKosher(cogMethod)) == 0);
  			writableCogMethod = ((CogMethod *) ((((usqInt)cogMethod)) + codeToDataDelta));
  			(writableCogMethod->selector = remapOop((cogMethod->selector)));
  			if (((cogMethod->cmType)) == CMClosedPIC) {
  				assert(!((cogMethod->cmRefersToYoung)));
  				mapObjectReferencesInClosedPIC(cogMethod);
  			}
  			else {
  				if (((cogMethod->cmType)) == CMMethod) {
  					assert(((cogMethod->objectHeader)) == (nullHeaderForMachineCodeMethod()));
  					(writableCogMethod->methodObject = remapOop((cogMethod->methodObject)));
  				}
  				/* begin mapFor:performUntil:arg: */
  				mcpc = (((usqInt)cogMethod)) + cmNoCheckEntryOffset;
  				map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
  				while (((mapByte = byteAt(map))) != MapEnd) {
  					if (mapByte >= FirstAnnotation) {
  
  						/* If this is an IsSendCall annotation, peek ahead for an IsAnnotationExtension, and consume it. */
  						mcpc += (mapByte & DisplacementMask) * 4 /* codeGranularity */;
  						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 l2;
  						}
  					}
  					else {
  						if (mapByte < (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift)))) {
  							mcpc += (((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))) * 4 /* codeGranularity */;
  						}
  					}
  					map -= 1;
  				}
  	l2:	/* end mapFor:performUntil:arg: */;
  				if (((cogMethod->cmRefersToYoung))
  				 && (1)) {
  					(writableCogMethod->cmRefersToYoung = 0);
  				}
  			}
  		}
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  	pruneYoungReferrers();
  	if (codeModified) {
  
  		/* After updating oops in inline caches we need to flush the icache. */
  		flushICacheFromto(backEnd, ((usqInt)codeBase), ((usqInt)(limitZony())));
  	}
  }
  
  
  /*	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;
      CogMethod * writableCogMethod;
  
  	val = 0;
  	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)) == CMOpenPIC));
  				writableCogMethod = ((CogMethod *) ((((usqInt)cogMethod)) + codeToDataDelta));
  				(writableCogMethod->selector = remapOop((cogMethod->selector)));
  				if (isYoung((cogMethod->selector))) {
  					hasYoungObj = 1;
  				}
  				if (((cogMethod->cmType)) == CMMethod) {
  					assert(((cogMethod->objectHeader)) == (nullHeaderForMachineCodeMethod()));
  					(writableCogMethod->methodObject = remapOop((cogMethod->methodObject)));
  					if (isYoung((cogMethod->methodObject))) {
  						hasYoungObj = 1;
  					}
  				}
  				/* begin mapFor:performUntil:arg: */
  				mcpc = (((usqInt)cogMethod)) + cmNoCheckEntryOffset;
  				map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
  				while (((mapByte = byteAt(map))) != MapEnd) {
  					if (mapByte >= FirstAnnotation) {
  
  						/* If this is an IsSendCall annotation, peek ahead for an IsAnnotationExtension, and consume it. */
  						mcpc += (mapByte & DisplacementMask) * 4 /* codeGranularity */;
  						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 l2;
  						}
  					}
  					else {
  						if (mapByte < (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift)))) {
  							mcpc += (((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))) * 4 /* codeGranularity */;
  						}
  					}
  					map -= 1;
  				}
  	l2:	/* end mapFor:performUntil:arg: */;
  				if (hasYoungObj) {
  					hasYoungObj = 0;
  				}
  				else {
  					(writableCogMethod->cmRefersToYoung = 0);
  				}
  			}
  		}
  		pointer += BytesPerWord;
  	}
  	pruneYoungReferrers();
  	if (codeModified) {
  
  		/* After updating oops in inline caches we need to flush the icache. */
  		flushICacheFromto(backEnd, ((usqInt)methodZoneBase), ((usqInt)(limitZony())));
  	}
  }
  
  
  /*	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");
  	}
  }
  
  
  /*	Free any methods that refer to unmarked objects, unlinking sends to freed
  	methods. 
   */
  
  	/* Cogit>>#markAndTraceMachineCodeForNewSpaceGC */
  static void
  markAndTraceMachineCodeForNewSpaceGC(void)
  {
      sqInt annotation;
      CogMethod *cogMethod;
      usqInt map;
      sqInt mapByte;
      sqInt mcpc;
      usqInt pointer;
      sqInt result;
  
  	if (leakCheckNewSpaceGC()) {
  		asserta(allMachineCodeObjectReferencesValid());
  	}
  	codeModified = 0;
  	pointer = youngReferrers();
  	while (pointer < limitAddress) {
  		cogMethod = ((CogMethod *) (longAt(pointer)));
  		if ((cogMethod->cmRefersToYoung)) {
  			assert((cogMethodDoesntLookKosher(cogMethod)) == 0);
  			assert((((cogMethod->cmType)) == CMMethod)
  			 || (((cogMethod->cmType)) == CMOpenPIC));
  			if (isYoung((cogMethod->selector))) {
  				markAndTrace((cogMethod->selector));
  			}
  			if (((cogMethod->cmType)) == CMMethod) {
  				if (isYoung((cogMethod->methodObject))) {
  					markAndTrace((cogMethod->methodObject));
  				}
  				/* begin markYoungObjectsIn: */
  				assert((((cogMethod->cmType)) == CMMethod)
  				 || (((cogMethod->cmType)) == CMOpenPIC));
  				if (isYoung((cogMethod->selector))) {
  					markAndTrace((cogMethod->selector));
  				}
  				if ((((cogMethod->cmType)) == CMMethod)
  				 && (isYoung((cogMethod->methodObject)))) {
  					markAndTrace((cogMethod->methodObject));
  				}
  				/* begin mapFor:performUntil:arg: */
  				mcpc = (((usqInt)cogMethod)) + cmNoCheckEntryOffset;
  				map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
  				while (((mapByte = byteAt(map))) != MapEnd) {
  					if (mapByte >= FirstAnnotation) {
  
  						/* If this is an IsSendCall annotation, peek ahead for an IsAnnotationExtension, and consume it. */
  						mcpc += (mapByte & DisplacementMask) * 4 /* codeGranularity */;
  						if ((((annotation = ((usqInt)(mapByte)) >> AnnotationShift)) == IsSendCall)
  						 && ((((usqInt)(((mapByte = byteAt(map - 1))))) >> AnnotationShift) == IsAnnotationExtension)) {
  							annotation += mapByte & DisplacementMask;
  							map -= 1;
  						}
  						result = markYoungObjectspcmethod(annotation, (((char *) mcpc)), (((sqInt)cogMethod)));
  						if (result != 0) {
  							goto l2;
  						}
  					}
  					else {
  						if (mapByte < (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift)))) {
  							mcpc += (((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))) * 4 /* codeGranularity */;
  						}
  					}
  					map -= 1;
  				}
  	l2:	/* end mapFor:performUntil:arg: */;
  			}
  		}
  		pointer += BytesPerWord;
  	}
  	if (leakCheckNewSpaceGC()) {
  		asserta(allMachineCodeObjectReferencesValid());
  	}
  	if (codeModified) {
  
  		/* After updating oops in inline caches we need to flush the icache. */
  		flushICacheFromto(backEnd, ((usqInt)methodZoneBase), ((usqInt)(limitZony())));
  	}
  }
  
  
  /*	Mark and trace any object references in the generated run-time. */
  
  	/* Cogit>>#markAndTraceObjectReferencesInGeneratedRuntime */
  static void
  markAndTraceObjectReferencesInGeneratedRuntime(void)
  {
      usqInt address;
      CogMethod *cogMethodOrNil;
      sqInt i;
      sqInt literal;
      usqInt mcpc;
  
  	for (i = 0; i < runtimeObjectRefIndex; i += 1) {
  		mcpc = objectReferencesInRuntime[i];
  		literal = longAt(mcpc);
  		/* begin markAndTraceLiteral:in:atpc: */
  		cogMethodOrNil = ((CogMethod *) null);
  		address = ((usqInt)mcpc);
  		markAndTraceLiteral(literal);
  	}
  }
  
  	/* Cogit>>#markAndTraceObjectsOrFreeMachineCode: */
  void
  markAndTraceObjectsOrFreeMachineCode(sqInt inFullGC)
  {
  	if (inFullGC) {
  		markAndTraceOrFreeMachineCodeForFullGC();
  	}
  	else {
  		markAndTraceMachineCodeForNewSpaceGC();
  	}
  }
  
  
  /*	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 *address;
      sqInt annotation;
      sqInt literal;
      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 (!(isMarked((cogMethod->methodObject)))) {
  			freeMethod(cogMethod);
  			return 1;
  		}
  		if (firstVisit) {
  			/* begin markLiteralsAndUnlinkUnmarkedSendsIn: */
  			assert(((cogMethod->cmType)) == CMMethod);
  			assert(isMarked((cogMethod->methodObject)));
  			/* begin markAndTraceLiteral:in:at: */
  			literal = (cogMethod->selector);
  			address = (&((cogMethod->selector)));
  			markAndTraceLiteral(literal);
  			/* begin maybeMarkIRCsIn: */
  			/* begin mapFor:performUntil:arg: */
  			mcpc = (((usqInt)cogMethod)) + cmNoCheckEntryOffset;
  			map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
  			while (((mapByte = byteAt(map))) != MapEnd) {
  				if (mapByte >= FirstAnnotation) {
  
  					/* If this is an IsSendCall annotation, peek ahead for an IsAnnotationExtension, and consume it. */
  					mcpc += (mapByte & DisplacementMask) * 4 /* codeGranularity */;
  					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 l2;
  					}
  				}
  				else {
  					if (mapByte < (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift)))) {
  						mcpc += (((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))) * 4 /* codeGranularity */;
  					}
  				}
  				map -= 1;
  			}
  	l2:	/* end mapFor:performUntil:arg: */;
  		}
  		return 0;
  	}
  	if (((cogMethod->cmType)) == CMClosedPIC) {
  		if (!(closedPICRefersToUnmarkedObject(cogMethod))) {
  			return 0;
  		}
  		freeMethod(cogMethod);
  		return 1;
  	}
  	if (((cogMethod->cmType)) == CMOpenPIC) {
  		if (isMarked((cogMethod->selector))) {
  			return 0;
  		}
  		freeMethod(cogMethod);
  		return 1;
  	}
  	assert((((cogMethod->cmType)) == CMMethod)
  	 || ((((cogMethod->cmType)) == CMClosedPIC)
  	 || (((cogMethod->cmType)) == CMOpenPIC)));
  	return 0;
  }
  
  
  /*	Free any methods that refer to unmarked objects, unlinking sends to freed
  	methods. 
   */
  
  	/* Cogit>>#markAndTraceOrFreeMachineCodeForFullGC */
  static void
  markAndTraceOrFreeMachineCodeForFullGC(void)
  {
      CogMethod *cogMethod;
  
  	if (leakCheckFullGC()) {
  		asserta(allMachineCodeObjectReferencesValid());
  	}
  	codeModified = 0;
  	markAndTraceObjectReferencesInGeneratedRuntime();
  	cogMethod = ((CogMethod *) methodZoneBase);
  	while (cogMethod < (limitZony())) {
  		markAndTraceOrFreeCogMethodfirstVisit(cogMethod, 1);
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  	if (leakCheckFullGC()) {
  		asserta(allMachineCodeObjectReferencesValid());
  	}
  	if (codeModified) {
  
  		/* After updating oops in inline caches we need to flush the icache. */
  		flushICacheFromto(backEnd, ((usqInt)methodZoneBase), ((usqInt)(limitZony())));
  	}
  }
  
  
  /*	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)
  {
      sqInt *address;
      sqInt cacheTag1;
      sqInt cacheTagMarked;
      sqInt entryPoint1;
      sqInt literal;
      sqInt literal1;
      sqInt offset1;
      sqInt *sendTable1;
      sqInt tagCouldBeObj1;
      CogMethod *targetMethod1;
      sqInt unlinkedRoutine;
      sqInt val;
  
  	literal = 0;
  	val = 0;
  	if (annotation == IsObjectReference) {
  		literal = longAt(((usqInt)mcpc));
  		markAndTraceLiteral(literal);
  		codeModified = 1;
  	l1:	;
  	}
  	if (annotation >= IsSendCall) {
  		/* begin entryCacheTagAndCouldBeObjectAt:annotation:into: */
  		cacheTag1 = longAt(pcRelativeAddressAt(backEnd, ((usqInt)((((sqInt)mcpc)) - 8))));
  
  		/* in-line cache tags are the selectors of sends if sends are unlinked,
  		   the selectors of super sends (entry offset = cmNoCheckEntryOffset),
  		   the selectors of open PIC sends (entry offset = cmEntryOffset, target is an Open PIC)
  		   or in-line cache tags (classes, class indices, immediate bit patterns, etc).
  		   Note that selectors can be immediate so there is no guarantee that they
  		   are markable/remappable objects. */
  		entryPoint1 = callTargetFromReturnAddress(backEnd, ((sqInt)mcpc));
  		tagCouldBeObj1 = 1;
  		cacheTagMarked = tagCouldBeObj1
  		 && (cacheTagIsMarked(cacheTag1));
  		if (entryPoint1 > methodZoneBase) {
  
  			/* It's a linked send. */
  			/* begin targetMethodAndSendTableFor:annotation:into: */
  			if (annotation == IsSendCall) {
  				offset1 = cmEntryOffset;
  				sendTable1 = ordinarySendTrampolines;
  			}
  			else {
  				assert(annotation == IsSuperSend);
  				offset1 = cmNoCheckEntryOffset;
  				sendTable1 = superSendTrampolines;
  			}
  			targetMethod1 = ((CogMethod *) (entryPoint1 - offset1));
  			if ((!cacheTagMarked)
  			 || (markAndTraceOrFreeCogMethodfirstVisit(targetMethod1, (((usqInt)targetMethod1)) > (((usqInt)mcpc))))) {
  
  				/* Either the cacheTag is unmarked (e.g. new class) or the target
  				   has been freed (because it is unmarked), so unlink the send. */
  				/* begin unlinkSendAt:targetMethod:sendTable: */
  				unlinkedRoutine = sendTable1[((((targetMethod1->cmNumArgs)) < (NumSendTrampolines - 1)) ? ((targetMethod1->cmNumArgs)) : (NumSendTrampolines - 1))];
  				rewriteInlineCacheAttagtarget(backEnd, ((sqInt)mcpc), inlineCacheValueForSelectorin(backEnd, (targetMethod1->selector), enumeratingCogMethod), unlinkedRoutine);
  				codeModified = 1;
  				/* begin markAndTraceLiteral:in:at: */
  				literal1 = (targetMethod1->selector);
  				address = (&((targetMethod1->selector)));
  				markAndTraceLiteral(literal1);
  			}
  		}
  		else {
  
  			/* cacheTag is selector */
  			markAndTraceLiteral(cacheTag1);
  			codeModified = 1;
  	l3:	;
  		}
  	}
  	return 0;
  }
  
  	/* Cogit>>#markMethodAndReferents: */
  void
  markMethodAndReferents(CogBlockMethod *aCogMethod)
  {
      sqInt annotation;
      CogMethod * cogMethod;
      usqInt map;
      sqInt mapByte;
      sqInt mcpc;
      sqInt result;
      CogMethod * writableMethod;
  
  	assert((((aCogMethod->cmType)) == CMMethod)
  	 || (((aCogMethod->cmType)) == CMBlock));
  	cogMethod = (((aCogMethod->cmType)) == CMMethod
  		? ((CogMethod *) aCogMethod)
  		: cmHomeMethod(aCogMethod));
  	writableMethod = ((CogMethod *) ((((usqInt)cogMethod)) + codeToDataDelta));
  	(writableMethod->cmUsageCount = CMMaxUsageCount);
  	/* begin mapFor:performUntil:arg: */
  	mcpc = (((usqInt)cogMethod)) + cmNoCheckEntryOffset;
  	map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
  	while (((mapByte = byteAt(map))) != MapEnd) {
  		if (mapByte >= FirstAnnotation) {
  
  			/* If this is an IsSendCall annotation, peek ahead for an IsAnnotationExtension, and consume it. */
  			mcpc += (mapByte & DisplacementMask) * 4 /* codeGranularity */;
  			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 l2;
  			}
  		}
  		else {
  			if (mapByte < (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift)))) {
  				mcpc += (((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))) * 4 /* codeGranularity */;
  			}
  		}
  		map -= 1;
  	}
  	l2:	/* end mapFor:performUntil:arg: */;
  }
  
  
  /*	Mark and trace young literals. */
  
  	/* Cogit>>#markYoungObjects:pc:method: */
  static sqInt NoDbgRegParms
  markYoungObjectspcmethod(sqInt annotation, char *mcpc, sqInt cogMethod)
  {
      sqInt cacheTag1;
      sqInt entryPoint1;
      sqInt literal;
      sqInt tagCouldBeObj1;
  
  	if (annotation == IsObjectReference) {
  		literal = longAt(((usqInt)mcpc));
  		markAndTraceLiteralIfYoung(literal);
  	}
  	if (annotation >= IsSendCall) {
  		/* begin entryCacheTagAndCouldBeObjectAt:annotation:into: */
  		cacheTag1 = longAt(pcRelativeAddressAt(backEnd, ((usqInt)((((sqInt)mcpc)) - 8))));
  
  		/* in-line cache tags are the selectors of sends if sends are unlinked,
  		   the selectors of super sends (entry offset = cmNoCheckEntryOffset),
  		   the selectors of open PIC sends (entry offset = cmEntryOffset, target is an Open PIC)
  		   or in-line cache tags (classes, class indices, immediate bit patterns, etc).
  		   Note that selectors can be immediate so there is no guarantee that they
  		   are markable/remappable objects. */
  		entryPoint1 = callTargetFromReturnAddress(backEnd, ((sqInt)mcpc));
  		tagCouldBeObj1 = 1;
  		if (tagCouldBeObj1) {
  			markAndTraceLiteralIfYoung(cacheTag1);
  		}
  	}
  	return 0;
  }
  
  	/* Cogit>>#maxCogMethodAddress */
  usqInt
  maxCogMethodAddress(void)
  {
  	return ((usqInt)(limitZony()));
  }
  
  
  /*	If this is the Newspeak VM and the objectRepresentation supports pinning
  	then allocate space for the implicit receiver caches on the heap. */
  
  	/* Cogit>>#maybeAllocAndInitIRCs */
  static sqInt
  maybeAllocAndInitIRCs(void)
  {
  	return 1;
  }
  
  
  /*	If there is a dual mapped code zone (the normal zone but marked with
  	read/execute, and a read/write zone codeToDataDelta bytes away) then the
  	data cache for the read/write
  	zone must be flushed, and the data cache for the read/execute zone must be
  	invalidated, for the Cogit to see the same values in both zones after a
  	write to the read/write zone. */
  
  	/* Cogit>>#maybeFlushWritableZoneFrom:to: */
  static void NoDbgRegParms
  maybeFlushWritableZoneFromto(usqInt startAddress, usqInt endAddress)
  {
  	if (codeToDataDelta > 0) {
  		flushDCacheFromto(backEnd, startAddress, endAddress);
  	}
  }
  
  
  /*	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);
  }
  
  	/* Cogit>>#mclassIsSmallInteger */
  static sqInt
  mclassIsSmallInteger(void)
  {
  	return (receiverTags & 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 block or method object. */
  
  	/* Cogit>>#mcPCForBackwardBranch:startBcpc:in: */
  usqInt
  mcPCForBackwardBranchstartBcpcin(sqInt bcpc, sqInt startbcpc, CogBlockMethod *cogMethod)
  {
      sqInt aMethodHeader;
      sqInt aMethodHeader1;
      sqInt aMethodObj;
      sqInt annotation;
      sqInt bcpc1;
      sqInt bsOffset;
      sqInt byte;
      BytecodeDescriptor *descriptor;
      sqInt distance;
      sqInt endbcpc;
      CogMethod *homeMethod;
      sqInt isBackwardBranch;
      sqInt isInBlock;
      sqInt latestContinuation;
      usqInt map;
      sqInt mapByte;
      usqInt mcpc;
      sqInt nExts;
      sqInt nextBcpc;
      sqInt result;
      sqInt targetPC;
  
  	latestContinuation = 0;
  	/* begin mapFor:bcpc:performUntil:arg: */
  	assert(((cogMethod->stackCheckOffset)) > 0);
  
  	/* The stack check maps to the start of the first bytecode,
  	   the first bytecode being effectively after frame build. */
  	mcpc = (((usqInt)cogMethod)) + ((cogMethod->stackCheckOffset));
  	result = (((0 + (((int)((usqInt)(HasBytecodePC) << 1)))) & 1)
  	 && ((((sqInt)(((void *)bcpc)))) == startbcpc)
  		? ((sqInt)(((char *) mcpc)))
  		: 0);
  	if (result != 0) {
  		return result;
  	}
  
  	/* In both CMMethod and CMBlock cases find the start of the map and
  	   skip forward to the bytecode pc map entry for the stack check. */
  	bcpc1 = startbcpc;
  	if (((cogMethod->cmType)) == CMMethod) {
  		/* begin cmIsFullBlock */
  		isInBlock = 0;
  		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;
  		/* begin bytecodeSetOffsetForHeader: */
  		aMethodHeader = (homeMethod->methodHeader);
  		bsOffset = 
  #    if MULTIPLEBYTECODESETS
  			(headerIndicatesAlternateBytecodeSet(aMethodHeader)
  						? 256
  						: 0)
  #    else /* MULTIPLEBYTECODESETS */
  			0
  #    endif /* MULTIPLEBYTECODESETS */
  			;
  		bcpc1 += deltaToSkipPrimAndErrorStoreInheader(aMethodObj, (homeMethod->methodHeader));
  	}
  	else {
  		isInBlock = 1;
  		assert(bcpc1 == ((cogMethod->startpc)));
  		homeMethod = cmHomeMethod(cogMethod);
  		map = findMapLocationForMcpcinMethod((((usqInt)cogMethod)) + (sizeof(CogBlockMethod)), homeMethod);
  		assert(map != 0);
  		annotation = ((usqInt)((byteAt(map)))) >> AnnotationShift;
  		assert(((((usqInt)(annotation)) >> AnnotationShift) == HasBytecodePC)
  		 || ((((usqInt)(annotation)) >> AnnotationShift) == IsDisplacementX2N));
  		while (((annotation = ((usqInt)((byteAt(map)))) >> AnnotationShift)) != HasBytecodePC) {
  			map -= 1;
  		}
  
  		/* skip fiducial; i.e. the map entry for the pc immediately following the method header. */
  		map -= 1;
  		aMethodObj = (homeMethod->methodObject);
  		bcpc1 = startbcpc - (
  #if MULTIPLEBYTECODESETS
  	(headerIndicatesAlternateBytecodeSet((homeMethod->methodHeader))
  		? AltBlockCreationBytecodeSize
  		: BlockCreationBytecodeSize)
  #else /* MULTIPLEBYTECODESETS */
  	BlockCreationBytecodeSize
  #endif /* MULTIPLEBYTECODESETS */
  	);
  		/* begin bytecodeSetOffsetForHeader: */
  		aMethodHeader1 = (homeMethod->methodHeader);
  		bsOffset = 
  #    if MULTIPLEBYTECODESETS
  			(headerIndicatesAlternateBytecodeSet(aMethodHeader1)
  						? 256
  						: 0)
  #    else /* MULTIPLEBYTECODESETS */
  			0
  #    endif /* MULTIPLEBYTECODESETS */
  			;
  		byte = (fetchByteofObject(bcpc1, aMethodObj)) + bsOffset;
  		descriptor = generatorAt(byte);
  		endbcpc = (bcpc1 + ((descriptor->numBytes))) + (((descriptor->isBlockCreation)
  	? (/* begin spanFor:at:exts:in: */
  		((descriptor->spanFunction))(descriptor, bcpc1, -1, aMethodObj))
  	: 0));
  		bcpc1 = startbcpc;
  	}
  	nExts = 0;
  	while ((((usqInt)((byteAt(map)))) >> AnnotationShift) != HasBytecodePC) {
  		map -= 1;
  	}
  	map -= 1;
  	while (((mapByte = byteAt(map))) != MapEnd) {
  
  		/* defensive; we exit on bcpc */
  		if (mapByte >= FirstAnnotation) {
  			annotation = ((usqInt)(mapByte)) >> AnnotationShift;
  			mcpc += (mapByte & DisplacementMask) * 4 /* codeGranularity */;
  			if (annotation >= HasBytecodePC) {
  				if ((annotation == IsSendCall)
  				 && ((((usqInt)(((mapByte = byteAt(map - 1))))) >> AnnotationShift) == IsAnnotationExtension)) {
  					annotation += mapByte & DisplacementMask;
  					map -= 1;
  				}
  				while (1) {
  					byte = (fetchByteofObject(bcpc1, aMethodObj)) + bsOffset;
  					descriptor = generatorAt(byte);
  					if (isInBlock) {
  						if (bcpc1 >= endbcpc) {
  							return 0;
  						}
  					}
  					else {
  						if (((descriptor->isReturn))
  						 && (bcpc1 >= latestContinuation)) {
  							return 0;
  						}
  						if ((isBranch(descriptor))
  						 || ((descriptor->isBlockCreation))) {
  							/* begin latestContinuationPCFor:at:exts:in: */
  							distance = ((descriptor->spanFunction))(descriptor, bcpc1, nExts, aMethodObj);
  							targetPC = (bcpc1 + ((descriptor->numBytes))) + (((distance < 0) ? 0 : distance));
  							latestContinuation = ((latestContinuation < targetPC) ? targetPC : latestContinuation);
  						}
  						/* latestContinuation = */ latestContinuation;
  					}
  					nextBcpc = (bcpc1 + ((descriptor->numBytes))) + (((descriptor->isBlockCreation)
  	? (/* begin spanFor:at:exts:in: */
  		((descriptor->spanFunction))(descriptor, bcpc1, nExts, aMethodObj))
  	: 0));
  					if (((descriptor->isMapped))
  					 || (isInBlock
  					 && ((descriptor->isMappedInBlock)))) break;
  					bcpc1 = nextBcpc;
  					nExts = ((descriptor->isExtension)
  						? nExts + 1
  						: 0);
  				}
  				isBackwardBranch = (isBranch(descriptor))
  				 && ((assert(((descriptor->spanFunction)) != null),
  				(((descriptor->spanFunction))(descriptor, bcpc1, nExts, aMethodObj)) < 0));
  				result = findBackwardBranchIsBackwardBranchMcpcBcpcMatchingBcpc(descriptor, ((isBackwardBranch
  	? (((sqInt)((usqInt)(annotation) << 1))) + 1
  	: ((sqInt)((usqInt)(annotation) << 1)))), (((char *) mcpc)), ((isBackwardBranch
  	? bcpc1 - (2 * nExts)
  	: bcpc1)), (((void *)bcpc)));
  				if (result != 0) {
  					return result;
  				}
  				bcpc1 = nextBcpc;
  				nExts = ((descriptor->isExtension)
  					? nExts + 1
  					: 0);
  			}
  		}
  		else {
  			assert(((((usqInt)(mapByte)) >> AnnotationShift) == IsDisplacementX2N)
  			 || ((((usqInt)(mapByte)) >> AnnotationShift) == IsAnnotationExtension));
  			if (mapByte < (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift)))) {
  				mcpc += (((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))) * 4 /* codeGranularity */;
  			}
  		}
  		map -= 1;
  	}
  	return 0;
  }
  
  
  /*	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 */
  usqInt
  minCogMethodAddress(void)
  {
  	return methodZoneBase;
  }
  
  	/* Cogit>>#mnuOffset */
  sqInt
  mnuOffset(void)
  {
  	return missOffset;
  }
  
  	/* Cogit>>#NativePopR: */
  static AbstractInstruction * NoDbgRegParms
  gNativePopR(sqInt reg)
  {
  	return genoperand(PopR, reg);
  }
  
  	/* Cogit>>#NativePushR: */
  static AbstractInstruction * NoDbgRegParms
  gNativePushR(sqInt reg)
  {
  	return genoperand(PushR, reg);
  }
  
  	/* Cogit>>#NativeRetN: */
  static AbstractInstruction * NoDbgRegParms
  gNativeRetN(sqInt offset)
  {
  	return genoperand(RetN, offset);
  }
  
  	/* 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 *) (roundUpToMethodAlignment(backEnd(), (((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));
  }
  
  	/* Cogit>>#OrCq:R:R: */
  static AbstractInstruction * NoDbgRegParms
  gOrCqRR(sqInt quickConstant, sqInt srcReg, sqInt destReg)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction2;
      AbstractInstruction * first;
  
  	/* begin gen:quickConstant:operand:operand: */
  	anInstruction = genoperandoperandoperand(OrCqRR, quickConstant, srcReg, destReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(quickConstant));
  	}
  	return anInstruction;
  	if (srcReg == destReg) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction1 = genoperandoperand(OrCqR, quickConstant, destReg);
  		if (usesOutOfLineLiteral(anInstruction1)) {
  			(anInstruction1->dependent = locateLiteral(quickConstant));
  		}
  		return anInstruction1;
  	}
  	first = genoperandoperand(MoveRR, srcReg, destReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction2 = genoperandoperand(OrCqR, quickConstant, destReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(quickConstant));
  	}
  	return first;
  }
  
  
  /*	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) {
  			longAtput(absoluteAddress + j, ((abstractInstruction->machineCode))[j / 4]);
  		}
  		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));
  }
  
  
  /*	Code entry closed 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 open 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>>#patchToOpenPICFor:numArgs:receiver: */
  sqInt
  patchToOpenPICFornumArgsreceiver(sqInt selector, sqInt numArgs, sqInt receiver)
  {
      sqInt extent;
      CogMethod *oPIC;
      sqInt outerReturn;
  
  
  	/* See if an Open PIC is already available. */
  	outerReturn = stackTop();
  	oPIC = openPICWithSelector(selector);
  	if (!(oPIC)) {
  
  		/* otherwise attempt to create an Open PIC. */
  		oPIC = cogOpenPICSelectornumArgs(selector, numArgs);
  		if ((((((sqInt)oPIC)) >= MaxNegativeErrorCode) && ((((sqInt)oPIC)) <= -1))) {
  
  			/* For some reason the PIC couldn't be generated, most likely a lack of code memory. */
  			if ((((sqInt)oPIC)) == InsufficientCodeSpace) {
  				callForCogCompiledCodeCompaction();
  			}
  			return 0;
  		}
  	}
  	extent = rewriteInlineCacheAttagtarget(backEnd, outerReturn, inlineCacheValueForSelectorin(backEnd, selector, mframeHomeMethodExport()), (((sqInt)oPIC)) + cmEntryOffset);
  	flushICacheFromto(backEnd, (((usqInt)outerReturn)) - extent, ((usqInt)outerReturn));
  	flushICacheFromto(backEnd, ((usqInt)oPIC), (((usqInt)oPIC)) + openPICSize);
  	executeCogMethodfromLinkedSendWithReceiver(oPIC, receiver);
  	return 1;
  }
  
  
  /*	This value is used to decide between MNU processing
  	or interpretation in the closed PIC aborts. */
  
  	/* Cogit>>#picAbortDiscriminatorValue */
  static sqInt
  picAbortDiscriminatorValue(void)
  {
  	return 0;
  }
  
  
  /*	Answer the start of the abort sequence for invoking the interpreter in a
  	closed PIC.
   */
  
  	/* Cogit>>#picInterpretAbortOffset */
  static sqInt
  picInterpretAbortOffset(void)
  {
  	return (interpretOffset()) - (8);
  }
  
  	/* Cogit>>#printCogMethodFor: */
  void
  printCogMethodFor(void *address)
  {
      CogMethod * cogMethod;
  
  	cogMethod = methodFor(address);
  	if (cogMethod == null) {
  		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>>#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 1U << reg;
  }
  
  	/* Cogit>>#relocateCallsAndSelfReferencesInMethod: */
  static void NoDbgRegParms
  relocateCallsAndSelfReferencesInMethod(CogMethod *cogMethod)
  {
      sqInt annotation;
      sqInt callDelta;
      usqInt map;
      sqInt mapByte;
      sqInt mcpc;
      sqInt refDelta;
      sqInt result;
  
  	refDelta = (cogMethod->objectHeader);
  	callDelta = refDelta;
  	assert((((cogMethod->cmType)) == CMMethod)
  	 || (((cogMethod->cmType)) == CMOpenPIC));
  	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: */
  	mcpc = (((usqInt)cogMethod)) + cmNoCheckEntryOffset;
  	map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
  	while (((mapByte = byteAt(map))) != MapEnd) {
  		if (mapByte >= FirstAnnotation) {
  
  			/* If this is an IsSendCall annotation, peek ahead for an IsAnnotationExtension, and consume it. */
  			mcpc += (mapByte & DisplacementMask) * 4 /* codeGranularity */;
  			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 l2;
  			}
  		}
  		else {
  			if (mapByte < (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift)))) {
  				mcpc += (((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))) * 4 /* codeGranularity */;
  			}
  		}
  		map -= 1;
  	}
  	l2:	/* end mapFor:performUntil:arg: */;
  }
  
  	/* Cogit>>#relocateCallsInClosedPIC: */
  static void NoDbgRegParms
  relocateCallsInClosedPIC(CogMethod *cPIC)
  {
      sqInt callDelta;
      sqInt entryPoint;
      sqInt i;
      sqInt pc;
      sqInt 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);
  		}
  		if (((((usqInt)cPIC)) <= (((usqInt)entryPoint)))
  		 && (((((usqInt)cPIC)) + ((cPIC->blockSize))) >= (((usqInt)entryPoint)))) {
  
  			/* Interpret/MNU */
  					}
  		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)) + 4 /* loadPICLiteralByteSize */, 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 offset1;
      sqInt *sendTable1;
      CogMethod *targetMethod;
      sqInt unlinkedRoutine;
  
  	callDelta = refDelta;
  	if (annotation >= IsSendCall) {
  		entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt)mcpc));
  		if (entryPoint <= methodZoneBase) {
  
  			/* send is not linked; just relocate */
  			relocateCallBeforeReturnPCby(backEnd, ((sqInt)mcpc), -callDelta);
  			return 0;
  		}
  		/* begin offsetAndSendTableFor:annotation:into: */
  		if (annotation == IsSendCall) {
  			offset1 = cmEntryOffset;
  			sendTable1 = ordinarySendTrampolines;
  		}
  		else {
  			assert(annotation == IsSuperSend);
  			offset1 = cmNoCheckEntryOffset;
  			sendTable1 = superSendTrampolines;
  		}
  		targetMethod = ((CogMethod *) (entryPoint - offset1));
  		if (((targetMethod->cmType)) != CMFree) {
  
  			/* send target not freed; just relocate. */
  			relocateCallBeforeReturnPCby(backEnd, ((sqInt)mcpc), -(callDelta - ((targetMethod->objectHeader))));
  			return 0;
  		}
  		unlinkedRoutine = sendTable1[((((targetMethod->cmNumArgs)) < (NumSendTrampolines - 1)) ? ((targetMethod->cmNumArgs)) : (NumSendTrampolines - 1))];
  		unlinkedRoutine -= callDelta;
  		rewriteInlineCacheAttagtarget(backEnd, ((sqInt)mcpc), inlineCacheValueForSelectorin(backEnd, (targetMethod->selector), enumeratingCogMethod), unlinkedRoutine);
  		return 0;
  	}
  	if (annotation == IsRelativeCall) {
  		relocateCallBeforeReturnPCby(backEnd, ((sqInt)mcpc), -callDelta);
  		return 0;
  	}
  	if (annotation == IsAbsPCReference) {
  		relocateMethodReferenceBeforeAddressby(backEnd, ((sqInt)mcpc), refDelta);
  	}
  	return 0;
  }
  
  	/* Cogit>>#remapIfObjectRef:pc:hasYoung: */
  static sqInt NoDbgRegParms
  remapIfObjectRefpchasYoung(sqInt annotation, char *mcpc, sqInt hasYoungPtr)
  {
      sqInt cacheTag1;
      sqInt callSiteReturnAddress;
      sqInt entryPoint1;
      sqInt literal;
      sqInt mappedCacheTag;
      sqInt mappedLiteral;
      sqInt offset1;
      sqInt *sendTable1;
      sqInt tagCouldBeObj1;
      CogMethod *targetMethod1;
  
  	if (annotation == IsObjectReference) {
  		literal = longAt(((usqInt)mcpc));
  		if (couldBeObject(literal)) {
  			mappedLiteral = remapObject(literal);
  			if (literal != mappedLiteral) {
  				/* begin storeLiteral:atAnnotatedAddress:using: */
  				codeLongAtput(((usqInt)mcpc), mappedLiteral);
  				codeModified = 1;
  			}
  			if ((hasYoungPtr != 0)
  			 && (isYoung(mappedLiteral))) {
  				(((sqInt *) hasYoungPtr))[0] = 1;
  			}
  		}
  	}
  	if (annotation >= IsSendCall) {
  		/* begin entryCacheTagAndCouldBeObjectAt:annotation:into: */
  		cacheTag1 = longAt(pcRelativeAddressAt(backEnd, ((usqInt)((((sqInt)mcpc)) - 8))));
  
  		/* in-line cache tags are the selectors of sends if sends are unlinked,
  		   the selectors of super sends (entry offset = cmNoCheckEntryOffset),
  		   the selectors of open PIC sends (entry offset = cmEntryOffset, target is an Open PIC)
  		   or in-line cache tags (classes, class indices, immediate bit patterns, etc).
  		   Note that selectors can be immediate so there is no guarantee that they
  		   are markable/remappable objects. */
  		entryPoint1 = callTargetFromReturnAddress(backEnd, ((sqInt)mcpc));
  		tagCouldBeObj1 = 1;
  		if (tagCouldBeObj1
  		 && (couldBeObject(cacheTag1))) {
  			mappedCacheTag = remapObject(cacheTag1);
  			if (cacheTag1 != mappedCacheTag) {
  				/* begin rewriteInlineCacheTag:at: */
  				callSiteReturnAddress = ((usqInt)mcpc);
  				longAtput(pcRelativeAddressAt(((AbstractInstruction *) backEnd), callSiteReturnAddress - 8), mappedCacheTag);
  				((AbstractInstruction *) backEnd);
  				codeModified = 1;
  			}
  			if ((hasYoungPtr != 0)
  			 && (isYoung(mappedCacheTag))) {
  				(((sqInt *) hasYoungPtr))[0] = 1;
  			}
  		}
  		if (hasYoungPtr != 0) {
  
  			/* Since the unlinking routines may rewrite the cacheTag to the send's selector, and
  			   since they don't have the cogMethod to hand and can't add it to youngReferrers,
  			   the method must remain in youngReferrers if the targetMethod's selector is young. */
  			if (entryPoint1 > methodZoneBase) {
  
  				/* It's a linked send. */
  				/* begin targetMethodAndSendTableFor:annotation:into: */
  				if (annotation == IsSendCall) {
  					offset1 = cmEntryOffset;
  					sendTable1 = ordinarySendTrampolines;
  				}
  				else {
  					assert(annotation == IsSuperSend);
  					offset1 = cmNoCheckEntryOffset;
  					sendTable1 = superSendTrampolines;
  				}
  				targetMethod1 = ((CogMethod *) (entryPoint1 - offset1));
  				if (isYoung((targetMethod1->selector))) {
  					(((sqInt *) hasYoungPtr))[0] = 1;
  				}
  			}
  		}
  	}
  	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(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>>#rewriteCPICCaseAt:tag:objRef:target: */
  static void NoDbgRegParms
  rewriteCPICCaseAttagobjReftarget(sqInt followingAddress, sqInt newTag, sqInt newObjRef, sqInt newTarget)
  {
      sqInt classTagPC;
      sqInt methodObjPC;
  
  	methodObjPC = (followingAddress - (jumpLongConditionalByteSize(backEnd))) - 8 /* cmpC32RTempByteSize */;
  	storeLiteralbeforeFollowingAddress(backEnd, newObjRef, methodObjPC);
  
  	/* rewite the tag via the first ldr */
  	classTagPC = followingAddress - (jumpLongConditionalByteSize(backEnd));
  	/* begin storeLiteral32:beforeFollowingAddress: */
  	storeLiteralbeforeFollowingAddress(((AbstractInstruction *) backEnd), newTag, classTagPC);
  	((AbstractInstruction *) backEnd);
  	rewriteConditionalJumpLongAttarget(backEnd, followingAddress, newTarget);
  }
  
  	/* Cogit>>#SubCw:R: */
  static AbstractInstruction * NoDbgRegParms
  gSubCwR(sqInt wordConstant, sqInt reg)
  {
  	/* begin gen:literal:operand: */
  	return checkLiteralforInstruction(wordConstant, genoperandoperand(SubCwR, wordConstant, reg));
  }
  
  
  /*	Answer the number of clean blocks found in the literal frame */
  
  	/* Cogit>>#scanForCleanBlocks */
  static sqInt
  scanForCleanBlocks(void)
  {
      sqInt i;
      sqInt iLimiT;
      sqInt lit;
      sqInt numCleanBlocks;
      sqInt startPCOrNil;
  
  	numCleanBlocks = 0;
  	for (i = 1, iLimiT = (literalCountOf(methodObj)); i <= iLimiT; i += 1) {
  		lit = fetchPointerofObject(i, methodObj);
  		startPCOrNil = startPCOrNilOfLiteralin(lit, methodObj);
  		if (!(startPCOrNil == null)) {
  			numCleanBlocks += 1;
  		}
  	}
  	return numCleanBlocks;
  }
  
  	/* Cogit>>#setBreakMethod: */
  void
  setBreakMethod(sqInt anObj)
  {
  	breakMethod = anObj;
  }
  
  	/* 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. 
   */
  /*	self disassembleMethod: cogMethod */
  
  	/* Cogit>>#setSelectorOf:to: */
  void
  setSelectorOfto(CogMethod *cogMethod, sqInt aSelectorOop)
  {
  	compilationBreakpointisMNUCase(aSelectorOop, 0);
  	assert(((cogMethod->cmType)) == CMMethod);
  	((((CogMethod *) ((((usqInt)cogMethod)) + codeToDataDelta)))->selector = aSelectorOop);
  	if (isYoung(aSelectorOop)) {
  		ensureInYoungReferrers(cogMethod);
  	}
  }
  
  	/* Cogit>>#spanForCleanBlockStartingAt: */
  static sqInt NoDbgRegParms
  spanForCleanBlockStartingAt(sqInt startPC)
  {
      BytecodeDescriptor *descriptor;
      sqInt end;
      sqInt pc;
  
  	pc = startPC;
  	end = numBytesOf(methodObj);
  	while (pc <= end) {
  		/* begin generatorForPC: */
  		descriptor = generatorAt(bytecodeSetOffset + (fetchByteofObject(pc, methodObj)));
  		pc += (descriptor->numBytes);
  		if ((descriptor->isReturn)) {
  			return pc - startPC;
  		}
  	}
  	error("couldn't locate end of clean block");
  	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 (addressIsInCurrentCompilation(195929424)
  		? 233496237
  		: 195929424);
  }
  
  	/* Cogit>>#traceLinkedSendOffset */
  sqInt
  traceLinkedSendOffset(void)
  {
  	return (cmNoCheckEntryOffset + 4 /* callInstructionByteSize */) + (/* begin pushLinkRegisterByteSize */ 4);
  }
  
  
  /*	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, (numArgs <= (NumSendTrampolines - 2)
  		? '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 = 1 /* numRegArgs */;
  	theString = malloc((strlen(routinePrefix)) + 6);
  	sprintf(theString, "%s%cArgs", routinePrefix, (numArgs <= argsLimit
  		? '0' + numArgs
  		: 'N'));
  	return theString;
  }
  
  	/* 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;
  	}
  	cogMethod = ((CogMethod *) methodZoneBase);
  	voidOpenPICList();
  	while (cogMethod < (limitZony())) {
  		if (((cogMethod->cmType)) == CMMethod) {
  			/* begin mapFor:performUntil:arg: */
  			mcpc = (((usqInt)cogMethod)) + cmNoCheckEntryOffset;
  			map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
  			while (((mapByte = byteAt(map))) != MapEnd) {
  				if (mapByte >= FirstAnnotation) {
  
  					/* If this is an IsSendCall annotation, peek ahead for an IsAnnotationExtension, and consume it. */
  					mcpc += (mapByte & DisplacementMask) * 4 /* codeGranularity */;
  					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 l2;
  					}
  				}
  				else {
  					if (mapByte < (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift)))) {
  						mcpc += (((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))) * 4 /* codeGranularity */;
  					}
  				}
  				map -= 1;
  			}
  	l2:	/* end mapFor:performUntil:arg: */;
  		}
  		else {
  			if (((cogMethod->cmType)) != CMFree) {
  				freeMethod(cogMethod);
  			}
  		}
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  	flushICacheFromto(backEnd, ((usqInt)methodZoneBase), ((usqInt)(limitZony())));
  }
  
  	/* Cogit>>#unlinkIfFreeOrLinkedSend:pc:of: */
  static sqInt NoDbgRegParms
  unlinkIfFreeOrLinkedSendpcof(sqInt annotation, char *mcpc, sqInt theSelector)
  {
      sqInt entryPoint;
      sqInt offset1;
      sqInt *sendTable1;
      CogMethod *targetMethod1;
      sqInt unlinkedRoutine;
  
  	if (annotation >= IsSendCall) {
  		entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt)mcpc));
  		if (entryPoint > methodZoneBase) {
  
  			/* It's a linked send. */
  			/* begin targetMethodAndSendTableFor:annotation:into: */
  			if (annotation == IsSendCall) {
  				offset1 = cmEntryOffset;
  				sendTable1 = ordinarySendTrampolines;
  			}
  			else {
  				assert(annotation == IsSuperSend);
  				offset1 = cmNoCheckEntryOffset;
  				sendTable1 = superSendTrampolines;
  			}
  			targetMethod1 = ((CogMethod *) (entryPoint - offset1));
  			if ((((targetMethod1->cmType)) == CMFree)
  			 || (((targetMethod1->selector)) == theSelector)) {
  				/* begin unlinkSendAt:targetMethod:sendTable: */
  				unlinkedRoutine = sendTable1[((((targetMethod1->cmNumArgs)) < (NumSendTrampolines - 1)) ? ((targetMethod1->cmNumArgs)) : (NumSendTrampolines - 1))];
  				rewriteInlineCacheAttagtarget(backEnd, ((sqInt)mcpc), inlineCacheValueForSelectorin(backEnd, (targetMethod1->selector), enumeratingCogMethod), unlinkedRoutine);
  				codeModified = 1;
  			}
  		}
  	}
  	return 0;
  }
  
  	/* Cogit>>#unlinkIfLinkedSendToFree:pc:ignored: */
  static sqInt NoDbgRegParms
  unlinkIfLinkedSendToFreepcignored(sqInt annotation, char *mcpc, sqInt superfluity)
  {
      sqInt entryPoint;
      sqInt offset1;
      sqInt *sendTable1;
      CogMethod *targetMethod1;
      sqInt unlinkedRoutine;
  
  	if (annotation >= IsSendCall) {
  		entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt)mcpc));
  		if (entryPoint > methodZoneBase) {
  
  			/* It's a linked send. */
  			/* begin targetMethodAndSendTableFor:annotation:into: */
  			if (annotation == IsSendCall) {
  				offset1 = cmEntryOffset;
  				sendTable1 = ordinarySendTrampolines;
  			}
  			else {
  				assert(annotation == IsSuperSend);
  				offset1 = cmNoCheckEntryOffset;
  				sendTable1 = superSendTrampolines;
  			}
  			targetMethod1 = ((CogMethod *) (entryPoint - offset1));
  			if (((targetMethod1->cmType)) == CMFree) {
  				/* begin unlinkSendAt:targetMethod:sendTable: */
  				unlinkedRoutine = sendTable1[((((targetMethod1->cmNumArgs)) < (NumSendTrampolines - 1)) ? ((targetMethod1->cmNumArgs)) : (NumSendTrampolines - 1))];
  				rewriteInlineCacheAttagtarget(backEnd, ((sqInt)mcpc), inlineCacheValueForSelectorin(backEnd, (targetMethod1->selector), enumeratingCogMethod), unlinkedRoutine);
  				codeModified = 1;
  			}
  		}
  	}
  	return 0;
  }
  
  	/* Cogit>>#unlinkIfLinkedSend:pc:ignored: */
  static sqInt NoDbgRegParms
  unlinkIfLinkedSendpcignored(sqInt annotation, char *mcpc, sqInt superfluity)
  {
      sqInt entryPoint;
      sqInt offset1;
      sqInt *sendTable1;
      CogMethod *targetMethod1;
      sqInt unlinkedRoutine;
  
  	if (annotation >= IsSendCall) {
  		entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt)mcpc));
  		if (entryPoint > methodZoneBase) {
  
  			/* It's a linked send. */
  			/* begin targetMethodAndSendTableFor:annotation:into: */
  			if (annotation == IsSendCall) {
  				offset1 = cmEntryOffset;
  				sendTable1 = ordinarySendTrampolines;
  			}
  			else {
  				assert(annotation == IsSuperSend);
  				offset1 = cmNoCheckEntryOffset;
  				sendTable1 = superSendTrampolines;
  			}
  			targetMethod1 = ((CogMethod *) (entryPoint - offset1));
  			/* begin unlinkSendAt:targetMethod:sendTable: */
  			unlinkedRoutine = sendTable1[((((targetMethod1->cmNumArgs)) < (NumSendTrampolines - 1)) ? ((targetMethod1->cmNumArgs)) : (NumSendTrampolines - 1))];
  			rewriteInlineCacheAttagtarget(backEnd, ((sqInt)mcpc), inlineCacheValueForSelectorin(backEnd, (targetMethod1->selector), enumeratingCogMethod), unlinkedRoutine);
  			codeModified = 1;
  		}
  	}
  	return 0;
  }
  
  	/* Cogit>>#unlinkIfLinkedSend:pc:toMachineCodePrim: */
  static sqInt NoDbgRegParms
  unlinkIfLinkedSendpctoMachineCodePrim(sqInt annotation, char *mcpc, sqInt ignored)
  {
      sqInt entryPoint;
      sqInt offset1;
      sqInt *sendTable1;
      CogMethod *targetMethod1;
      sqInt unlinkedRoutine;
  
  	if (annotation >= IsSendCall) {
  		entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt)mcpc));
  		if (entryPoint > methodZoneBase) {
  
  			/* It's a linked send. */
  			/* begin targetMethodAndSendTableFor:annotation:into: */
  			if (annotation == IsSendCall) {
  				offset1 = cmEntryOffset;
  				sendTable1 = ordinarySendTrampolines;
  			}
  			else {
  				assert(annotation == IsSuperSend);
  				offset1 = cmNoCheckEntryOffset;
  				sendTable1 = superSendTrampolines;
  			}
  			targetMethod1 = ((CogMethod *) (entryPoint - offset1));
  			if (cogMethodHasMachineCodePrim(targetMethod1)) {
  				/* begin unlinkSendAt:targetMethod:sendTable: */
  				unlinkedRoutine = sendTable1[((((targetMethod1->cmNumArgs)) < (NumSendTrampolines - 1)) ? ((targetMethod1->cmNumArgs)) : (NumSendTrampolines - 1))];
  				rewriteInlineCacheAttagtarget(backEnd, ((sqInt)mcpc), inlineCacheValueForSelectorin(backEnd, (targetMethod1->selector), enumeratingCogMethod), unlinkedRoutine);
  				codeModified = 1;
  			}
  		}
  	}
  	return 0;
  }
  
  	/* Cogit>>#unlinkIfLinkedSend:pc:to: */
  static sqInt NoDbgRegParms
  unlinkIfLinkedSendpcto(sqInt annotation, char *mcpc, sqInt theCogMethod)
  {
      sqInt entryPoint;
      sqInt offset1;
      sqInt *sendTable1;
      CogMethod *targetMethod1;
      sqInt unlinkedRoutine;
  
  	if (annotation >= IsSendCall) {
  		entryPoint = callTargetFromReturnAddress(backEnd, ((sqInt)mcpc));
  		if (entryPoint > methodZoneBase) {
  
  			/* It's a linked send. */
  			/* begin targetMethodAndSendTableFor:annotation:into: */
  			if (annotation == IsSendCall) {
  				offset1 = cmEntryOffset;
  				sendTable1 = ordinarySendTrampolines;
  			}
  			else {
  				assert(annotation == IsSuperSend);
  				offset1 = cmNoCheckEntryOffset;
  				sendTable1 = superSendTrampolines;
  			}
  			targetMethod1 = ((CogMethod *) (entryPoint - offset1));
  			if ((((sqInt)targetMethod1)) == theCogMethod) {
  				/* begin unlinkSendAt:targetMethod:sendTable: */
  				unlinkedRoutine = sendTable1[((((targetMethod1->cmNumArgs)) < (NumSendTrampolines - 1)) ? ((targetMethod1->cmNumArgs)) : (NumSendTrampolines - 1))];
  				rewriteInlineCacheAttagtarget(backEnd, ((sqInt)mcpc), inlineCacheValueForSelectorin(backEnd, (targetMethod1->selector), enumeratingCogMethod), unlinkedRoutine);
  				codeModified = 1;
  			}
  		}
  	}
  	return 0;
  }
  
  
  /*	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;
      sqInt mustScanAndUnlink;
      sqInt result;
  
  	if (!(methodZoneBase)) {
  		return;
  	}
  	cogMethod = ((CogMethod *) methodZoneBase);
  	mustScanAndUnlink = 0;
  	if (isMNUSelector) {
  		while (cogMethod < (limitZony())) {
  			if (((cogMethod->cmType)) != CMFree) {
  				if ((cogMethod->cpicHasMNUCaseOrCMIsFullBlock)) {
  					assert(((cogMethod->cmType)) == CMClosedPIC);
  					freeMethod(cogMethod);
  					mustScanAndUnlink = 1;
  				}
  				else {
  					if (((cogMethod->selector)) == selector) {
  						mustScanAndUnlink = 1;
  						if (((cogMethod->cmType)) == CMClosedPIC) {
  							freeMethod(cogMethod);
  						}
  					}
  				}
  			}
  			cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  		}
  	}
  	else {
  		while (cogMethod < (limitZony())) {
  			if ((((cogMethod->cmType)) != CMFree)
  			 && (((cogMethod->selector)) == selector)) {
  				mustScanAndUnlink = 1;
  				if (((cogMethod->cmType)) == CMClosedPIC) {
  					freeMethod(cogMethod);
  				}
  			}
  			cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  		}
  	}
  	if (!mustScanAndUnlink) {
  		return;
  	}
  	codeModified = 0;
  	cogMethod = ((CogMethod *) methodZoneBase);
  	while (cogMethod < (limitZony())) {
  		if (((cogMethod->cmType)) == CMMethod) {
  			/* begin mapFor:performUntil:arg: */
  			mcpc = (((usqInt)cogMethod)) + cmNoCheckEntryOffset;
  			map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
  			while (((mapByte = byteAt(map))) != MapEnd) {
  				if (mapByte >= FirstAnnotation) {
  
  					/* If this is an IsSendCall annotation, peek ahead for an IsAnnotationExtension, and consume it. */
  					mcpc += (mapByte & DisplacementMask) * 4 /* codeGranularity */;
  					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 l2;
  					}
  				}
  				else {
  					if (mapByte < (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift)))) {
  						mcpc += (((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))) * 4 /* codeGranularity */;
  					}
  				}
  				map -= 1;
  			}
  	l2:	/* end mapFor:performUntil:arg: */;
  		}
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  	if (codeModified) {
  
  		/* After possibly updating inline caches we need to flush the icache. */
  		flushICacheFromto(backEnd, ((usqInt)methodZoneBase), ((usqInt)(limitZony())));
  	}
  }
  
  
  /*	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: */
  			mcpc = (((usqInt)cogMethod)) + cmNoCheckEntryOffset;
  			map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
  			while (((mapByte = byteAt(map))) != MapEnd) {
  				if (mapByte >= FirstAnnotation) {
  
  					/* If this is an IsSendCall annotation, peek ahead for an IsAnnotationExtension, and consume it. */
  					mcpc += (mapByte & DisplacementMask) * 4 /* codeGranularity */;
  					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 l2;
  					}
  				}
  				else {
  					if (mapByte < (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift)))) {
  						mcpc += (((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))) * 4 /* codeGranularity */;
  					}
  				}
  				map -= 1;
  			}
  	l2:	/* end mapFor:performUntil:arg: */;
  		}
  		else {
  			if (((cogMethod->cmType)) == CMClosedPIC) {
  				assert(noTargetsFreeInClosedPIC(cogMethod));
  			}
  		}
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  	if (codeModified) {
  
  		/* After possibly updating inline caches we need to flush the icache. */
  		flushICacheFromto(backEnd, ((usqInt)methodZoneBase), ((usqInt)(limitZony())));
  	}
  }
  
  
  /*	Unlink all sends in cog methods to methods with a machine code
  	primitive, and free machine code primitive methods if freeIfTrue.
  	To avoid having to scan PICs, free any and all PICs */
  
  	/* Cogit>>#unlinkSendsToMachineCodePrimitiveMethodsAndFreeIf: */
  void
  unlinkSendsToMachineCodePrimitiveMethodsAndFreeIf(sqInt freeIfTrue)
  {
      sqInt annotation;
      CogMethod *cogMethod;
      sqInt freedSomething;
      usqInt map;
      sqInt mapByte;
      sqInt mcpc;
      sqInt result;
  
  	if (!(methodZoneBase)) {
  		return;
  	}
  	codeModified = (freedSomething = 0);
  	cogMethod = ((CogMethod *) methodZoneBase);
  	while (cogMethod < (limitZony())) {
  		if (((cogMethod->cmType)) == CMMethod) {
  			if (freeIfTrue
  			 && (cogMethodHasMachineCodePrim(cogMethod))) {
  				freeMethod(cogMethod);
  				freedSomething = 1;
  			}
  			else {
  				/* begin mapFor:performUntil:arg: */
  				mcpc = (((usqInt)cogMethod)) + cmNoCheckEntryOffset;
  				map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
  				while (((mapByte = byteAt(map))) != MapEnd) {
  					if (mapByte >= FirstAnnotation) {
  
  						/* If this is an IsSendCall annotation, peek ahead for an IsAnnotationExtension, and consume it. */
  						mcpc += (mapByte & DisplacementMask) * 4 /* codeGranularity */;
  						if ((((annotation = ((usqInt)(mapByte)) >> AnnotationShift)) == IsSendCall)
  						 && ((((usqInt)(((mapByte = byteAt(map - 1))))) >> AnnotationShift) == IsAnnotationExtension)) {
  							annotation += mapByte & DisplacementMask;
  							map -= 1;
  						}
  						result = unlinkIfLinkedSendpctoMachineCodePrim(annotation, (((char *) mcpc)), 0);
  						if (result != 0) {
  							goto l2;
  						}
  					}
  					else {
  						if (mapByte < (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift)))) {
  							mcpc += (((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))) * 4 /* codeGranularity */;
  						}
  					}
  					map -= 1;
  				}
  	l2:	/* end mapFor:performUntil:arg: */;
  			}
  		}
  		else {
  			if (((cogMethod->cmType)) == CMClosedPIC) {
  				freeMethod(cogMethod);
  				freedSomething = 1;
  			}
  		}
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  	if (freedSomething) {
  		unlinkSendsToFree();
  	}
  	else {
  		if (codeModified) {
  
  			/* After possibly updating inline caches we need to flush the icache. */
  			flushICacheFromto(backEnd, ((usqInt)methodZoneBase), ((usqInt)(limitZony())));
  		}
  	}
  }
  
  
  /*	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;
      sqInt 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);
  	while (cogMethod < (limitZony())) {
  		if (((cogMethod->cmType)) == CMMethod) {
  			/* begin mapFor:performUntil:arg: */
  			mcpc = (((usqInt)cogMethod)) + cmNoCheckEntryOffset;
  			map = ((((usqInt)cogMethod)) + ((cogMethod->blockSize))) - 1;
  			while (((mapByte = byteAt(map))) != MapEnd) {
  				if (mapByte >= FirstAnnotation) {
  
  					/* If this is an IsSendCall annotation, peek ahead for an IsAnnotationExtension, and consume it. */
  					mcpc += (mapByte & DisplacementMask) * 4 /* codeGranularity */;
  					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 l2;
  					}
  				}
  				else {
  					if (mapByte < (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift)))) {
  						mcpc += (((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))) * 4 /* codeGranularity */;
  					}
  				}
  				map -= 1;
  			}
  	l2:	/* end mapFor:performUntil:arg: */;
  		}
  		else {
  			if ((((cogMethod->cmType)) == CMClosedPIC)
  			 && (cPICHasTarget(cogMethod, targetMethod))) {
  				freeMethod(cogMethod);
  				freedPIC = 1;
  			}
  		}
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  	if (freeIfTrue) {
  		freeMethod(targetMethod);
  	}
  	if (freedPIC) {
  		unlinkSendsToFree();
  	}
  	else {
  		if (codeModified) {
  
  			/* After possibly updating inline caches we need to flush the icache. */
  			flushICacheFromto(backEnd, ((usqInt)methodZoneBase), ((usqInt)(limitZony())));
  		}
  	}
  }
  
  	/* Cogit>>#varBaseAddress */
  static sqInt
  varBaseAddress(void)
  {
  	return (stackPointerAddress()) - BytesPerWord;
  }
  
  	/* Cogit>>#XorCw:R: */
  static AbstractInstruction * NoDbgRegParms
  gXorCwR(sqInt wordConstant, sqInt reg)
  {
  	/* begin gen:literal:operand: */
  	return checkLiteralforInstruction(wordConstant, genoperandoperand(XorCwR, wordConstant, reg));
  }
  
  
  /*	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 */
  
  	/* an impossibly high value */
  	firstOpcodeIndex = 65536;
  	nextLiteralIndex = (lastDumpedLiteralIndex = 0);
  }
  
  	/* CogMethod>>#counters */
  static sqInt NoDbgRegParms
  counters(CogMethod * self_in_counters)
  {
  	return 0;
  }
  
  	/* CogMethodZone>>#addAllToYoungReferrers */
  void
  addAllToYoungReferrers(void)
  {
      CogMethod *cogMethod;
  
  	cogMethod = ((CogMethod *) baseAddress);
  	while (cogMethod < (limitZony())) {
  		if ((((cogMethod->cmType)) == CMMethod)
  		 || (((cogMethod->cmType)) == CMOpenPIC)) {
  			ensureInYoungReferrers(cogMethod);
  		}
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  }
  
  	/* CogMethodZone>>#addToOpenPICList: */
  static void NoDbgRegParms
  addToOpenPICList(CogMethod *anOpenPIC)
  {
  	assert(((anOpenPIC->cmType)) == CMOpenPIC);
  	assert((openPICList == null)
  	 || (((openPICList->cmType)) == CMOpenPIC));
  	assertValidDualZoneWriteAddress(anOpenPIC);
  	(anOpenPIC->nextOpenPIC = ((usqInt)openPICList));
  	openPICList = ((CogMethod *) ((((usqInt)anOpenPIC)) - (getCodeToDataDelta())));
  }
  
  	/* CogMethodZone>>#addToYoungReferrers: */
  static void NoDbgRegParms
  addToYoungReferrers(CogMethod *cogMethod)
  {
  	assertValidDualZoneWriteAddress(cogMethod);
  	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;
  	codeLongAtput(youngReferrers, (((usqInt)cogMethod)) - (getCodeToDataDelta()));
  }
  
  	/* 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;
  
  	cogMethod = ((CogMethod *) baseAddress);
  	while ((((usqInt)cogMethod)) < mzFreeStart) {
  		if (((cogMethod->cmType)) == CMMethod) {
  			freeMethod(cogMethod);
  		}
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  	/* begin manageFrom:to: */
  	mzFreeStart = (/* baseAddress = */ baseAddress);
  	youngReferrers = (/* limitAddress = */ limitAddress);
  	openPICList = null;
  	methodBytesFreedSinceLastCompaction = 0;
  	methodCount = 0;
  }
  
  	/* CogMethodZone>>#compactCompiledCode */
  static void
  compactCompiledCode(void)
  {
      unsigned short bytes;
      CogMethod *dest;
      sqInt objectHeaderValue;
      CogMethod *source;
      CogMethod * writableVersion;
  
  	compactionInProgress = 1;
  	methodCount = 0;
  	objectHeaderValue = nullHeaderForMachineCodeMethod();
  	source = ((CogMethod *) baseAddress);
  	voidOpenPICList();
  	voidUnpairedMethodList();
  	while ((source < (limitZony()))
  	 && (((source->cmType)) != CMFree)) {
  		assert((cogMethodDoesntLookKosher(source)) == 0);
  		/* begin writableMethodFor: */
  		writableVersion = ((CogMethod *) ((((usqInt)source)) + codeToDataDelta));
  		(writableVersion->objectHeader = objectHeaderValue);
  		if (((source->cmUsageCount)) > 0) {
  			(writableVersion->cmUsageCount = ((source->cmUsageCount)) / 2);
  		}
  		/* begin maybeLinkOnUnpairedMethodList: */
  		/* begin clearSavedPICUsageCount: */
  		if (((source->cmType)) == CMOpenPIC) {
  			addToOpenPICList(writableVersion);
  		}
  		methodCount += 1;
  		source = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)source)) + ((source->blockSize)))));
  	}
  	if (source >= (limitZony())) {
  		haltmsg("no free methods; cannot compact.");
  		return;
  	}
  	dest = source;
  	while (source < (limitZony())) {
  		assert((maybeFreeCogMethodDoesntLookKosher(source)) == 0);
  		bytes = (source->blockSize);
  		if (((source->cmType)) != CMFree) {
  			methodCount += 1;
  			codeMemmove(dest, source, bytes);
  			maybeFlushWritableZoneFromto(((usqInt)dest), (((usqInt)dest)) + bytes);
  			((writableVersion = ((CogMethod *) ((((usqInt)dest)) + codeToDataDelta)))->objectHeader = objectHeaderValue);
  			if (((dest->cmType)) == CMMethod) {
  
  				/* For non-Newspeak there should be a one-to-one mapping between bytecoded and
  				   cog methods.  For Newspeak not necessarily, but only for anonymous accessors. */
  				/* Only update the original method's header if it is referring to this CogMethod. */
  				if ((((sqInt)(rawHeaderOf((dest->methodObject))))) == (((sqInt)source))) {
  					rawHeaderOfput((dest->methodObject), ((sqInt)dest));
  				}
  				else {
  					assert((noAssertMethodClassAssociationOf((dest->methodObject))) == (nilObject()));
  					/* begin linkOnUnpairedMethodList: */
  									}
  			}
  			else {
  				/* begin clearSavedPICUsageCount: */
  				if (((dest->cmType)) == CMOpenPIC) {
  					addToOpenPICList(writableVersion);
  				}
  			}
  			if (((dest->cmUsageCount)) > 0) {
  				(writableVersion->cmUsageCount = ((dest->cmUsageCount)) / 2);
  			}
  			maybeFlushWritableZoneFromto(((usqInt)dest), ((usqInt)(dest + 1)));
  			dest = ((CogMethod *) ((((usqInt)dest)) + bytes));
  		}
  		source = ((CogMethod *) ((((usqInt)source)) + bytes));
  	}
  	mzFreeStart = ((usqInt)dest);
  	methodBytesFreedSinceLastCompaction = 0;
  	compactionInProgress = 0;
  }
  
  	/* CogMethodZone>>#ensureInYoungReferrers: */
  static void NoDbgRegParms
  ensureInYoungReferrers(CogMethod *cogMethod)
  {
      CogMethod * writableMethod;
  
  	assertValidDualZoneReadAddress(cogMethod);
  	if (!((cogMethod->cmRefersToYoung))) {
  		assert((occurrencesInYoungReferrers(cogMethod)) == 0);
  		((writableMethod = ((CogMethod *) ((((usqInt)cogMethod)) + codeToDataDelta)))->cmRefersToYoung = 1);
  		addToYoungReferrers(writableMethod);
  	}
  }
  
  	/* CogMethodZone>>#freeMethod: */
  void
  freeMethod(CogMethod *cogMethod)
  {
      CogMethod * writableMethod;
  
  	assert(((cogMethod->cmType)) != CMFree);
  	assert((cogMethodDoesntLookKosher(cogMethod)) == 0);
  	if (((cogMethod->cmType)) == CMMethod) {
  
  		/* For non-Newspeak there should be a one-to-one mapping between bytecoded and
  		   cog methods.  For Newspeak not necessarily, but only for anonymous accessors. */
  		/* Only reset the original method's header if it is referring to this CogMethod. */
  		if ((((sqInt)(rawHeaderOf((cogMethod->methodObject))))) == (((sqInt)cogMethod))) {
  			rawHeaderOfput((cogMethod->methodObject), (cogMethod->methodHeader));
  					}
  		else {
  			assert((noAssertMethodClassAssociationOf((cogMethod->methodObject))) == (nilObject()));
  					}
  	}
  	if (((cogMethod->cmType)) == CMOpenPIC) {
  		removeFromOpenPICList(cogMethod);
  	}
  	/* begin writableMethodFor: */
  	writableMethod = ((CogMethod *) ((((usqInt)cogMethod)) + codeToDataDelta));
  	(writableMethod->cmRefersToYoung = 0);
  	(writableMethod->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;
      sqInt freeableUsage;
      sqInt freedSoFar;
      sqInt initialFreeSpace;
      sqInt zoneSize;
  
  	zoneSize = limitAddress - baseAddress;
  	initialFreeSpace = (limitAddress - mzFreeStart) + methodBytesFreedSinceLastCompaction;
  	freedSoFar = initialFreeSpace;
  
  	/* 4 needs to be e.g. a start-up parameter */
  	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 *) (roundUpToMethodAlignment(backEnd(), (((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 */
  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) {
  			if (!((cogMethod->cmRefersToYoung))) {
  				return 0;
  			}
  			if ((occurrencesInYoungReferrers(cogMethod)) != 1) {
  				return 0;
  			}
  		}
  		pointer += BytesPerWord;
  	}
  	cogMethod = ((CogMethod *) baseAddress);
  	while (cogMethod < (limitZony())) {
  		if (((cogMethod->cmType)) != CMFree) {
  			if ((occurrencesInYoungReferrers(cogMethod)) != (((cogMethod->cmRefersToYoung)
  				? 1
  				: 0))) {
  				return 0;
  			}
  		}
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  	return 1;
  }
  
  	/* CogMethodZone>>#methodFor: */
  CogMethod *
  methodFor(void *address)
  {
      CogMethod * cogMethod;
      CogMethod * nextMethod;
  
  	cogMethod = ((CogMethod *) baseAddress);
  	while ((cogMethod < (limitZony()))
  	 && ((((usqInt)cogMethod)) <= (((usqInt)address)))) {
  		/* begin methodAfter: */
  		nextMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  		if (nextMethod == cogMethod) {
  			return null;
  		}
  		if (((((usqInt)address)) >= (((usqInt)cogMethod)))
  		 && ((((usqInt)address)) < (((usqInt)nextMethod)))) {
  			return cogMethod;
  		}
  		cogMethod = nextMethod;
  	}
  	return null;
  }
  
  	/* CogMethodZone>>#methodsCompiledToMachineCodeInto: */
  sqInt
  methodsCompiledToMachineCodeInto(sqInt arrayObj)
  {
      CogMethod *cogMethod;
      sqInt methodIndex;
  
  	methodIndex = 0;
  	cogMethod = ((CogMethod *) baseAddress);
  	while (cogMethod < (limitZony())) {
  		if (((cogMethod->cmType)) == CMMethod) {
  			storePointerUncheckedofObjectwithValue(methodIndex, arrayObj, (cogMethod->methodObject));
  			methodIndex += 1;
  		}
  		/* begin methodAfter: */
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  	return methodIndex;
  }
  
  	/* CogMethodZone>>#numMethods */
  sqInt
  numMethods(void)
  {
  	return methodCount;
  }
  
  	/* CogMethodZone>>#numMethodsOfType: */
  sqInt
  numMethodsOfType(sqInt cogMethodType)
  {
      CogMethod *cogMethod;
      sqInt n;
  
  	n = 0;
  	cogMethod = ((CogMethod *) baseAddress);
  	while (cogMethod < (limitZony())) {
  		if (((cogMethod->cmType)) == cogMethodType) {
  			n += 1;
  		}
  		/* begin methodAfter: */
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  	return n;
  }
  
  	/* CogMethodZone>>#occurrencesInYoungReferrers: */
  static sqInt NoDbgRegParms
  occurrencesInYoungReferrers(CogMethod *cogMethod)
  {
      sqInt 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;
      sqInt delta;
  
  	delta = 0;
  	cogMethod = ((CogMethod *) baseAddress);
  	while ((((usqInt)cogMethod)) < mzFreeStart) {
  		if (((cogMethod->cmType)) == CMFree) {
  			delta -= (cogMethod->blockSize);
  		}
  		else {
  			assert((cogMethodDoesntLookKosher(cogMethod)) == 0);
  			((((CogMethod *) ((((usqInt)cogMethod)) + codeToDataDelta)))->objectHeader = delta);
  					}
  		/* begin methodAfter: */
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  }
  
  	/* CogMethodZone>>#printCogMethods */
  void
  printCogMethods(void)
  {
      CogMethod *cogMethod;
      sqInt nc;
      sqInt nf;
      sqInt nm;
      sqInt no;
      sqInt nu;
  
  	/* begin printCogMethodsSummarizing: */
  	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 CMClosedPIC:
  			nc += 1;
  			break;
  		case CMOpenPIC:
  			no += 1;
  			break;
  		default:
  			nu += 1;
  
  		}
  		/* begin methodAfter: */
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  	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 *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  }
  
  	/* 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 *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  }
  
  	/* 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 *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  }
  
  	/* 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 *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  }
  
  	/* 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)
  {
      sqInt n;
      CogMethod *openPIC;
  
  	/* begin printOpenPICListSummarizing: */
  	n = 0;
  	openPIC = openPICList;
  	while (!(openPIC == null)) {
  		n += 1;
  		printCogMethod(openPIC);
  		openPIC = ((CogMethod *) ((openPIC->nextOpenPIC)));
  	}
  	return n;
  }
  
  	/* CogMethodZone>>#pruneYoungReferrers */
  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));
  			codeLongAtput((dest -= BytesPerWord), longAt(source));
  		}
  		source -= BytesPerWord;
  	}
  	youngReferrers = dest;
  	assert(kosherYoungReferrers());
  	return 0;
  }
  
  	/* 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) {
  			codeLongAtput(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))))));
  			}
  			codeLongAtput((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)) == CMClosedPIC) {
  				relocateCallsInClosedPIC(cogMethod);
  			}
  			else {
  				relocateCallsAndSelfReferencesInMethod(cogMethod);
  			}
  		}
  		/* begin methodAfter: */
  		cogMethod = ((CogMethod *) (roundUpToMethodAlignment(backEnd(), (((sqInt)cogMethod)) + ((cogMethod->blockSize)))));
  	}
  	relocateAndPruneYoungReferrers();
  	return 1;
  }
  
  	/* CogMethodZone>>#removeFromOpenPICList: */
  static sqInt NoDbgRegParms
  removeFromOpenPICList(CogMethod *anOpenPIC)
  {
      CogMethod *prevPIC;
  
  	assert(((anOpenPIC->cmType)) == CMOpenPIC);
  	if (!(openPICList)) {
  		return null;
  	}
  	assert((((openPICList->cmType)) == CMOpenPIC)
  	 && ((((openPICList->nextOpenPIC)) == null)
  	 || ((((((CogMethod *) ((openPICList->nextOpenPIC))))->cmType)) == CMOpenPIC)));
  	if (anOpenPIC == openPICList) {
  
  		/* N.B. Use self rather than coInterpreter to avoid attempting to cast nil.
  		   Conversion to CogMethod done in the nextOpenPIC accessor. */
  		openPICList = ((CogMethod *) ((anOpenPIC->nextOpenPIC)));
  		return null;
  	}
  	prevPIC = openPICList;
  	do {
  		assert((prevPIC != null)
  		 && (((prevPIC->cmType)) == CMOpenPIC));
  		if (((prevPIC->nextOpenPIC)) == (((usqInt)anOpenPIC))) {
  			((((CogMethod *) ((((usqInt)prevPIC)) + codeToDataDelta)))->nextOpenPIC = (anOpenPIC->nextOpenPIC));
  			return null;
  		}
  		prevPIC = ((CogMethod *) ((prevPIC->nextOpenPIC)));
  	} while(1);
  	return 0;
  }
  
  
  /*	Determine the default alignment for the start of a CogMethod, which in
  	turn determines the size of the mask used to distinguish the checked and
  	unchecked entry-points, used to distinguish normal and super sends on
  	method unlinking.
  	This is passed onto the backEnd to allow processors with coarse
  	instructions (ARM) to increase the alignment if required. */
  
  	/* CogMethodZone>>#roundUpLength: */
  static sqInt NoDbgRegParms
  roundUpLength(sqInt numBytes)
  {
  	return roundUpToMethodAlignment(backEnd(), numBytes);
  }
  
  	/* CogMethodZone>>#voidOpenPICList */
  static void
  voidOpenPICList(void)
  {
  	openPICList = null;
  }
  
  	/* CogMethodZone>>#voidUnpairedMethodList */
  static void
  voidUnpairedMethodList(void)
  {
  	}
  
  	/* 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;
  }
  
  	/* 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;
  }
  
  	/* CogObjectRepresentation>>#genCmpClassMethodContextCompactIndexR: */
  static AbstractInstruction * NoDbgRegParms
  genCmpClassMethodContextCompactIndexR(sqInt reg)
  {
      AbstractInstruction *anInstruction;
  
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(CmpCqR, ClassMethodContextCompactIndex, reg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(ClassMethodContextCompactIndex));
  	}
  	return anInstruction;
  }
  
  	/* CogObjectRepresentation>>#genDoubleArithmetic:preOpCheck: */
  static sqInt NoDbgRegParms
  genDoubleArithmeticpreOpCheck(sqInt arithmeticOperator, AbstractInstruction *(*preOpCheckOrNil)(int rcvrReg, int argReg))
  {
      AbstractInstruction *doOp;
      AbstractInstruction *jumpFailAlloc;
      AbstractInstruction *jumpFailCheck;
      AbstractInstruction *jumpFailClass;
      AbstractInstruction *jumpImmediate;
  
  	jumpFailCheck = ((AbstractInstruction *) 0);
  
  	/* inline processorHasDoublePrecisionFloatingPointSupport */
  	/* begin hasDoublePrecisionFloatingPointSupport */
  ;
  	/* begin genLoadArgAtDepth:into: */
  	assert(0 < (numRegArgs()));
  	genGetDoubleValueOfinto(ReceiverResultReg, DPFPReg0);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, Arg0Reg, ClassReg);
  	jumpImmediate = genJumpImmediate(Arg0Reg);
  	genGetCompactClassIndexNonImmOfinto(Arg0Reg, SendNumArgsReg);
  	genCmpClassFloatCompactIndexR(SendNumArgsReg);
  	/* begin JumpNonZero: */
  	jumpFailClass = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	genGetDoubleValueOfinto(Arg0Reg, DPFPReg1);
  	/* begin Label */
  	doOp = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	if (!(preOpCheckOrNil == null)) {
  		jumpFailCheck = preOpCheckOrNil(DPFPReg0, DPFPReg1);
  	}
  	genoperandoperand(arithmeticOperator, DPFPReg1, DPFPReg0);
  	jumpFailAlloc = genAllocFloatValueintoscratchRegscratchReg(DPFPReg0, SendNumArgsReg, ClassReg, TempReg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  
  	/* maybeGenConvertIfSmallFloatIn:scratchReg:into:andJumpTo: */
  	genConvertSmallIntegerToIntegerInReg(ClassReg);
  	/* begin ConvertR:Rd: */
  	genoperandoperand(ConvertRRd, ClassReg, DPFPReg1);
  	/* begin Jump: */
  	genoperand(Jump, ((sqInt)doOp));
  	jmpTarget(jumpFailAlloc, jmpTarget(jumpFailClass, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
  	if (!(preOpCheckOrNil == null)) {
  		jmpTarget(jumpFailCheck, ((AbstractInstruction *) (((jumpFailClass->operands))[0])));
  	}
  	return 0;
  }
  
  	/* CogObjectRepresentation>>#genDoubleComparison:invert: */
  static sqInt NoDbgRegParms
  genDoubleComparisoninvert(AbstractInstruction * NoDbgRegParms (*jumpOpcodeGenerator)(void *), sqInt invertComparison)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *compare;
      sqInt constant;
      AbstractInstruction *jumpCond;
      AbstractInstruction *jumpFail;
      AbstractInstruction *jumpImmediate;
  
  
  	/* inline processorHasDoublePrecisionFloatingPointSupport */
  	/* begin hasDoublePrecisionFloatingPointSupport */
  ;
  	/* begin genLoadArgAtDepth:into: */
  	assert(0 < (numRegArgs()));
  	genGetDoubleValueOfinto(ReceiverResultReg, DPFPReg0);
  	jumpImmediate = genJumpImmediate(Arg0Reg);
  	genGetCompactClassIndexNonImmOfinto(Arg0Reg, SendNumArgsReg);
  	genCmpClassFloatCompactIndexR(SendNumArgsReg);
  	/* begin JumpNonZero: */
  	jumpFail = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	genGetDoubleValueOfinto(Arg0Reg, DPFPReg1);
  	if (invertComparison) {
  
  		/* May need to invert for NaNs */
  		/* begin CmpRd:Rd: */
  		compare = genoperandoperand(CmpRdRd, DPFPReg0, DPFPReg1);
  	}
  	else {
  		/* begin CmpRd:Rd: */
  		compare = genoperandoperand(CmpRdRd, DPFPReg1, DPFPReg0);
  	}
  
  	/* FP jumps are a little weird */
  	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));
  		}
  	}
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpCond, genMoveConstantR(trueObject(), ReceiverResultReg));
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  
  	/* maybeGenConvertIfSmallFloatIn:scratchReg:into:andJumpTo: */
  	genConvertSmallIntegerToIntegerInReg(Arg0Reg);
  	/* begin ConvertR:Rd: */
  	genoperandoperand(ConvertRRd, Arg0Reg, DPFPReg1);
  	/* begin Jump: */
  	genoperand(Jump, ((sqInt)compare));
  	jmpTarget(jumpFail, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	return CompletePrimitive;
  }
  
  	/* 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));
  	}
  	return 0;
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveAdd */
  static sqInt
  genPrimitiveAdd(void)
  {
      AbstractInstruction *jumpNotSI;
      AbstractInstruction *jumpOvfl;
  
  	if (!(mclassIsSmallInteger())) {
  		return UnimplementedPrimitive;
  	}
  	/* begin genLoadArgAtDepth:into: */
  	assert(0 < (numRegArgs()));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, Arg0Reg, ClassReg);
  	/* begin genJumpNotSmallInteger:scratchReg: */
  	jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
  	genRemoveSmallIntegerTagsInScratchReg(ClassReg);
  	/* begin AddR:R: */
  	genoperandoperand(AddRR, ReceiverResultReg, ClassReg);
  	/* begin JumpOverflow: */
  	jumpOvfl = genConditionalBranchoperand(JumpOverflow, ((sqInt)0));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ClassReg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpOvfl, jmpTarget(jumpNotSI, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
  	return CompletePrimitive;
  }
  
  
  /*	subclasses override if they can */
  
  	/* CogObjectRepresentation>>#genPrimitiveAsCharacter */
  static sqInt
  genPrimitiveAsCharacter(void)
  {
  	return UnimplementedPrimitive;
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveAsFloat */
  static sqInt
  genPrimitiveAsFloat(void)
  {
      AbstractInstruction *jumpFailAlloc;
  
  
  	/* inline processorHasDoublePrecisionFloatingPointSupport */
  	/* begin hasDoublePrecisionFloatingPointSupport */
  ;
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ReceiverResultReg, TempReg);
  	genConvertSmallIntegerToIntegerInReg(TempReg);
  	/* begin ConvertR:Rd: */
  	genoperandoperand(ConvertRRd, TempReg, DPFPReg0);
  	jumpFailAlloc = genAllocFloatValueintoscratchRegscratchReg(DPFPReg0, SendNumArgsReg, ClassReg, TempReg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpFailAlloc, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	return 0;
  }
  
  
  /*	subclasses override if they can */
  
  	/* CogObjectRepresentation>>#genPrimitiveAtPut */
  static sqInt
  genPrimitiveAtPut(void)
  {
  	return UnimplementedPrimitive;
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveBitAnd */
  static sqInt
  genPrimitiveBitAnd(void)
  {
      AbstractInstruction *jumpNotSI;
  
  	if (!(mclassIsSmallInteger())) {
  		return UnimplementedPrimitive;
  	}
  	/* begin genLoadArgAtDepth:into: */
  	assert(0 < (numRegArgs()));
  	/* begin genJumpNotSmallInteger:scratchReg: */
  	jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
  	/* begin AndR:R: */
  	genoperandoperand(AndRR, Arg0Reg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	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()));
  	/* begin genJumpNotSmallInteger:scratchReg: */
  	jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
  	/* begin OrR:R: */
  	genoperandoperand(OrRR, Arg0Reg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	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 *anInstruction1;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *anInstruction3;
      AbstractInstruction *jumpInRange;
      AbstractInstruction *jumpNegative;
      AbstractInstruction *jumpNotSI;
      AbstractInstruction *jumpOvfl;
      AbstractInstruction *jumpTooBig;
  
  	if (!(mclassIsSmallInteger())) {
  		return UnimplementedPrimitive;
  	}
  	/* begin genLoadArgAtDepth:into: */
  	assert(0 < (numRegArgs()));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, Arg0Reg, ClassReg);
  	/* begin genJumpNotSmallInteger:scratchReg: */
  	jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
  	genConvertSmallIntegerToIntegerInReg(ClassReg);
  	if (!(setsConditionCodesFor(lastOpcode(), JumpNegative))) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction = genoperandoperand(CmpCqR, 0, ClassReg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(0));
  		}
  	}
  	/* begin JumpNegative: */
  	jumpNegative = genConditionalBranchoperand(JumpNegative, ((sqInt)0));
  	/* begin CmpCq:R: */
  	anInstruction1 = genoperandoperand(CmpCqR, 0x1F /* numSmallIntegerBits */, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(0x1F /* numSmallIntegerBits */));
  	}
  	/* begin JumpGreaterOrEqual: */
  	jumpTooBig = genConditionalBranchoperand(JumpGreaterOrEqual, ((sqInt)0));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ReceiverResultReg, TempReg);
  	/* begin LogicalShiftLeftR:R: */
  	genoperandoperand(LogicalShiftLeftRR, ClassReg, TempReg);
  	/* begin ArithmeticShiftRightR:R: */
  	genoperandoperand(ArithmeticShiftRightRR, ClassReg, TempReg);
  	/* begin CmpR:R: */
  	assert(!((TempReg == SPReg)));
  	genoperandoperand(CmpRR, TempReg, ReceiverResultReg);
  	/* begin JumpNonZero: */
  	jumpOvfl = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	genRemoveSmallIntegerTagsInScratchReg(ReceiverResultReg);
  	/* begin LogicalShiftLeftR:R: */
  	genoperandoperand(LogicalShiftLeftRR, ClassReg, ReceiverResultReg);
  	genAddSmallIntegerTagsTo(ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpNegative, genoperand(NegateR, ClassReg));
  	/* begin CmpCq:R: */
  	anInstruction2 = genoperandoperand(CmpCqR, 0x1F /* numSmallIntegerBits */, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(0x1F /* numSmallIntegerBits */));
  	}
  	/* begin JumpLessOrEqual: */
  	jumpInRange = genConditionalBranchoperand(JumpLessOrEqual, ((sqInt)0));
  	/* begin MoveCq:R: */
  	anInstruction3 = genoperandoperand(MoveCqR, 0x1F /* numSmallIntegerBits */, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction3)) {
  		(anInstruction3->dependent = locateLiteral(0x1F /* numSmallIntegerBits */));
  	}
  	jmpTarget(jumpInRange, genoperandoperand(ArithmeticShiftRightRR, ClassReg, ReceiverResultReg));
  	genClearAndSetSmallIntegerTagsIn(ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	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()));
  	/* begin genJumpNotSmallInteger:scratchReg: */
  	jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
  	genRemoveSmallIntegerTagsInScratchReg(Arg0Reg);
  	/* begin XorR:R: */
  	genoperandoperand(XorRR, Arg0Reg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpNotSI, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	return CompletePrimitive;
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveClass */
  static sqInt
  genPrimitiveClass(void)
  {
      sqInt reg;
      sqInt reg1;
  
  	reg = ReceiverResultReg;
  	if (methodOrBlockNumArgs > 0) {
  		if (methodOrBlockNumArgs > 1) {
  			return UnimplementedPrimitive;
  		}
  		/* begin genLoadArgAtDepth:into: */
  		reg1 = (reg = Arg0Reg);
  		assert(0 < (numRegArgs()));
  	}
  	if ((genGetClassObjectOfintoscratchRegmayBeAForwarder(reg, ReceiverResultReg, TempReg, reg != ReceiverResultReg)) == BadRegisterSet) {
  		genGetClassObjectOfintoscratchRegmayBeAForwarder(reg, ClassReg, TempReg, reg != ReceiverResultReg);
  		/* begin MoveR:R: */
  		genoperandoperand(MoveRR, ClassReg, ReceiverResultReg);
  	}
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	return UnfailingPrimitive;
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveDiv */
  static sqInt
  genPrimitiveDiv(void)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *anInstruction3;
      AbstractInstruction *convert;
      AbstractInstruction *jumpExact;
      AbstractInstruction *jumpIsSI;
      AbstractInstruction *jumpNotSI;
      AbstractInstruction *jumpSameSign;
      AbstractInstruction *jumpZero;
  
  	if (!(processorHasDivQuoRemAndMClassIsSmallInteger())) {
  		return UnimplementedPrimitive;
  	}
  	/* begin genLoadArgAtDepth:into: */
  	assert(0 < (numRegArgs()));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, Arg0Reg, ClassReg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
  	/* begin genJumpNotSmallInteger:scratchReg: */
  	jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
  	genShiftAwaySmallIntegerTagsInScratchReg(ClassReg);
  	if (!(setsConditionCodesFor(lastOpcode(), JumpZero))) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction = genoperandoperand(CmpCqR, 0, ClassReg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(0));
  		}
  	}
  	/* begin JumpZero: */
  	jumpZero = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ReceiverResultReg, TempReg);
  	genShiftAwaySmallIntegerTagsInScratchReg(TempReg);
  	gDivRRQuoRem(ClassReg, TempReg, TempReg, ClassReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction2 = genoperandoperand(CmpCqR, 0, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(0));
  	}
  	/* begin JumpZero: */
  	jumpExact = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	/* begin XorR:R: */
  	genoperandoperand(XorRR, ClassReg, Arg1Reg);
  	if (!(setsConditionCodesFor(lastOpcode(), JumpZero))) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction1 = genoperandoperand(CmpCqR, 0, Arg1Reg);
  		if (usesOutOfLineLiteral(anInstruction1)) {
  			(anInstruction1->dependent = locateLiteral(0));
  		}
  	}
  	/* begin JumpGreaterOrEqual: */
  	jumpSameSign = genConditionalBranchoperand(JumpGreaterOrEqual, ((sqInt)0));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction3 = genoperandoperand(SubCqR, 1, TempReg);
  	if (usesOutOfLineLiteral(anInstruction3)) {
  		(anInstruction3->dependent = locateLiteral(1));
  	}
  	jmpTarget(jumpSameSign, (convert = genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
  	genConvertIntegerInRegtoSmallIntegerInReg(TempReg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	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()));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, Arg0Reg, ClassReg);
  	/* begin genJumpNotSmallInteger:scratchReg: */
  	jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
  	genShiftAwaySmallIntegerTagsInScratchReg(ClassReg);
  	/* begin JumpZero: */
  	jumpZero = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ReceiverResultReg, TempReg);
  	genShiftAwaySmallIntegerTagsInScratchReg(TempReg);
  	gDivRRQuoRem(ClassReg, TempReg, TempReg, ClassReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(CmpCqR, 0, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(0));
  	}
  	/* begin JumpNonZero: */
  	jumpInexact = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	jumpOverflow = genJumpNotSmallIntegerValuescratch(TempReg, Arg1Reg);
  	genConvertIntegerInRegtoSmallIntegerInReg(TempReg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpOverflow, jmpTarget(jumpInexact, jmpTarget(jumpZero, jmpTarget(jumpNotSI, genoperandoperand(Label, (labelCounter += 1), bytecodePC)))));
  	return CompletePrimitive;
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveEqual */
  static sqInt
  genPrimitiveEqual(void)
  {
  	return (primitiveDoMixedArithmetic()
  		? genSmallIntegerComparisonorDoubleComparisoninvert(JumpZero, gJumpFPEqual, 0)
  		: genSmallIntegerComparison(JumpZero));
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveFloatAdd */
  static sqInt
  genPrimitiveFloatAdd(void)
  {
  	return (primitiveDoMixedArithmetic()
  		? genDoubleArithmeticpreOpCheck(AddRdRd, null)
  		: genPureDoubleArithmeticpreOpCheck(AddRdRd, null));
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveFloatDivide */
  static sqInt
  genPrimitiveFloatDivide(void)
  {
  	return (primitiveDoMixedArithmetic()
  		? genDoubleArithmeticpreOpCheck(DivRdRd, genDoubleFailIfZeroArgRcvrarg)
  		: genPureDoubleArithmeticpreOpCheck(DivRdRd, genDoubleFailIfZeroArgRcvrarg));
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveFloatEqual */
  static sqInt
  genPrimitiveFloatEqual(void)
  {
  	return (primitiveDoMixedArithmetic()
  		? genDoubleComparisoninvert(gJumpFPEqual, 0)
  		: genPureDoubleComparisoninvert(gJumpFPEqual, 0));
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveFloatGreaterOrEqual */
  static sqInt
  genPrimitiveFloatGreaterOrEqual(void)
  {
  	return (primitiveDoMixedArithmetic()
  		? genDoubleComparisoninvert(gJumpFPGreaterOrEqual, 0)
  		: genPureDoubleComparisoninvert(gJumpFPGreaterOrEqual, 0));
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveFloatGreaterThan */
  static sqInt
  genPrimitiveFloatGreaterThan(void)
  {
  	return (primitiveDoMixedArithmetic()
  		? genDoubleComparisoninvert(gJumpFPGreater, 0)
  		: genPureDoubleComparisoninvert(gJumpFPGreater, 0));
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveFloatLessOrEqual */
  static sqInt
  genPrimitiveFloatLessOrEqual(void)
  {
  	return (primitiveDoMixedArithmetic()
  		? genDoubleComparisoninvert(gJumpFPGreaterOrEqual, 1)
  		: genPureDoubleComparisoninvert(gJumpFPGreaterOrEqual, 1));
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveFloatLessThan */
  static sqInt
  genPrimitiveFloatLessThan(void)
  {
  	return (primitiveDoMixedArithmetic()
  		? genDoubleComparisoninvert(gJumpFPGreater, 1)
  		: genPureDoubleComparisoninvert(gJumpFPGreater, 1));
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveFloatMultiply */
  static sqInt
  genPrimitiveFloatMultiply(void)
  {
  	return (primitiveDoMixedArithmetic()
  		? genDoubleArithmeticpreOpCheck(MulRdRd, null)
  		: genPureDoubleArithmeticpreOpCheck(MulRdRd, null));
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveFloatNotEqual */
  static sqInt
  genPrimitiveFloatNotEqual(void)
  {
  	return (primitiveDoMixedArithmetic()
  		? genDoubleComparisoninvert(gJumpFPNotEqual, 0)
  		: genPureDoubleComparisoninvert(gJumpFPNotEqual, 0));
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveFloatSquareRoot */
  static sqInt
  genPrimitiveFloatSquareRoot(void)
  {
      AbstractInstruction *jumpFailAlloc;
  
  
  	/* inline processorHasDoublePrecisionFloatingPointSupport */
  	/* begin hasDoublePrecisionFloatingPointSupport */
  ;
  	genGetDoubleValueOfinto(ReceiverResultReg, DPFPReg0);
  	/* begin SqrtRd: */
  	genoperand(SqrtRd, DPFPReg0);
  	jumpFailAlloc = genAllocFloatValueintoscratchRegscratchReg(DPFPReg0, SendNumArgsReg, ClassReg, TempReg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpFailAlloc, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	return 0;
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveFloatSubtract */
  static sqInt
  genPrimitiveFloatSubtract(void)
  {
  	return (primitiveDoMixedArithmetic()
  		? genDoubleArithmeticpreOpCheck(SubRdRd, null)
  		: genPureDoubleArithmeticpreOpCheck(SubRdRd, null));
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveGreaterOrEqual */
  static sqInt
  genPrimitiveGreaterOrEqual(void)
  {
  	return (primitiveDoMixedArithmetic()
  		? genSmallIntegerComparisonorDoubleComparisoninvert(JumpGreaterOrEqual, gJumpFPGreaterOrEqual, 0)
  		: genSmallIntegerComparison(JumpGreaterOrEqual));
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveGreaterThan */
  static sqInt
  genPrimitiveGreaterThan(void)
  {
  	return (primitiveDoMixedArithmetic()
  		? genSmallIntegerComparisonorDoubleComparisoninvert(JumpGreater, gJumpFPGreater, 0)
  		: genSmallIntegerComparison(JumpGreater));
  }
  
  
  /*	Implementation notes: there are two reasons to use TempReg
  	-1) if primitive fails, ReceiverResultReg must remain unchanged (we
  	CompletePrimitive) -2) CLZ/BSR only work on 64bits for registers R0-R7 on
  	Intel X64. But Win64 uses R9
  	Normally, this should be backEnd dependent, but for now we have a single
  	64bits target...
   */
  
  	/* CogObjectRepresentation>>#genPrimitiveHighBit */
  static sqInt
  genPrimitiveHighBit(void)
  {
      AbstractInstruction *anInstruction1;
      AbstractInstruction *jumpNegativeReceiver;
      AbstractInstruction *jumpNegativeReceiver2;
  
  
  	/* remove excess tag bits from the receiver oop */
  	
  	/* and use the abstract cogit facility for case of single tag-bit */
  	/* begin genHighBitIn:ofSmallIntegerOopWithSingleTagBit: */
  	/* begin genHighBitClzIn:ofSmallIntegerOopWithSingleTagBit: */
  	genoperandoperand(ClzRR, ReceiverResultReg, TempReg);
  	if (!(setsConditionCodesFor(lastOpcode(), JumpZero))) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction1 = genoperandoperand(CmpCqR, 0, TempReg);
  		if (usesOutOfLineLiteral(anInstruction1)) {
  			(anInstruction1->dependent = locateLiteral(0));
  		}
  	}
  
  	/* Note the nice bit trick below:
  	   highBit_1based_of_small_int_value = (BytesPerWord * 8) - leadingZeroCout_of_oop - 1 toAccountForTagBit.
  	   This is like 2 complements (- reg - 1) on (BytesPerWord * 8) log2 bits, or exactly a bit invert operation... */
  	jumpNegativeReceiver2 = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction((BytesPerWord * 8) - 1, genoperandoperand(XorCwR, (BytesPerWord * 8) - 1, TempReg));
  	jumpNegativeReceiver = jumpNegativeReceiver2;
  	goto l6;
  	l6:	/* end genHighBitIn:ofSmallIntegerOopWithSingleTagBit: */;
  	if (jumpNegativeReceiver == 0) {
  		return UnimplementedPrimitive;
  	}
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, TempReg, ReceiverResultReg);
  	genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpNegativeReceiver, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	return CompletePrimitive;
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveIdentical */
  static sqInt
  genPrimitiveIdentical(void)
  {
  	return genPrimitiveIdenticalOrNotIf(0);
  }
  
  
  /*	subclasses override if they can */
  
  	/* CogObjectRepresentation>>#genPrimitiveImmediateAsInteger */
  static sqInt
  genPrimitiveImmediateAsInteger(void)
  {
  	return UnimplementedPrimitive;
  }
  
  
  /*	subclasses override if they can */
  
  	/* CogObjectRepresentation>>#genPrimitiveIntegerAt */
  static sqInt
  genPrimitiveIntegerAt(void)
  {
  	return UnimplementedPrimitive;
  }
  
  
  /*	subclasses override if they can */
  
  	/* CogObjectRepresentation>>#genPrimitiveIntegerAtPut */
  static sqInt
  genPrimitiveIntegerAtPut(void)
  {
  	return UnimplementedPrimitive;
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveLessOrEqual */
  static sqInt
  genPrimitiveLessOrEqual(void)
  {
  	return (primitiveDoMixedArithmetic()
  		? genSmallIntegerComparisonorDoubleComparisoninvert(JumpLessOrEqual, gJumpFPGreaterOrEqual, 1)
  		: genSmallIntegerComparison(JumpLessOrEqual));
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveLessThan */
  static sqInt
  genPrimitiveLessThan(void)
  {
  	return (primitiveDoMixedArithmetic()
  		? genSmallIntegerComparisonorDoubleComparisoninvert(JumpLess, gJumpFPGreater, 1)
  		: genSmallIntegerComparison(JumpLess));
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveMod */
  static sqInt
  genPrimitiveMod(void)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *jumpExact;
      AbstractInstruction *jumpNotSI;
      AbstractInstruction *jumpSameSign;
      AbstractInstruction *jumpZero;
  
  	if (!(processorHasDivQuoRemAndMClassIsSmallInteger())) {
  		return UnimplementedPrimitive;
  	}
  	/* begin genLoadArgAtDepth:into: */
  	assert(0 < (numRegArgs()));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, Arg0Reg, ClassReg);
  	/* begin genJumpNotSmallInteger:scratchReg: */
  	jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
  	genRemoveSmallIntegerTagsInScratchReg(ClassReg);
  	/* begin JumpZero: */
  	jumpZero = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ClassReg, Arg1Reg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ReceiverResultReg, TempReg);
  	genRemoveSmallIntegerTagsInScratchReg(TempReg);
  	gDivRRQuoRem(ClassReg, TempReg, TempReg, ClassReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperand(CmpCqR, 0, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(0));
  	}
  	/* begin JumpZero: */
  	jumpExact = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	/* begin XorR:R: */
  	genoperandoperand(XorRR, ClassReg, Arg1Reg);
  	if (!(setsConditionCodesFor(lastOpcode(), JumpZero))) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction = genoperandoperand(CmpCqR, 0, Arg1Reg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(0));
  		}
  	}
  	/* begin JumpGreaterOrEqual: */
  	jumpSameSign = genConditionalBranchoperand(JumpGreaterOrEqual, ((sqInt)0));
  	/* begin XorR:R: */
  	genoperandoperand(XorRR, ClassReg, Arg1Reg);
  	/* begin AddR:R: */
  	genoperandoperand(AddRR, Arg1Reg, ClassReg);
  	jmpTarget(jumpSameSign, jmpTarget(jumpExact, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
  	genSetSmallIntegerTagsIn(ClassReg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ClassReg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	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()));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, Arg0Reg, ClassReg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ReceiverResultReg, Arg1Reg);
  	/* begin genJumpNotSmallInteger:scratchReg: */
  	jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
  	genShiftAwaySmallIntegerTagsInScratchReg(ClassReg);
  	genRemoveSmallIntegerTagsInScratchReg(Arg1Reg);
  	/* begin MulR:R: */
  	genMulRR(backEnd, Arg1Reg, ClassReg);
  	/* begin JumpOverflow: */
  	jumpOvfl = genConditionalBranchoperand(JumpOverflow, ((sqInt)0));
  	genSetSmallIntegerTagsIn(ClassReg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ClassReg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpOvfl, jmpTarget(jumpNotSI, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
  	return CompletePrimitive;
  }
  
  
  /*	subclasses override if they can */
  
  	/* CogObjectRepresentation>>#genPrimitiveNew */
  static sqInt
  genPrimitiveNew(void)
  {
  	return UnimplementedPrimitive;
  }
  
  
  /*	subclasses override if they can */
  
  	/* CogObjectRepresentation>>#genPrimitiveNewMethod */
  static sqInt
  genPrimitiveNewMethod(void)
  {
  	return UnimplementedPrimitive;
  }
  
  
  /*	subclasses override if they can */
  
  	/* CogObjectRepresentation>>#genPrimitiveNewWithArg */
  static sqInt
  genPrimitiveNewWithArg(void)
  {
  	return UnimplementedPrimitive;
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveNotEqual */
  static sqInt
  genPrimitiveNotEqual(void)
  {
  	return (primitiveDoMixedArithmetic()
  		? genSmallIntegerComparisonorDoubleComparisoninvert(JumpNonZero, gJumpFPNotEqual, 0)
  		: genSmallIntegerComparison(JumpNonZero));
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveNotIdentical */
  static sqInt
  genPrimitiveNotIdentical(void)
  {
  	return genPrimitiveIdenticalOrNotIf(1);
  }
  
  
  /*	subclasses override if they can */
  
  	/* CogObjectRepresentation>>#genPrimitiveObjectAt */
  static sqInt
  genPrimitiveObjectAt(void)
  {
  	return UnimplementedPrimitive;
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveQuo */
  static sqInt
  genPrimitiveQuo(void)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *convert;
      AbstractInstruction *jumpExact;
      AbstractInstruction *jumpIsSI;
      AbstractInstruction *jumpNotSI;
      AbstractInstruction *jumpZero;
  
  	if (!(processorHasDivQuoRemAndMClassIsSmallInteger())) {
  		return UnimplementedPrimitive;
  	}
  	/* begin genLoadArgAtDepth:into: */
  	assert(0 < (numRegArgs()));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, Arg0Reg, ClassReg);
  	/* begin genJumpNotSmallInteger:scratchReg: */
  	jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
  	genShiftAwaySmallIntegerTagsInScratchReg(ClassReg);
  	if (!(setsConditionCodesFor(lastOpcode(), JumpZero))) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction = genoperandoperand(CmpCqR, 0, ClassReg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(0));
  		}
  	}
  	/* begin JumpZero: */
  	jumpZero = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ReceiverResultReg, TempReg);
  	genShiftAwaySmallIntegerTagsInScratchReg(TempReg);
  	gDivRRQuoRem(ClassReg, TempReg, TempReg, ClassReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperand(CmpCqR, 0, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(0));
  	}
  	/* begin JumpZero: */
  	jumpExact = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	/* begin Label */
  	convert = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	genConvertIntegerInRegtoSmallIntegerInReg(TempReg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	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;
  }
  
  
  /*	subclasses override if they can */
  
  	/* CogObjectRepresentation>>#genPrimitiveShallowCopy */
  static sqInt
  genPrimitiveShallowCopy(void)
  {
  	return UnimplementedPrimitive;
  }
  
  
  /*	subclasses override if they can */
  
  	/* CogObjectRepresentation>>#genPrimitiveStringAtPut */
  static sqInt
  genPrimitiveStringAtPut(void)
  {
  	return UnimplementedPrimitive;
  }
  
  
  /*	subclasses override if they can */
  
  	/* CogObjectRepresentation>>#genPrimitiveStringCompareWith */
  static sqInt
  genPrimitiveStringCompareWith(void)
  {
  	return UnimplementedPrimitive;
  }
  
  
  /*	subclasses override if they can */
  
  	/* CogObjectRepresentation>>#genPrimitiveStringReplace */
  static sqInt
  genPrimitiveStringReplace(void)
  {
  	return UnimplementedPrimitive;
  }
  
  	/* CogObjectRepresentation>>#genPrimitiveSubtract */
  static sqInt
  genPrimitiveSubtract(void)
  {
      AbstractInstruction *jumpNotSI;
      AbstractInstruction *jumpOvfl;
  
  	if (!(mclassIsSmallInteger())) {
  		return UnimplementedPrimitive;
  	}
  	/* begin genLoadArgAtDepth:into: */
  	assert(0 < (numRegArgs()));
  	/* begin genJumpNotSmallInteger:scratchReg: */
  	jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ReceiverResultReg, TempReg);
  	/* begin SubR:R: */
  	genoperandoperand(SubRR, Arg0Reg, TempReg);
  	/* begin JumpOverflow: */
  	jumpOvfl = genConditionalBranchoperand(JumpOverflow, ((sqInt)0));
  	genAddSmallIntegerTagsTo(TempReg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, TempReg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpOvfl, jmpTarget(jumpNotSI, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
  	return CompletePrimitive;
  }
  
  
  /*	In the Pure version, mixed arithmetic with SmallInteger is forbidden */
  
  	/* CogObjectRepresentation>>#genPureDoubleArithmetic:preOpCheck: */
  static sqInt NoDbgRegParms
  genPureDoubleArithmeticpreOpCheck(sqInt arithmeticOperator, AbstractInstruction *(*preOpCheckOrNil)(int rcvrReg, int argReg))
  {
      AbstractInstruction *doOp;
      AbstractInstruction *jumpFailAlloc;
      AbstractInstruction *jumpFailCheck;
      AbstractInstruction *jumpFailClass;
      AbstractInstruction *jumpImmediate;
  
  	jumpFailCheck = ((AbstractInstruction *) 0);
  
  	/* inline processorHasDoublePrecisionFloatingPointSupport */
  	/* begin hasDoublePrecisionFloatingPointSupport */
  ;
  	/* begin genLoadArgAtDepth:into: */
  	assert(0 < (numRegArgs()));
  	genGetDoubleValueOfinto(ReceiverResultReg, DPFPReg0);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, Arg0Reg, ClassReg);
  	jumpImmediate = genJumpImmediate(Arg0Reg);
  	genGetCompactClassIndexNonImmOfinto(Arg0Reg, SendNumArgsReg);
  	genCmpClassFloatCompactIndexR(SendNumArgsReg);
  	/* begin JumpNonZero: */
  	jumpFailClass = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	genGetDoubleValueOfinto(Arg0Reg, DPFPReg1);
  	/* begin Label */
  	doOp = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	if (!(preOpCheckOrNil == null)) {
  		jumpFailCheck = preOpCheckOrNil(DPFPReg0, DPFPReg1);
  	}
  	genoperandoperand(arithmeticOperator, DPFPReg1, DPFPReg0);
  	jumpFailAlloc = genAllocFloatValueintoscratchRegscratchReg(DPFPReg0, SendNumArgsReg, ClassReg, TempReg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, SendNumArgsReg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  
  	/* maybeGenConvertIfSmallFloatIn:scratchReg:into:andJumpTo: */
  	jmpTarget(jumpFailAlloc, jmpTarget(jumpFailClass, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
  	if (!(preOpCheckOrNil == null)) {
  		jmpTarget(jumpFailCheck, ((AbstractInstruction *) (((jumpFailClass->operands))[0])));
  	}
  	return 0;
  }
  
  
  /*	In the Pure version, mixed arithmetic with SmallInteger is forbidden */
  
  	/* CogObjectRepresentation>>#genPureDoubleComparison:invert: */
  static sqInt NoDbgRegParms
  genPureDoubleComparisoninvert(AbstractInstruction * NoDbgRegParms (*jumpOpcodeGenerator)(void *), sqInt invertComparison)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *compare;
      sqInt constant;
      AbstractInstruction *jumpCond;
      AbstractInstruction *jumpFail;
      AbstractInstruction *jumpImmediate;
  
  
  	/* inline processorHasDoublePrecisionFloatingPointSupport */
  	/* begin hasDoublePrecisionFloatingPointSupport */
  ;
  	/* begin genLoadArgAtDepth:into: */
  	assert(0 < (numRegArgs()));
  	genGetDoubleValueOfinto(ReceiverResultReg, DPFPReg0);
  	jumpImmediate = genJumpImmediate(Arg0Reg);
  	genGetCompactClassIndexNonImmOfinto(Arg0Reg, SendNumArgsReg);
  	genCmpClassFloatCompactIndexR(SendNumArgsReg);
  	/* begin JumpNonZero: */
  	jumpFail = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	genGetDoubleValueOfinto(Arg0Reg, DPFPReg1);
  	if (invertComparison) {
  
  		/* May need to invert for NaNs */
  		/* begin CmpRd:Rd: */
  		compare = genoperandoperand(CmpRdRd, DPFPReg0, DPFPReg1);
  	}
  	else {
  		/* begin CmpRd:Rd: */
  		compare = genoperandoperand(CmpRdRd, DPFPReg1, DPFPReg0);
  	}
  
  	/* FP jumps are a little weird */
  	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));
  		}
  	}
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpCond, genMoveConstantR(trueObject(), ReceiverResultReg));
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpImmediate, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  
  	/* maybeGenConvertIfSmallFloatIn:scratchReg:into:andJumpTo: */
  	jmpTarget(jumpFail, 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()));
  	/* begin genJumpNotSmallInteger:scratchReg: */
  	jumpFail = genJumpNotSmallInteger(Arg0Reg);
  	/* begin CmpR:R: */
  	assert(!((Arg0Reg == SPReg)));
  	genoperandoperand(CmpRR, Arg0Reg, ReceiverResultReg);
  	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));
  		}
  	}
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpTrue, genMoveConstantR(trueObject(), ReceiverResultReg));
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	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;
      sqInt r;
  
  	r = genSmallIntegerComparison(jumpOpcode);
  	if (r < 0) {
  		return r;
  	}
  	
  #  if defined(DPFPReg0)
  
  	/* Fall through on non-SmallInteger argument.  Argument may be a Float : let us check or fail */
  	genGetCompactClassIndexNonImmOfinto(Arg0Reg, SendNumArgsReg);
  	genCmpClassFloatCompactIndexR(SendNumArgsReg);
  	/* begin JumpNonZero: */
  	jumpFail = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	genConvertSmallIntegerToIntegerInReg(ReceiverResultReg);
  	/* begin ConvertR:Rd: */
  	genoperandoperand(ConvertRRd, ReceiverResultReg, DPFPReg0);
  	genGetDoubleValueOfinto(Arg0Reg, DPFPReg1);
  	if (invertComparison) {
  
  		/* May need to invert for NaNs */
  		/* begin CmpRd:Rd: */
  		genoperandoperand(CmpRdRd, DPFPReg0, DPFPReg1);
  	}
  	else {
  		/* begin CmpRd:Rd: */
  		genoperandoperand(CmpRdRd, DPFPReg1, DPFPReg0);
  	}
  
  	/* FP jumps are a little weird */
  	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));
  		}
  	}
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpCond, genMoveConstantR(trueObject(), ReceiverResultReg));
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpFail, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  #  endif /* defined(DPFPReg0) */
  	return CompletePrimitive;
  }
  
  
  /*	subclasses override if they want, and will have SendNumArgsReg and
  	ClassReg available in addition to ReceiverResultReg and TempReg if they
  	do. 
   */
  
  	/* CogObjectRepresentation>>#getActiveContextAllocatesInMachineCode */
  static sqInt
  getActiveContextAllocatesInMachineCode(void)
  {
  	return 0;
  }
  
  	/* CogObjectRepresentation>>#isUnannotatableConstant: */
  static sqInt NoDbgRegParms
  isUnannotatableConstant(CogSimStackEntry *simStackEntry)
  {
  	return (((simStackEntry->type)) == SSConstant)
  	 && ((isImmediate((simStackEntry->constant)))
  	 || (!(shouldAnnotateObjectReference((simStackEntry->constant)))));
  }
  
  
  /*	Answer if the cacheTag is not unmarked, i.e. answer true for compact
  	class indices and immediates; only answer false for unmarked objects */
  
  	/* CogObjectRepresentationForSqueakV3>>#cacheTagIsMarked: */
  static sqInt NoDbgRegParms
  cacheTagIsMarked(sqInt cacheTag)
  {
  	if (!(couldBeObject(cacheTag))) {
  		return 1;
  	}
  	assert(addressCouldBeObj(cacheTag));
  	return isMarked(cacheTag);
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#checkValidOopReference: */
  static sqInt NoDbgRegParms
  checkValidOopReference(sqInt anOop)
  {
  	return ((anOop & 1))
  	 || ((heapMapAtWord(pointerForOop(anOop))) != 0);
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#classForInlineCacheTag: */
  static sqInt NoDbgRegParms
  classForInlineCacheTag(sqInt inlineCacheTag)
  {
  	if ((inlineCacheTag & 1)) {
  		return classSmallInteger();
  	}
  	if (couldBeObject(inlineCacheTag)) {
  		return inlineCacheTag;
  	}
  	return compactClassAt(((usqInt)(inlineCacheTag)) >> (compactClassFieldLSB()));
  }
  
  
  /*	This is the mask for the field when shifted into the least significant
  	bits 
   */
  
  	/* CogObjectRepresentationForSqueakV3>>#compactClassFieldMask */
  static sqInt
  compactClassFieldMask(void)
  {
  	return (1U << (compactClassFieldWidth())) - 1;
  }
  
  
  /*	Note this version filters-out compact class indices via the >= nilObj
  	clause 
   */
  
  	/* CogObjectRepresentationForSqueakV3>>#couldBeObject: */
  static sqInt NoDbgRegParms
  couldBeObject(sqInt oop)
  {
  	return (isNonIntegerObject(oop))
  	 && (oopisGreaterThanOrEqualTo(oop, nilObject()));
  }
  
  
  /*	Short-circuit the interpreter call if a frame is already married. */
  
  	/* CogObjectRepresentationForSqueakV3>>#genActiveContextTrampoline */
  static usqInt
  genActiveContextTrampoline(void)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *jumpSingle;
  
  	zeroOpcodeIndex();
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperandoperand(MoveMwrR, FoxMethod, FPReg, TempReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(FoxMethod));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperand(AndCqR, MFMethodFlagHasContextFlag, TempReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(MFMethodFlagHasContextFlag));
  	}
  	/* begin JumpZero: */
  	jumpSingle = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction2 = genoperandoperandoperand(MoveMwrR, FoxThisContext, FPReg, ReceiverResultReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(FoxThisContext));
  	}
  	/* begin RetN: */
  	genoperand(RetN, 0);
  	jmpTarget(jumpSingle, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(ceActiveContext, "ceActiveContextTrampoline", 0, null, null, null, null, 0 /* emptyRegisterMask */, 1, ReceiverResultReg, 1);
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#genAddSmallIntegerTagsTo: */
  static sqInt NoDbgRegParms
  genAddSmallIntegerTagsTo(sqInt aRegister)
  {
      AbstractInstruction *anInstruction;
  
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(AddCqR, 1, aRegister);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(1));
  	}
  	return 0;
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#genAllocFloatValue:into:scratchReg:scratchReg: */
  static AbstractInstruction * NoDbgRegParms
  genAllocFloatValueintoscratchRegscratchReg(sqInt dpreg, sqInt resultReg, sqInt scratch1, sqInt scratch2)
  {
      sqInt address;
      sqInt address1;
      sqInt address2;
      usqIntptr_t allocSize;
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *anInstruction3;
      AbstractInstruction *anInstruction4;
      AbstractInstruction *jumpFail;
      usqIntptr_t newFloatHeaderSansHash;
  
  	allocSize = BaseHeaderSize + (sizeof(double));
  	newFloatHeaderSansHash = (((((int)((usqInt)(ClassFloatCompactIndex) << (compactClassFieldLSB())))) | (formatOfClass(classFloat()))) | allocSize) | HeaderTypeShort;
  	/* begin MoveAw:R: */
  	address = freeStartAddress();
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(address, genoperandoperand(MoveAwR, address, resultReg));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperandoperand(LoadEffectiveAddressMwrR, allocSize, resultReg, scratch1);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(allocSize));
  	}
  	/* begin MoveAw:R: */
  	address1 = scavengeThresholdAddress();
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(address1, genoperandoperand(MoveAwR, address1, scratch2));
  	/* begin CmpR:R: */
  	assert(!((scratch2 == SPReg)));
  	genoperandoperand(CmpRR, scratch2, scratch1);
  	/* begin JumpAboveOrEqual: */
  	jumpFail = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt)0));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, resultReg, scratch2);
  	flag("newObjectHash");
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperand(AndCqR, ((int)((usqInt)(HashMaskUnshifted) << BytesPerWord)), scratch2);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(((int)((usqInt)(HashMaskUnshifted) << BytesPerWord))));
  	}
  	/* begin LogicalShiftLeftCq:R: */
  	genoperandoperand(LogicalShiftLeftCqR, HashBitsOffset - BytesPerWord, scratch2);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction2 = genoperandoperand(OrCqR, newFloatHeaderSansHash, scratch2);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(newFloatHeaderSansHash));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction3 = genoperandoperandoperand(MoveRMwr, scratch2, 0, resultReg);
  	if (usesOutOfLineLiteral(anInstruction3)) {
  		(anInstruction3->dependent = locateLiteral(0));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction4 = genoperandoperandoperand(MoveRdM64r, dpreg, BaseHeaderSize, resultReg);
  	if (usesOutOfLineLiteral(anInstruction4)) {
  		(anInstruction4->dependent = locateLiteral(BaseHeaderSize));
  	}
  	/* begin MoveR:Aw: */
  	address2 = freeStartAddress();
  	/* begin gen:operand:literal: */
  	checkLiteralforInstruction(address2, genoperandoperand(MoveRAw, scratch1, address2));
  	return jumpFail;
  }
  
  
  /*	Set the SmallInteger tag bits when the tag bits may be filled with
  	garbage. 
   */
  
  	/* CogObjectRepresentationForSqueakV3>>#genClearAndSetSmallIntegerTagsIn: */
  static sqInt NoDbgRegParms
  genClearAndSetSmallIntegerTagsIn(sqInt scratchReg)
  {
  	return genSetSmallIntegerTagsIn(scratchReg);
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#genConvertIntegerInReg:toSmallIntegerInReg: */
  static sqInt NoDbgRegParms
  genConvertIntegerInRegtoSmallIntegerInReg(sqInt srcReg, sqInt destReg)
  {
      AbstractInstruction *anInstruction;
  
  	gLogicalShiftLeftCqRR(1, srcReg, destReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(AddCqR, 1, destReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(1));
  	}
  	return 0;
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#genConvertIntegerToSmallIntegerInReg: */
  static sqInt NoDbgRegParms
  genConvertIntegerToSmallIntegerInReg(sqInt reg)
  {
      AbstractInstruction *anInstruction;
  
  	/* begin LogicalShiftLeftCq:R: */
  	genoperandoperand(LogicalShiftLeftCqR, 1, reg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(AddCqR, 1, reg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(1));
  	}
  	return 0;
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#genConvertSmallIntegerToIntegerInReg: */
  static sqInt NoDbgRegParms
  genConvertSmallIntegerToIntegerInReg(sqInt reg)
  {
  	/* begin ArithmeticShiftRightCq:R: */
  	genoperandoperand(ArithmeticShiftRightCqR, 1, reg);
  	return 0;
  }
  
  
  /*	Create a closure with the given startpc, numArgs and numCopied
  	within a context with ctxtNumArgs, large if isLargeCtxt that is in a
  	block if isInBlock. If numCopied > 0 pop those values off the stack. */
  /*	see ceClosureCopyDescriptor: */
  
  	/* CogObjectRepresentationForSqueakV3>>#genCreateClosureAt:numArgs:numCopied:contextNumArgs:large:inBlock: */
  static sqInt NoDbgRegParms
  genCreateClosureAtnumArgsnumCopiedcontextNumArgslargeinBlock(sqInt bcpc, sqInt numArgs, sqInt numCopied, sqInt ctxtNumArgs, sqInt isLargeCtxt, sqInt isInBlock)
  {
      AbstractInstruction *abstractInstruction;
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
  
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperand(MoveCqR, (numArgs + (((sqInt)((usqInt)(numCopied) << 6)))) + (((sqInt)((usqInt)(bcpc) << 12))), SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral((numArgs + (((sqInt)((usqInt)(numCopied) << 6)))) + (((sqInt)((usqInt)(bcpc) << 12)))));
  	}
  	/* begin CallRT: */
  	abstractInstruction = genoperand(Call, ceClosureCopyTrampoline);
  	(abstractInstruction->annotation = IsRelativeCall);
  	if (numCopied > 0) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction = genoperandoperand(AddCqR, numCopied * BytesPerWord, SPReg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(numCopied * BytesPerWord));
  		}
  	}
  	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. */
  
  	/* CogObjectRepresentationForSqueakV3>>#generateObjectRepresentationTrampolines */
  static void
  generateObjectRepresentationTrampolines(void)
  {
  	ceStoreCheckTrampoline = genTrampolineForcalledargregsToSaveresult(ceStoreCheck, "ceStoreCheckTrampoline", ReceiverResultReg, ((CallerSavedRegisterMask | (1U << ReceiverResultReg)) - (1U << ReceiverResultReg)), (CallerSavedRegisterMask & (1U << ReceiverResultReg)
  		? ReceiverResultReg
  		: ABIResultReg));
  	ceCreateNewArrayTrampoline = genTrampolineForcalledargregsToSaveresult(ceNewArraySlotSize, "ceCreateNewArrayTrampoline", SendNumArgsReg, ((CallerSavedRegisterMask | (1U << ReceiverResultReg)) - (1U << ReceiverResultReg)), ReceiverResultReg);
  	cePositive32BitIntegerTrampoline = genTrampolineForcalledargregsToSaveresult(positive32BitIntegerFor, "cePositive32BitIntegerTrampoline", ReceiverResultReg, ((CallerSavedRegisterMask | (1U << ReceiverResultReg)) - (1U << ReceiverResultReg)), TempReg);
  	ceActiveContextTrampoline = genActiveContextTrampoline();
  	ceClosureCopyTrampoline = genTrampolineForcalledargregsToSaveresult(ceClosureCopyDescriptor, "ceClosureCopyTrampoline", SendNumArgsReg, ((CallerSavedRegisterMask | (1U << ReceiverResultReg)) - (1U << ReceiverResultReg)), ReceiverResultReg);
  	}
  
  
  /*	Get the active context into ReceiverResultReg, creating it if necessary. */
  
  	/* CogObjectRepresentationForSqueakV3>>#genGetActiveContextNumArgs:large:inBlock: */
  static void NoDbgRegParms
  genGetActiveContextNumArgslargeinBlock(sqInt numArgs, sqInt isLargeContext, sqInt isInBlock)
  {
      AbstractInstruction *abstractInstruction;
  
  	/* begin CallRT: */
  	abstractInstruction = genoperand(Call, ceActiveContextTrampoline);
  	(abstractInstruction->annotation = IsRelativeCall);
  }
  
  
  /*	Fetch the instance's class format into destReg, assuming the object is
  	non-int. 
   */
  
  	/* CogObjectRepresentationForSqueakV3>>#genGetClassFormatOfNonInt:into:scratchReg: */
  static sqInt NoDbgRegParms
  genGetClassFormatOfNonIntintoscratchReg(sqInt instReg, sqInt destReg, sqInt scratchReg)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *anInstruction3;
      AbstractInstruction *jumpCompact;
      AbstractInstruction *jumpGotClass;
      sqInt literal;
      sqInt offset;
      sqInt quickConstant;
      sqInt quickConstant1;
  
  
  	/* Get header word in destReg */
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperandoperand(MoveMwrR, 0, instReg, destReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(0));
  	}
  	/* begin LogicalShiftRightCq:R: */
  	quickConstant = (compactClassFieldLSB()) - (shiftForWord());
  	genoperandoperand(LogicalShiftRightCqR, quickConstant, destReg);
  	/* begin AndCq:R: */
  	quickConstant1 = ((sqInt)((usqInt)(((1U << (compactClassFieldWidth())) - 1)) << (shiftForWord())));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperand(AndCqR, quickConstant1, destReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(quickConstant1));
  	}
  	/* begin JumpNonZero: */
  	jumpCompact = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	/* begin MoveMw:r:R: */
  	offset = classFieldOffset();
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction2 = genoperandoperandoperand(MoveMwrR, offset, instReg, scratchReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(offset));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	literal = ((int) AllButTypeMask);
  	anInstruction3 = genoperandoperand(AndCqR, ((int) AllButTypeMask), scratchReg);
  	if (usesOutOfLineLiteral(anInstruction3)) {
  		(anInstruction3->dependent = locateLiteral(literal));
  	}
  	/* begin Jump: */
  	jumpGotClass = genoperand(Jump, ((sqInt)0));
  	assert(BaseHeaderSize == BytesPerWord);
  	jmpTarget(jumpCompact, annotateobjRef(gMoveMwrR(splObj(CompactClasses), destReg, scratchReg), splObj(CompactClasses)));
  	jmpTarget(jumpGotClass, gMoveMwrR((((int)((usqInt)(InstanceSpecificationIndex) << (shiftForWord())))) + BytesPerWord, scratchReg, destReg));
  	return 0;
  }
  
  
  /*	Fetch the instance's class into destReg. This is almost identical
  	to genGetClassFormatOfNonInt:into:scratchReg: but because we
  	put the fetch of SmallInteger between the then and the else for 
  	compact class/non-compact class we cannot easily share code.
  	instRegIsReceiver is ignored. It is for Spur compatibility where
  	objects may be forwarded. */
  
  	/* CogObjectRepresentationForSqueakV3>>#genGetClassObjectOf:into:scratchReg:mayBeAForwarder: */
  static sqInt NoDbgRegParms
  genGetClassObjectOfintoscratchRegmayBeAForwarder(sqInt instReg, sqInt destReg, sqInt scratchReg, sqInt mayBeAForwarder)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *anInstruction3;
      AbstractInstruction *anInstruction4;
      AbstractInstruction *jumpCompact;
      AbstractInstruction *jumpGotClass;
      AbstractInstruction *jumpGotClass2;
      AbstractInstruction *jumpIsInt;
      sqInt literal;
      sqInt offset;
      sqInt quickConstant;
      sqInt quickConstant1;
  
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, instReg, scratchReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(AndCqR, 1, scratchReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(1));
  	}
  	/* begin JumpNonZero: */
  	jumpIsInt = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperandoperand(MoveMwrR, 0, instReg, scratchReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(0));
  	}
  	/* begin LogicalShiftRightCq:R: */
  	quickConstant = (compactClassFieldLSB()) - (shiftForWord());
  	genoperandoperand(LogicalShiftRightCqR, quickConstant, scratchReg);
  	/* begin AndCq:R: */
  	quickConstant1 = ((sqInt)((usqInt)(((1U << (compactClassFieldWidth())) - 1)) << (shiftForWord())));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction2 = genoperandoperand(AndCqR, quickConstant1, scratchReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(quickConstant1));
  	}
  	/* begin JumpNonZero: */
  	jumpCompact = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	/* begin MoveMw:r:R: */
  	offset = classFieldOffset();
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction3 = genoperandoperandoperand(MoveMwrR, offset, instReg, destReg);
  	if (usesOutOfLineLiteral(anInstruction3)) {
  		(anInstruction3->dependent = locateLiteral(offset));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	literal = ((int) AllButTypeMask);
  	anInstruction4 = genoperandoperand(AndCqR, ((int) AllButTypeMask), destReg);
  	if (usesOutOfLineLiteral(anInstruction4)) {
  		(anInstruction4->dependent = locateLiteral(literal));
  	}
  	/* begin Jump: */
  	jumpGotClass = genoperand(Jump, ((sqInt)0));
  	jmpTarget(jumpIsInt, genMoveConstantR(classSmallInteger(), destReg));
  	/* begin Jump: */
  	jumpGotClass2 = genoperand(Jump, ((sqInt)0));
  	assert(BaseHeaderSize == BytesPerWord);
  	jmpTarget(jumpCompact, annotateobjRef(gMoveMwrR(splObj(CompactClasses), scratchReg, destReg), splObj(CompactClasses)));
  	jmpTarget(jumpGotClass, jmpTarget(jumpGotClass2, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
  	return 0;
  }
  
  
  /*	Compatibility with SpurObjectRepresentation/SpurMemoryManager. */
  
  	/* CogObjectRepresentationForSqueakV3>>#genGetClassTagOf:into:scratchReg: */
  static AbstractInstruction * NoDbgRegParms
  genGetClassTagOfintoscratchReg(sqInt instReg, sqInt destReg, sqInt scratchReg)
  {
      sqInt alignment;
      AbstractInstruction *entryLabel;
  
  	/* begin AlignmentNops: */
  	alignment = ((BytesPerWord < 8) ? 8 : BytesPerWord);
  	genoperand(AlignmentNops, alignment);
  	/* begin Label */
  	entryLabel = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	if ((genGetClassObjectOfintoscratchRegmayBeAForwarder(instReg, destReg, scratchReg, null)) != 0) {
  		error("internal error");
  	}
  	return entryLabel;
  }
  
  
  /*	Fetch the instance's compact class index into destReg. */
  /*	Get header word in scratchReg */
  
  	/* CogObjectRepresentationForSqueakV3>>#genGetCompactClassIndexNonImmOf:into: */
  static sqInt NoDbgRegParms
  genGetCompactClassIndexNonImmOfinto(sqInt instReg, sqInt destReg)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      sqInt quickConstant;
      sqInt quickConstant1;
  
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperandoperand(MoveMwrR, 0, instReg, destReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(0));
  	}
  	/* begin LogicalShiftRightCq:R: */
  	quickConstant = compactClassFieldLSB();
  	genoperandoperand(LogicalShiftRightCqR, quickConstant, destReg);
  	/* begin AndCq:R: */
  	quickConstant1 = (1U << (compactClassFieldWidth())) - 1;
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperand(AndCqR, quickConstant1, destReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(quickConstant1));
  	}
  	return 0;
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#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));
  	}
  	return 0;
  }
  
  
  /*	Fetch the instance's class format into destReg, assuming the object is
  	pointers and non-int
   */
  
  	/* CogObjectRepresentationForSqueakV3>>#genGetFixedFieldsOfPointerNonInt:into:scratchReg: */
  static sqInt NoDbgRegParms
  genGetFixedFieldsOfPointerNonIntintoscratchReg(sqInt instReg, sqInt destReg, sqInt scratchReg)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction2;
  
  	genGetClassFormatOfNonIntintoscratchReg(instReg, destReg, scratchReg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, destReg, scratchReg);
  	/* begin LogicalShiftRightCq:R: */
  	genoperandoperand(LogicalShiftRightCqR, 2, destReg);
  	/* begin LogicalShiftRightCq:R: */
  	genoperandoperand(LogicalShiftRightCqR, 11, scratchReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(AndCqR, 0x3F, destReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(0x3F));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperand(AndCqR, 192, scratchReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(192));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction2 = genoperandoperand(SubCqR, 1, destReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(1));
  	}
  	/* begin AddR:R: */
  	genoperandoperand(AddRR, scratchReg, destReg);
  	return 0;
  }
  
  
  /*	Fetch the instance's identity hash into destReg, encoded as a
  	SmallInteger. 
   */
  /*	Get header word in scratchReg */
  
  	/* CogObjectRepresentationForSqueakV3>>#genGetHashFieldNonImmOf:asSmallIntegerInto: */
  static sqInt NoDbgRegParms
  genGetHashFieldNonImmOfasSmallIntegerInto(sqInt instReg, sqInt destReg)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction2;
  
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperandoperand(MoveMwrR, 0, instReg, destReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(0));
  	}
  	/* begin LogicalShiftRightCq:R: */
  	genoperandoperand(LogicalShiftRightCqR, HashBitsOffset - 1, destReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperand(AndCqR, ((int)((usqInt)(HashMaskUnshifted) << 1)), destReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(((int)((usqInt)(HashMaskUnshifted) << 1))));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction2 = genoperandoperand(AddCqR, 1, destReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(1));
  	}
  	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. The inline cache tag for a given object is the value loaded in
  	inline caches to distinguish
  	objects of different classes. In SqueakV3 the tag is the integer tag bit
  	for SmallIntegers (1),
  	the compact class index shifted by log: 2 word size for objects with
  	compact classes
  	(1 * 4 to: 31 * 4 by: 4), or the class. These ranges cannot overlap
  	because the heap
  	(and hence the lowest class object) is beyond the machine code zone.
  	If forEntry is true answer the entry label at which control is to enter
  	(cmEntryOffset). If forEntry is false, control enters at the start. */
  
  	/* CogObjectRepresentationForSqueakV3>>#genGetInlineCacheClassTagFrom:into:forEntry: */
  static AbstractInstruction * NoDbgRegParms
  genGetInlineCacheClassTagFromintoforEntry(sqInt sourceReg, sqInt destReg, sqInt forEntry)
  {
      sqInt alignment;
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *anInstruction3;
      AbstractInstruction *anInstruction4;
      AbstractInstruction *entryLabel;
      AbstractInstruction *jumpCompact;
      AbstractInstruction *jumpIsInt;
      sqInt literal;
      sqInt offset;
      sqInt quickConstant;
  
  	/* begin AlignmentNops: */
  	alignment = ((BytesPerWord < 8) ? 8 : BytesPerWord);
  	genoperand(AlignmentNops, alignment);
  	/* begin Label */
  	entryLabel = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, sourceReg, destReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(AndCqR, 1, destReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(1));
  	}
  	/* begin JumpNonZero: */
  	jumpIsInt = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperandoperand(MoveMwrR, 0, sourceReg, destReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(0));
  	}
  	assert((((sqInt)((usqInt)((compactClassFieldMask())) << (compactClassFieldLSB())))) < (((usqInt)(nilObject()))));
  	/* begin AndCq:R: */
  	quickConstant = ((sqInt)((usqInt)(((1U << (compactClassFieldWidth())) - 1)) << (compactClassFieldLSB())));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction2 = genoperandoperand(AndCqR, quickConstant, destReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(quickConstant));
  	}
  	/* begin JumpNonZero: */
  	jumpCompact = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	/* begin MoveMw:r:R: */
  	offset = classFieldOffset();
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction3 = genoperandoperandoperand(MoveMwrR, offset, sourceReg, destReg);
  	if (usesOutOfLineLiteral(anInstruction3)) {
  		(anInstruction3->dependent = locateLiteral(offset));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	literal = ((int) AllButTypeMask);
  	anInstruction4 = genoperandoperand(AndCqR, ((int) AllButTypeMask), destReg);
  	if (usesOutOfLineLiteral(anInstruction4)) {
  		(anInstruction4->dependent = locateLiteral(literal));
  	}
  	jmpTarget(jumpCompact, jmpTarget(jumpIsInt, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
  	return entryLabel;
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#genJumpImmediate: */
  static AbstractInstruction * NoDbgRegParms
  genJumpImmediate(sqInt aRegister)
  {
  	return genJumpSmallInteger(aRegister);
  }
  
  
  /*	Generate a test for aRegister containing an integer value in the
  	SmallInteger range, and a jump if so, answering the jump.
  	c.f. ObjectMemory>>isIntegerValue: */
  
  	/* CogObjectRepresentationForSqueakV3>>#genJumpIsSmallIntegerValue:scratch: */
  static AbstractInstruction * NoDbgRegParms
  genJumpIsSmallIntegerValuescratch(sqInt aRegister, sqInt scratchReg)
  {
  	return (gLogicalShiftLeftCqRR(1, aRegister, scratchReg),
  		/* begin XorR:R: */
  		genoperandoperand(XorRR, aRegister, scratchReg),
  		/* begin JumpGreaterOrEqual: */
  		genConditionalBranchoperand(JumpGreaterOrEqual, ((sqInt)0)));
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#genJumpNotSmallIntegerInScratchReg: */
  static AbstractInstruction * NoDbgRegParms
  genJumpNotSmallIntegerInScratchReg(sqInt aRegister)
  {
      AbstractInstruction *anInstruction;
  
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(AndCqR, 1, aRegister);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(1));
  	}
  	/* begin JumpZero: */
  	return genConditionalBranchoperand(JumpZero, ((sqInt)0));
  }
  
  
  /*	Generate a test for aRegister containing an integer value outside the
  	SmallInteger range, and a jump if so, answering the jump.
  	c.f. ObjectMemory>>isIntegerValue: */
  
  	/* CogObjectRepresentationForSqueakV3>>#genJumpNotSmallIntegerValue:scratch: */
  static AbstractInstruction * NoDbgRegParms
  genJumpNotSmallIntegerValuescratch(sqInt aRegister, sqInt scratchReg)
  {
  	return (gArithmeticShiftRightCqRR(1, aRegister, scratchReg),
  		/* begin XorR:R: */
  		genoperandoperand(XorRR, aRegister, scratchReg),
  		/* begin JumpLess: */
  		genConditionalBranchoperand(JumpLess, ((sqInt)0)));
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#genJumpNotSmallInteger: */
  static AbstractInstruction * NoDbgRegParms
  genJumpNotSmallInteger(sqInt aRegister)
  {
      AbstractInstruction *anInstruction;
  
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(TstCqR, 1, aRegister);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(1));
  	}
  	/* begin JumpZero: */
  	return genConditionalBranchoperand(JumpZero, ((sqInt)0));
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#genJumpSmallInteger: */
  static AbstractInstruction * NoDbgRegParms
  genJumpSmallInteger(sqInt aRegister)
  {
      AbstractInstruction *anInstruction;
  
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(TstCqR, 1, aRegister);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(1));
  	}
  	/* begin JumpNonZero: */
  	return genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  }
  
  
  /*	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. */
  
  	/* CogObjectRepresentationForSqueakV3>>#genNewArrayOfSize:initialized: */
  static void NoDbgRegParms
  genNewArrayOfSizeinitialized(sqInt size, sqInt initialized)
  {
      AbstractInstruction *abstractInstruction;
      AbstractInstruction *anInstruction;
  
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(MoveCqR, size, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(size));
  	}
  	/* begin CallRT: */
  	abstractInstruction = genoperand(Call, ceCreateNewArrayTrampoline);
  	(abstractInstruction->annotation = IsRelativeCall);
  }
  
  
  /*	c.f. StackInterpreter>>stSizeOf: lengthOf:baseHeader:format:
  	fixedFieldsOf:format:length: 
   */
  
  	/* CogObjectRepresentationForSqueakV3>>#genPrimitiveAt */
  static sqInt
  genPrimitiveAt(void)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      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 *anInstruction3;
      AbstractInstruction *anInstruction4;
      AbstractInstruction *anInstruction5;
      AbstractInstruction *anInstruction6;
      AbstractInstruction *anInstruction7;
      AbstractInstruction *anInstruction8;
      AbstractInstruction *anInstruction9;
      AbstractInstruction *jmpFmtGeFirstByte;
      AbstractInstruction *jumpBounds;
      AbstractInstruction *jumpFmtEq2;
      AbstractInstruction *jumpFmtGt11;
      AbstractInstruction *jumpFmtGt4;
      AbstractInstruction *jumpFmtIsArray;
      AbstractInstruction *jumpFmtLeWeakArray;
      AbstractInstruction *jumpFmtLt8;
      AbstractInstruction *jumpGotByteSize;
      AbstractInstruction *jumpGotWordSize;
      AbstractInstruction *jumpIsContext;
      AbstractInstruction *jumpIsContext1;
      AbstractInstruction *jumpLarge;
      AbstractInstruction *jumpNotIndexable;
      AbstractInstruction *jumpNotIndexable1;
      AbstractInstruction *jumpNotSI;
      AbstractInstruction *jumpShortHeader;
      AbstractInstruction *jumpSI;
      AbstractInstruction *jumpSkip;
      sqInt literal;
      sqInt quickConstant;
      sqInt quickConstant1;
      sqInt quickConstant2;
      sqInt quickConstant3;
      sqInt quickConstant4;
      sqInt quickConstant5;
      sqInt quickConstant6;
      sqInt quickConstant7;
      sqInt quickConstant8;
      sqInt quickConstant9;
  
  	/* begin genLoadArgAtDepth:into: */
  	assert(0 < (numRegArgs()));
  	jumpSI = genJumpSmallInteger(ReceiverResultReg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
  	jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
  	/* begin genGetSizeOf:into:formatReg:scratchReg:abortJumpsInto: */
  	anInstruction = genoperandoperandoperand(MoveMwrR, 0, ReceiverResultReg, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(0));
  	}
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, SendNumArgsReg, ClassReg);
  	/* begin LogicalShiftRightCq:R: */
  	quickConstant8 = instFormatFieldLSB();
  	genoperandoperand(LogicalShiftRightCqR, quickConstant8, SendNumArgsReg);
  	/* begin AndCq:R: */
  	quickConstant2 = (1U << (instFormatFieldWidth())) - 1;
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperand(AndCqR, quickConstant2, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(quickConstant2));
  	}
  	/* begin CmpCq:R: */
  	quickConstant3 = arrayFormat();
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction2 = genoperandoperand(CmpCqR, quickConstant3, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(quickConstant3));
  	}
  	/* begin JumpLess: */
  	jumpNotIndexable1 = genConditionalBranchoperand(JumpLess, ((sqInt)0));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ClassReg, TempReg);
  	/* begin LogicalShiftRightCq:R: */
  	quickConstant1 = compactClassFieldLSB();
  	genoperandoperand(LogicalShiftRightCqR, quickConstant1, TempReg);
  	/* begin AndCq:R: */
  	quickConstant4 = (1U << (compactClassFieldWidth())) - 1;
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction3 = genoperandoperand(AndCqR, quickConstant4, TempReg);
  	if (usesOutOfLineLiteral(anInstruction3)) {
  		(anInstruction3->dependent = locateLiteral(quickConstant4));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction4 = genoperandoperand(CmpCqR, ClassMethodContextCompactIndex, TempReg);
  	if (usesOutOfLineLiteral(anInstruction4)) {
  		(anInstruction4->dependent = locateLiteral(ClassMethodContextCompactIndex));
  	}
  	/* begin JumpZero: */
  	jumpIsContext1 = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ClassReg, TempReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction5 = genoperandoperand(AndCqR, TypeMask, TempReg);
  	if (usesOutOfLineLiteral(anInstruction5)) {
  		(anInstruction5->dependent = locateLiteral(TypeMask));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction6 = genoperandoperand(CmpCqR, HeaderTypeSizeAndClass, TempReg);
  	if (usesOutOfLineLiteral(anInstruction6)) {
  		(anInstruction6->dependent = locateLiteral(HeaderTypeSizeAndClass));
  	}
  	/* begin JumpNonZero: */
  	jumpShortHeader = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	assert(Size4Bit == 0);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction7 = genoperandoperandoperand(MoveMwrR, 0 - (2 * BytesPerWord), ReceiverResultReg, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction7)) {
  		(anInstruction7->dependent = locateLiteral(0 - (2 * BytesPerWord)));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	literal = ((int) LongSizeMask);
  	anInstruction8 = genoperandoperand(AndCqR, ((int) LongSizeMask), ClassReg);
  	if (usesOutOfLineLiteral(anInstruction8)) {
  		(anInstruction8->dependent = locateLiteral(literal));
  	}
  	/* begin Jump: */
  	jumpSkip = genoperand(Jump, ((sqInt)0));
  	jmpTarget(jumpShortHeader, checkQuickConstantforInstruction(SizeMask, genoperandoperand(AndCqR, SizeMask, ClassReg)));
  	jmpTarget(jumpSkip, checkQuickConstantforInstruction(BaseHeaderSize, genoperandoperand(SubCqR, BaseHeaderSize, ClassReg)));
  	/* begin CmpCq:R: */
  	quickConstant5 = weakArrayFormat();
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction9 = genoperandoperand(CmpCqR, quickConstant5, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction9)) {
  		(anInstruction9->dependent = locateLiteral(quickConstant5));
  	}
  	/* begin JumpLessOrEqual: */
  	jumpFmtLeWeakArray = genConditionalBranchoperand(JumpLessOrEqual, ((sqInt)0));
  	/* begin CmpCq:R: */
  	quickConstant6 = firstByteFormat();
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction10 = genoperandoperand(CmpCqR, quickConstant6, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction10)) {
  		(anInstruction10->dependent = locateLiteral(quickConstant6));
  	}
  	/* begin JumpLess: */
  	jmpFmtGeFirstByte = genConditionalBranchoperand(JumpLess, ((sqInt)0));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction11 = genoperandoperand(AndCqR, 3, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction11)) {
  		(anInstruction11->dependent = locateLiteral(3));
  	}
  	/* begin SubR:R: */
  	genoperandoperand(SubRR, SendNumArgsReg, ClassReg);
  	/* begin Jump: */
  	jumpGotByteSize = genoperand(Jump, ((sqInt)0));
  	jmpTarget(jmpFmtGeFirstByte, genoperandoperand(LogicalShiftRightCqR, 2, ClassReg));
  	/* begin Jump: */
  	jumpGotWordSize = genoperand(Jump, ((sqInt)0));
  	jmpTarget(jumpFmtLeWeakArray, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	/* begin LogicalShiftRightCq:R: */
  	genoperandoperand(LogicalShiftRightCqR, shiftForWord(), ClassReg);
  	/* begin CmpCq:R: */
  	quickConstant7 = arrayFormat();
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction12 = genoperandoperand(CmpCqR, quickConstant7, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction12)) {
  		(anInstruction12->dependent = locateLiteral(quickConstant7));
  	}
  	/* begin JumpZero: */
  	jumpFmtIsArray = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	genGetFixedFieldsOfPointerNonIntintoscratchReg(ReceiverResultReg, SendNumArgsReg, TempReg);
  	/* begin SubR:R: */
  	genoperandoperand(SubRR, SendNumArgsReg, ClassReg);
  	jmpTarget(jumpFmtIsArray, jmpTarget(jumpGotWordSize, jmpTarget(jumpGotByteSize, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
  	jumpNotIndexable = jumpNotIndexable1;
  	jumpIsContext = jumpIsContext1;
  	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction13 = genoperandoperand(SubCqR, 1, Arg1Reg);
  	if (usesOutOfLineLiteral(anInstruction13)) {
  		(anInstruction13->dependent = locateLiteral(1));
  	}
  	/* begin CmpR:R: */
  	assert(!((ClassReg == SPReg)));
  	genoperandoperand(CmpRR, ClassReg, Arg1Reg);
  	/* begin JumpAboveOrEqual: */
  	jumpBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt)0));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction14 = genoperandoperandoperand(MoveMwrR, 0, ReceiverResultReg, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction14)) {
  		(anInstruction14->dependent = locateLiteral(0));
  	}
  	/* begin LogicalShiftRightCq:R: */
  	quickConstant = instFormatFieldLSB();
  	genoperandoperand(LogicalShiftRightCqR, quickConstant, ClassReg);
  	/* begin AndCq:R: */
  	quickConstant9 = (1U << (instFormatFieldWidth())) - 1;
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction15 = genoperandoperand(AndCqR, quickConstant9, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction15)) {
  		(anInstruction15->dependent = locateLiteral(quickConstant9));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction16 = genoperandoperand(CmpCqR, 4, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction16)) {
  		(anInstruction16->dependent = locateLiteral(4));
  	}
  	/* begin JumpGreater: */
  	jumpFmtGt4 = genConditionalBranchoperand(JumpGreater, ((sqInt)0));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction17 = genoperandoperand(CmpCqR, 2, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction17)) {
  		(anInstruction17->dependent = locateLiteral(2));
  	}
  	/* begin JumpZero: */
  	jumpFmtEq2 = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	/* begin AddR:R: */
  	genoperandoperand(AddRR, SendNumArgsReg, Arg1Reg);
  	jmpTarget(jumpFmtEq2, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction18 = genoperandoperand(AddCqR, BaseHeaderSize / BytesPerWord, Arg1Reg);
  	if (usesOutOfLineLiteral(anInstruction18)) {
  		(anInstruction18->dependent = locateLiteral(BaseHeaderSize / BytesPerWord));
  	}
  	/* begin MoveXwr:R:R: */
  	genoperandoperandoperand(MoveXwrRR, Arg1Reg, ReceiverResultReg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpFmtGt4, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction19 = genoperandoperand(CmpCqR, 8, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction19)) {
  		(anInstruction19->dependent = locateLiteral(8));
  	}
  	/* begin JumpLess: */
  	jumpFmtLt8 = genConditionalBranchoperand(JumpLess, ((sqInt)0));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction20 = genoperandoperand(CmpCqR, 11, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction20)) {
  		(anInstruction20->dependent = locateLiteral(11));
  	}
  	/* begin JumpGreater: */
  	jumpFmtGt11 = genConditionalBranchoperand(JumpGreater, ((sqInt)0));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction21 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
  	if (usesOutOfLineLiteral(anInstruction21)) {
  		(anInstruction21->dependent = locateLiteral(BaseHeaderSize));
  	}
  	/* begin MoveXbr:R:R: */
  	genoperandoperandoperand(MoveXbrRR, Arg1Reg, ReceiverResultReg, ReceiverResultReg);
  	genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpFmtLt8, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	assert(BytesPerWord == 4);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction22 = genoperandoperand(AddCqR, BaseHeaderSize / BytesPerWord, Arg1Reg);
  	if (usesOutOfLineLiteral(anInstruction22)) {
  		(anInstruction22->dependent = locateLiteral(BaseHeaderSize / BytesPerWord));
  	}
  	/* begin MoveXwr:R:R: */
  	genoperandoperandoperand(MoveXwrRR, Arg1Reg, ReceiverResultReg, ReceiverResultReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction23 = genoperandoperand(CmpCqR, 0x3FFFFFFF, ReceiverResultReg);
  	if (usesOutOfLineLiteral(anInstruction23)) {
  		(anInstruction23->dependent = locateLiteral(0x3FFFFFFF));
  	}
  	/* begin JumpAbove: */
  	jumpLarge = genConditionalBranchoperand(JumpAbove, ((sqInt)0));
  	genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpLarge, CallRT(cePositive32BitIntegerTrampoline));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, TempReg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpSI, jmpTarget(jumpNotSI, jmpTarget(jumpNotIndexable, jmpTarget(jumpIsContext, jmpTarget(jumpBounds, jmpTarget(jumpFmtGt11, genoperandoperand(Label, (labelCounter += 1), bytecodePC)))))));
  	return 0;
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#genPrimitiveIdenticalOrNotIf: */
  static sqInt NoDbgRegParms
  genPrimitiveIdenticalOrNotIf(sqInt orNot)
  {
      AbstractInstruction *anInstruction;
      sqInt constant;
      AbstractInstruction *jumpCmp;
  
  	/* begin genLoadArgAtDepth:into: */
  	assert(0 < (numRegArgs()));
  	/* begin CmpR:R: */
  	assert(!((Arg0Reg == SPReg)));
  	genoperandoperand(CmpRR, Arg0Reg, ReceiverResultReg);
  	if (orNot) {
  		/* begin JumpZero: */
  		jumpCmp = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	}
  	else {
  		/* begin JumpNonZero: */
  		jumpCmp = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	}
  	/* 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));
  		}
  	}
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpCmp, genMoveConstantR(falseObject(), ReceiverResultReg));
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	return UnfailingPrimitive;
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#genPrimitiveIdentityHash */
  static sqInt
  genPrimitiveIdentityHash(void)
  {
      AbstractInstruction *jumpSI;
  
  	jumpSI = genJumpSmallInteger(ReceiverResultReg);
  	genGetHashFieldNonImmOfasSmallIntegerInto(ReceiverResultReg, TempReg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, TempReg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpSI, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	return 0;
  }
  
  
  /*	c.f. StackInterpreter>>stSizeOf: lengthOf:baseHeader:format:
  	fixedFieldsOf:format:length: 
   */
  
  	/* CogObjectRepresentationForSqueakV3>>#genPrimitiveSize */
  static sqInt
  genPrimitiveSize(void)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction10;
      AbstractInstruction *anInstruction11;
      AbstractInstruction *anInstruction12;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *anInstruction3;
      AbstractInstruction *anInstruction4;
      AbstractInstruction *anInstruction5;
      AbstractInstruction *anInstruction6;
      AbstractInstruction *anInstruction7;
      AbstractInstruction *anInstruction8;
      AbstractInstruction *anInstruction9;
      AbstractInstruction *jmpFmtGeFirstByte;
      AbstractInstruction *jumpFmtIsArray;
      AbstractInstruction *jumpFmtLeWeakArray;
      AbstractInstruction *jumpGotByteSize;
      AbstractInstruction *jumpGotWordSize;
      AbstractInstruction *jumpIsContext;
      AbstractInstruction *jumpIsContext1;
      AbstractInstruction *jumpNotIndexable;
      AbstractInstruction *jumpNotIndexable1;
      AbstractInstruction *jumpShortHeader;
      AbstractInstruction *jumpSI;
      AbstractInstruction *jumpSkip;
      sqInt literal;
      sqInt quickConstant;
      sqInt quickConstant1;
      sqInt quickConstant2;
      sqInt quickConstant3;
      sqInt quickConstant4;
      sqInt quickConstant5;
      sqInt quickConstant6;
      sqInt quickConstant7;
  
  	jumpSI = genJumpSmallInteger(ReceiverResultReg);
  	/* begin genGetSizeOf:into:formatReg:scratchReg:abortJumpsInto: */
  	anInstruction = genoperandoperandoperand(MoveMwrR, 0, ReceiverResultReg, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(0));
  	}
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, SendNumArgsReg, ClassReg);
  	/* begin LogicalShiftRightCq:R: */
  	quickConstant = instFormatFieldLSB();
  	genoperandoperand(LogicalShiftRightCqR, quickConstant, SendNumArgsReg);
  	/* begin AndCq:R: */
  	quickConstant2 = (1U << (instFormatFieldWidth())) - 1;
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperand(AndCqR, quickConstant2, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(quickConstant2));
  	}
  	/* begin CmpCq:R: */
  	quickConstant3 = arrayFormat();
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction2 = genoperandoperand(CmpCqR, quickConstant3, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(quickConstant3));
  	}
  	/* begin JumpLess: */
  	jumpNotIndexable1 = genConditionalBranchoperand(JumpLess, ((sqInt)0));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ClassReg, TempReg);
  	/* begin LogicalShiftRightCq:R: */
  	quickConstant1 = compactClassFieldLSB();
  	genoperandoperand(LogicalShiftRightCqR, quickConstant1, TempReg);
  	/* begin AndCq:R: */
  	quickConstant4 = (1U << (compactClassFieldWidth())) - 1;
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction3 = genoperandoperand(AndCqR, quickConstant4, TempReg);
  	if (usesOutOfLineLiteral(anInstruction3)) {
  		(anInstruction3->dependent = locateLiteral(quickConstant4));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction4 = genoperandoperand(CmpCqR, ClassMethodContextCompactIndex, TempReg);
  	if (usesOutOfLineLiteral(anInstruction4)) {
  		(anInstruction4->dependent = locateLiteral(ClassMethodContextCompactIndex));
  	}
  	/* begin JumpZero: */
  	jumpIsContext1 = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ClassReg, TempReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction5 = genoperandoperand(AndCqR, TypeMask, TempReg);
  	if (usesOutOfLineLiteral(anInstruction5)) {
  		(anInstruction5->dependent = locateLiteral(TypeMask));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction6 = genoperandoperand(CmpCqR, HeaderTypeSizeAndClass, TempReg);
  	if (usesOutOfLineLiteral(anInstruction6)) {
  		(anInstruction6->dependent = locateLiteral(HeaderTypeSizeAndClass));
  	}
  	/* begin JumpNonZero: */
  	jumpShortHeader = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	assert(Size4Bit == 0);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction7 = genoperandoperandoperand(MoveMwrR, 0 - (2 * BytesPerWord), ReceiverResultReg, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction7)) {
  		(anInstruction7->dependent = locateLiteral(0 - (2 * BytesPerWord)));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	literal = ((int) LongSizeMask);
  	anInstruction8 = genoperandoperand(AndCqR, ((int) LongSizeMask), ClassReg);
  	if (usesOutOfLineLiteral(anInstruction8)) {
  		(anInstruction8->dependent = locateLiteral(literal));
  	}
  	/* begin Jump: */
  	jumpSkip = genoperand(Jump, ((sqInt)0));
  	jmpTarget(jumpShortHeader, checkQuickConstantforInstruction(SizeMask, genoperandoperand(AndCqR, SizeMask, ClassReg)));
  	jmpTarget(jumpSkip, checkQuickConstantforInstruction(BaseHeaderSize, genoperandoperand(SubCqR, BaseHeaderSize, ClassReg)));
  	/* begin CmpCq:R: */
  	quickConstant5 = weakArrayFormat();
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction9 = genoperandoperand(CmpCqR, quickConstant5, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction9)) {
  		(anInstruction9->dependent = locateLiteral(quickConstant5));
  	}
  	/* begin JumpLessOrEqual: */
  	jumpFmtLeWeakArray = genConditionalBranchoperand(JumpLessOrEqual, ((sqInt)0));
  	/* begin CmpCq:R: */
  	quickConstant6 = firstByteFormat();
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction10 = genoperandoperand(CmpCqR, quickConstant6, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction10)) {
  		(anInstruction10->dependent = locateLiteral(quickConstant6));
  	}
  	/* begin JumpLess: */
  	jmpFmtGeFirstByte = genConditionalBranchoperand(JumpLess, ((sqInt)0));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction11 = genoperandoperand(AndCqR, 3, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction11)) {
  		(anInstruction11->dependent = locateLiteral(3));
  	}
  	/* begin SubR:R: */
  	genoperandoperand(SubRR, SendNumArgsReg, ClassReg);
  	/* begin Jump: */
  	jumpGotByteSize = genoperand(Jump, ((sqInt)0));
  	jmpTarget(jmpFmtGeFirstByte, genoperandoperand(LogicalShiftRightCqR, 2, ClassReg));
  	/* begin Jump: */
  	jumpGotWordSize = genoperand(Jump, ((sqInt)0));
  	jmpTarget(jumpFmtLeWeakArray, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	/* begin LogicalShiftRightCq:R: */
  	genoperandoperand(LogicalShiftRightCqR, shiftForWord(), ClassReg);
  	/* begin CmpCq:R: */
  	quickConstant7 = arrayFormat();
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction12 = genoperandoperand(CmpCqR, quickConstant7, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction12)) {
  		(anInstruction12->dependent = locateLiteral(quickConstant7));
  	}
  	/* begin JumpZero: */
  	jumpFmtIsArray = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	genGetFixedFieldsOfPointerNonIntintoscratchReg(ReceiverResultReg, SendNumArgsReg, TempReg);
  	/* begin SubR:R: */
  	genoperandoperand(SubRR, SendNumArgsReg, ClassReg);
  	jmpTarget(jumpFmtIsArray, jmpTarget(jumpGotWordSize, jmpTarget(jumpGotByteSize, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
  	jumpNotIndexable = jumpNotIndexable1;
  	jumpIsContext = jumpIsContext1;
  	genConvertIntegerInRegtoSmallIntegerInReg(ClassReg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpSI, jmpTarget(jumpNotIndexable, jmpTarget(jumpIsContext, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
  	return 0;
  }
  
  
  /*	c.f. StackInterpreter>>stSizeOf: lengthOf:baseHeader:format:
  	fixedFieldsOf:format:length: 
   */
  
  	/* CogObjectRepresentationForSqueakV3>>#genPrimitiveStringAt */
  static sqInt
  genPrimitiveStringAt(void)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction10;
      AbstractInstruction *anInstruction11;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *anInstruction3;
      AbstractInstruction *anInstruction4;
      AbstractInstruction *anInstruction5;
      AbstractInstruction *anInstruction6;
      AbstractInstruction *anInstruction7;
      AbstractInstruction *anInstruction8;
      AbstractInstruction *anInstruction9;
      sqInt constant;
      AbstractInstruction *jumpBounds;
      AbstractInstruction *jumpNotByteIndexable;
      AbstractInstruction *jumpNotSI;
      AbstractInstruction *jumpShortHeader;
      AbstractInstruction *jumpSkip;
      sqInt literal;
      sqInt quickConstant;
      sqInt quickConstant1;
  
  	/* begin genLoadArgAtDepth:into: */
  	assert(0 < (numRegArgs()));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, Arg0Reg, Arg1Reg);
  	jumpNotSI = genJumpNotSmallInteger(Arg0Reg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperandoperand(MoveMwrR, 0, ReceiverResultReg, TempReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(0));
  	}
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, TempReg, ClassReg);
  	/* begin LogicalShiftRightCq:R: */
  	quickConstant = instFormatFieldLSB();
  	genoperandoperand(LogicalShiftRightCqR, quickConstant, TempReg);
  	/* begin AndCq:R: */
  	quickConstant1 = (1U << (instFormatFieldWidth())) - 1;
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperand(AndCqR, quickConstant1, TempReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(quickConstant1));
  	}
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, TempReg, SendNumArgsReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction2 = genoperandoperand(AndCqR, 3, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(3));
  	}
  	/* begin SubR:R: */
  	genoperandoperand(SubRR, SendNumArgsReg, TempReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction3 = genoperandoperand(CmpCqR, 8, TempReg);
  	if (usesOutOfLineLiteral(anInstruction3)) {
  		(anInstruction3->dependent = locateLiteral(8));
  	}
  	/* begin JumpNonZero: */
  	jumpNotByteIndexable = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ClassReg, TempReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction4 = genoperandoperand(AndCqR, TypeMask, TempReg);
  	if (usesOutOfLineLiteral(anInstruction4)) {
  		(anInstruction4->dependent = locateLiteral(TypeMask));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction5 = genoperandoperand(CmpCqR, HeaderTypeSizeAndClass, TempReg);
  	if (usesOutOfLineLiteral(anInstruction5)) {
  		(anInstruction5->dependent = locateLiteral(HeaderTypeSizeAndClass));
  	}
  	/* begin JumpNonZero: */
  	jumpShortHeader = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	assert(Size4Bit == 0);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction6 = genoperandoperandoperand(MoveMwrR, 0 - (2 * BytesPerWord), ReceiverResultReg, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction6)) {
  		(anInstruction6->dependent = locateLiteral(0 - (2 * BytesPerWord)));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	literal = ((int) LongSizeMask);
  	anInstruction7 = genoperandoperand(AndCqR, ((int) LongSizeMask), ClassReg);
  	if (usesOutOfLineLiteral(anInstruction7)) {
  		(anInstruction7->dependent = locateLiteral(literal));
  	}
  	/* begin Jump: */
  	jumpSkip = genoperand(Jump, ((sqInt)0));
  	jmpTarget(jumpShortHeader, checkQuickConstantforInstruction(SizeMask, genoperandoperand(AndCqR, SizeMask, ClassReg)));
  	jmpTarget(jumpSkip, checkQuickConstantforInstruction(BaseHeaderSize, genoperandoperand(SubCqR, BaseHeaderSize, ClassReg)));
  	/* begin SubR:R: */
  	genoperandoperand(SubRR, SendNumArgsReg, ClassReg);
  	genConvertSmallIntegerToIntegerInReg(Arg1Reg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction8 = genoperandoperand(SubCqR, 1, Arg1Reg);
  	if (usesOutOfLineLiteral(anInstruction8)) {
  		(anInstruction8->dependent = locateLiteral(1));
  	}
  	/* begin CmpR:R: */
  	assert(!((ClassReg == SPReg)));
  	genoperandoperand(CmpRR, ClassReg, Arg1Reg);
  	/* begin JumpAboveOrEqual: */
  	jumpBounds = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt)0));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction9 = genoperandoperand(AddCqR, BaseHeaderSize, Arg1Reg);
  	if (usesOutOfLineLiteral(anInstruction9)) {
  		(anInstruction9->dependent = locateLiteral(BaseHeaderSize));
  	}
  	/* begin genMoveConstant:R: */
  	constant = characterTable();
  	if (shouldAnnotateObjectReference(constant)) {
  		annotateobjRef(gMoveCwR(constant, Arg0Reg), constant);
  	}
  	else {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction11 = genoperandoperand(MoveCqR, constant, Arg0Reg);
  		if (usesOutOfLineLiteral(anInstruction11)) {
  			(anInstruction11->dependent = locateLiteral(constant));
  		}
  	}
  	/* begin MoveXbr:R:R: */
  	genoperandoperandoperand(MoveXbrRR, Arg1Reg, ReceiverResultReg, ReceiverResultReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction10 = genoperandoperand(AddCqR, BaseHeaderSize / BytesPerWord, ReceiverResultReg);
  	if (usesOutOfLineLiteral(anInstruction10)) {
  		(anInstruction10->dependent = locateLiteral(BaseHeaderSize / BytesPerWord));
  	}
  	/* begin MoveXwr:R:R: */
  	genoperandoperandoperand(MoveXwrRR, ReceiverResultReg, Arg0Reg, ReceiverResultReg);
  	if (methodOrBlockNumArgs <= 1 /* numRegArgs */) {
  		/* begin RetN: */
  		genoperand(RetN, 0);
  	}
  	else {
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	jmpTarget(jumpNotSI, jmpTarget(jumpNotByteIndexable, jmpTarget(jumpBounds, genoperandoperand(Label, (labelCounter += 1), bytecodePC))));
  	return 0;
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#genRemoveSmallIntegerTagsInScratchReg: */
  static sqInt NoDbgRegParms
  genRemoveSmallIntegerTagsInScratchReg(sqInt scratchReg)
  {
      AbstractInstruction *anInstruction;
  
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(SubCqR, 1, scratchReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(1));
  	}
  	return 0;
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#genSetSmallIntegerTagsIn: */
  static sqInt NoDbgRegParms
  genSetSmallIntegerTagsIn(sqInt scratchReg)
  {
      AbstractInstruction *anInstruction;
  
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(OrCqR, 1, scratchReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(1));
  	}
  	return 0;
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#genShiftAwaySmallIntegerTagsInScratchReg: */
  static sqInt NoDbgRegParms
  genShiftAwaySmallIntegerTagsInScratchReg(sqInt scratchReg)
  {
  	/* begin ArithmeticShiftRightCq:R: */
  	genoperandoperand(ArithmeticShiftRightCqR, 1, scratchReg);
  	return 0;
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#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 *abstractInstruction1;
      sqInt address;
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction2;
      AbstractInstruction * inst;
      AbstractInstruction *jmpAlreadyRoot;
      AbstractInstruction *jmpDestYoung;
      AbstractInstruction *jmpImmediate;
      AbstractInstruction *jmpSourceOld;
      sqInt mask;
      sqInt rootBitByteOffset;
  
  	/* begin genTraceStores */
  	if (traceStores > 0) {
  		/* begin MoveR:R: */
  		genoperandoperand(MoveRR, ClassReg, TempReg);
  		/* begin CallRT: */
  		abstractInstruction1 = genoperand(Call, ceTraceStoreTrampoline);
  		(abstractInstruction1->annotation = IsRelativeCall);
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperandoperand(MoveRMwr, sourceReg, (index * BytesPerWord) + BaseHeaderSize, destReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral((index * BytesPerWord) + BaseHeaderSize));
  	}
  	if (!needsStoreCheck) {
  		return 0;
  	}
  
  	/* Get the old/new boundary in scratchReg */
  	jmpImmediate = genJumpImmediate(sourceReg);
  	/* begin MoveAw:R: */
  	address = youngStartAddress();
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(address, genoperandoperand(MoveAwR, address, scratchReg));
  	/* begin CmpR:R: */
  	assert(!((scratchReg == SPReg)));
  	genoperandoperand(CmpRR, scratchReg, destReg);
  	/* begin JumpAboveOrEqual: */
  	jmpDestYoung = genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt)0));
  	/* begin CmpR:R: */
  	assert(!((scratchReg == SPReg)));
  	genoperandoperand(CmpRR, scratchReg, sourceReg);
  	/* begin JumpBelow: */
  	jmpSourceOld = genConditionalBranchoperand(JumpBelow, ((sqInt)0));
  	rootBitByteOffset = RootBitDigitLength - 1;
  	mask = ((usqInt)(RootBit)) >> ((RootBitDigitLength - 1) * 8);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperandoperand(MoveMbrR, rootBitByteOffset, destReg, scratchReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(rootBitByteOffset));
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction2 = genoperandoperand(AndCqR, mask, scratchReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(mask));
  	}
  	/* begin JumpNonZero: */
  	jmpAlreadyRoot = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	assert(destReg == ReceiverResultReg);
  	/* begin evaluateTrampolineCallBlock:protectLinkRegIfNot: */
  	if (inFrame) {
  		/* begin CallRT: */
  		abstractInstruction = genoperand(Call, ceStoreCheckTrampoline);
  		(abstractInstruction->annotation = IsRelativeCall);
  	}
  	else {
  		/* begin saveAndRestoreLinkRegAround: */
  		inst = genoperand(PushR, LinkReg);
  		/* begin CallRT: */
  		abstractInstruction = genoperand(Call, ceStoreCheckTrampoline);
  		(abstractInstruction->annotation = IsRelativeCall);
  		genoperand(PopR, LinkReg);
  	}
  	jmpTarget(jmpImmediate, jmpTarget(jmpDestYoung, jmpTarget(jmpSourceOld, jmpTarget(jmpAlreadyRoot, genoperandoperand(Label, (labelCounter += 1), bytecodePC)))));
  	return 0;
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#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));
  	}
  	return 0;
  }
  
  
  /*	Answer the relevant inline cache tag for an instance.
  	c.f. getInlineCacheClassTagFrom:into: & inlineCacheTagForClass: */
  
  	/* CogObjectRepresentationForSqueakV3>>#inlineCacheTagForInstance: */
  static sqInt NoDbgRegParms
  inlineCacheTagForInstance(sqInt oop)
  {
      sqInt cci;
  
  	if ((oop & 1)) {
  		return (((usqInt)0 << 1) | 1);
  	}
  	if (((cci = noShiftCompactClassIndexOf(oop))) > 0) {
  		return cci;
  	}
  	return (classHeader(oop)) & AllButTypeMask;
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#inlineCacheTagIsYoung: */
  static sqInt NoDbgRegParms
  inlineCacheTagIsYoung(sqInt cacheTag)
  {
  	return isYoung(cacheTag);
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#markAndTraceLiteralIfYoung: */
  static void NoDbgRegParms
  markAndTraceLiteralIfYoung(sqInt literal)
  {
  	if ((couldBeObject(literal))
  	 && (isYoungObject(literal))) {
  		assert(addressCouldBeObj(literal));
  		markAndTrace(literal);
  	}
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#markAndTraceLiteral: */
  static void NoDbgRegParms
  markAndTraceLiteral(sqInt literal)
  {
  	if (couldBeObject(literal)) {
  		assert(addressCouldBeObj(literal));
  		markAndTrace(literal);
  	}
  }
  
  
  /*	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). CogObjectRepresentationForSqueakV3 only implements
  	at most 1-arg primitives, because the complexity of the object
  	representation makes it difficult to implement at:put:, the most
  	performance-critical 2-argument
  	primitive.. 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.  */
  
  	/* CogObjectRepresentationForSqueakV3>>#numRegArgs */
  sqInt
  numRegArgs(void)
  {
  	return 1;
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#remapObject: */
  static sqInt NoDbgRegParms
  remapObject(sqInt objOop)
  {
  	assert(addressCouldBeObj(objOop));
  	return remap(objOop);
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#remapOop: */
  static sqInt NoDbgRegParms
  remapOop(sqInt oop)
  {
  	return ((oop & 1)
  		? oop
  		: remap(oop));
  }
  
  
  /*	self assert: ((objectMemory isIntegerObject: anOop)
  	or: [objectMemory addressCouldBeObj: anOop]). */
  
  	/* CogObjectRepresentationForSqueakV3>>#shouldAnnotateObjectReference: */
  static sqInt NoDbgRegParms
  shouldAnnotateObjectReference(sqInt anOop)
  {
  	return (isNonIntegerObject(anOop))
  	 && (oopisGreaterThan(anOop, trueObject()));
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#slotOffsetOfInstVarIndex: */
  static sqInt NoDbgRegParms
  slotOffsetOfInstVarIndex(sqInt index)
  {
  	return (index * BytesPerWord) + BaseHeaderSize;
  }
  
  	/* CogObjectRepresentationForSqueakV3>>#validInlineCacheTag: */
  static sqInt NoDbgRegParms
  validInlineCacheTag(sqInt cacheTag)
  {
  	return (cacheTag == ConstZero)
  	 || ((((cacheTag & ((1U << (shiftForWord())) - 1)) == 0)
  	 && (((cacheTag >= (1U << (compactClassFieldLSB()))) && (cacheTag <= (((sqInt)((usqInt)((compactClassIndexOfHeader(-1))) << (compactClassFieldLSB()))))))))
  	 || (checkValidObjectReference(cacheTag)));
  }
  
  	/* CogOutOfLineLiteralsARMCompiler>>#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. */
  
  	/* CogOutOfLineLiteralsARMCompiler>>#concretizeLiteral */
  static sqInt NoDbgRegParms
  concretizeLiteral(AbstractInstruction * self_in_concretizeLiteral)
  {
      usqInt literal;
      AbstractInstruction * literalAsInstruction;
  
  	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)) == null)) {
  		assert(((self_in_concretizeLiteral->annotation)) == null);
  		(self_in_concretizeLiteral->annotation) = (((self_in_concretizeLiteral->dependent))->annotation);
  	}
  	if (!(((((self_in_concretizeLiteral->dependent))->address)) == null)) {
  		assert(((((self_in_concretizeLiteral->dependent))->address)) == ((self_in_concretizeLiteral->address)));
  	}
  	(((self_in_concretizeLiteral->dependent))->address = (self_in_concretizeLiteral->address));
  	/* begin machineCodeAt:put: */
  	((self_in_concretizeLiteral->machineCode))[0 / 4] = literal;
  	return 4;
  }
  
  	/* CogOutOfLineLiteralsARMCompiler>>#inlineCacheTagAt: */
  static sqInt NoDbgRegParms
  inlineCacheTagAt(AbstractInstruction * self_in_inlineCacheTagAt, sqInt callSiteReturnAddress)
  {
  	return longAt(pcRelativeAddressAt(self_in_inlineCacheTagAt, ((usqInt)(callSiteReturnAddress - 8))));
  }
  
  
  /*	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. */
  
  	/* CogOutOfLineLiteralsARMCompiler>>#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. 
   */
  
  	/* CogOutOfLineLiteralsARMCompiler>>#literalBeforeFollowingAddress: */
  static sqInt NoDbgRegParms
  literalBeforeFollowingAddress(AbstractInstruction * self_in_literalBeforeFollowingAddress, sqInt followingAddress)
  {
  	return longAt(pcRelativeAddressAt(self_in_literalBeforeFollowingAddress, (instructionIsLDR(self_in_literalBeforeFollowingAddress, longAt(followingAddress - 4))
  		? (/* begin instructionAddressBefore: */
  			followingAddress - 4)
  		: (/* begin instructionAddressBefore: */
  			(followingAddress - 4) - 4))));
  }
  
  
  /*	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.
   */
  
  	/* CogOutOfLineLiteralsARMCompiler>>#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
   */
  
  	/* CogOutOfLineLiteralsARMCompiler>>#loadLiteralByteSize */
  static sqInt NoDbgRegParms
  loadLiteralByteSize(AbstractInstruction * self_in_loadLiteralByteSize)
  {
  	return 4;
  }
  
  
  /*	Answer the maximum number of bytes of machine code generated for any
  	abstract instruction.
   */
  
  	/* CogOutOfLineLiteralsARMCompiler>>#machineCodeBytes */
  static sqInt NoDbgRegParms
  machineCodeBytes(AbstractInstruction * self_in_machineCodeBytes)
  {
  	return 8;
  }
  
  
  /*	Answer the NSSendCache for the return address of a Newspeak
  	self, super, outer, or implicit receiver send. */
  
  	/* CogOutOfLineLiteralsARMCompiler>>#nsSendCacheAt: */
  static sqInt NoDbgRegParms
  nsSendCacheAt(AbstractInstruction * self_in_nsSendCacheAt, sqInt callSiteReturnAddress)
  {
  	return longAt(pcRelativeAddressAt(self_in_nsSendCacheAt, ((usqInt)(callSiteReturnAddress - 8))));
  }
  
  
  /*	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.. */
  
  	/* CogOutOfLineLiteralsARMCompiler>>#outOfLineLiteralOpcodeLimit */
  static sqInt NoDbgRegParms
  outOfLineLiteralOpcodeLimit(AbstractInstruction * self_in_outOfLineLiteralOpcodeLimit)
  {
  	return 0x1FF;
  }
  
  
  /*	Extract the address of the ldr rX, [pc, #NNN] instruction at address */
  
  	/* CogOutOfLineLiteralsARMCompiler>>#pcRelativeAddressAt: */
  static sqInt NoDbgRegParms
  pcRelativeAddressAt(AbstractInstruction * self_in_pcRelativeAddressAt, sqInt instrAddress)
  {
      sqInt inst;
      sqInt offset;
  
  	inst = longAt(instrAddress);
  	assert((inst & 4284416000U) == (ldrrnplusimm(self_in_pcRelativeAddressAt, 0, PC, 0, 0)));
  	offset = inst & 0xFFF;
  	return (instrAddress + 8) + ((inst & (0x800000)
  	? offset
  	: -offset));
  }
  
  
  /*	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. */
  
  	/* CogOutOfLineLiteralsARMCompiler>>#relocateMethodReferenceBeforeAddress:by: */
  static AbstractInstruction * NoDbgRegParms
  relocateMethodReferenceBeforeAddressby(AbstractInstruction * self_in_relocateMethodReferenceBeforeAddressby, sqInt pc, sqInt delta)
  {
      sqInt litAddr;
      sqInt pcPrecedingLoad;
      sqInt reference;
  
  
  	/* If the load is not done via pc-relative addressing we have to relocate. */
  	pcPrecedingLoad = (instructionIsPush(self_in_relocateMethodReferenceBeforeAddressby, longAt(pc - 4))
  		? pc - 4
  		: pc);
  	if (!(isPCRelativeValueLoad(self_in_relocateMethodReferenceBeforeAddressby, longAt(pcPrecedingLoad - 4)))) {
  		litAddr = pcRelativeAddressAt(self_in_relocateMethodReferenceBeforeAddressby, pcPrecedingLoad);
  		reference = longAt(litAddr);
  		longAtput(litAddr, reference + delta);
  	}
  	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. 
   */
  
  	/* CogOutOfLineLiteralsARMCompiler>>#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. */
  
  	/* CogOutOfLineLiteralsARMCompiler>>#rewriteInlineCacheAt:tag:target: */
  static sqInt NoDbgRegParms
  rewriteInlineCacheAttagtarget(AbstractInstruction * self_in_rewriteInlineCacheAttagtarget, usqInt callSiteReturnAddress, sqInt cacheTag, usqInt callTargetAddress)
  {
      sqInt call;
      usqInt callDistance;
  
  	if (!(callTargetAddress >= (minCallAddress()))) {
  		error("linking callsite to invalid address");
  	}
  
  	/* pc offset */
  	/* return offset */
  	callDistance = ((usqInt) (callTargetAddress - ((callSiteReturnAddress + 8) - 4)));
  	assert(isInImmediateJumpRange(self_in_rewriteInlineCacheAttagtarget, callDistance));
  	call = bl(self_in_rewriteInlineCacheAttagtarget, callDistance);
  	longAtput(callSiteReturnAddress - 4, call);
  	longAtput(pcRelativeAddressAt(self_in_rewriteInlineCacheAttagtarget, callSiteReturnAddress - 8), cacheTag);
  	assert((inlineCacheTagAt(self_in_rewriteInlineCacheAttagtarget, callSiteReturnAddress)) == cacheTag);
  	return 4;
  }
  
  
  /*	Rewrite an inline cache with a new tag. This variant is used
  	by the garbage collector. */
  
  	/* CogOutOfLineLiteralsARMCompiler>>#rewriteInlineCacheTag:at: */
  static AbstractInstruction * NoDbgRegParms
  rewriteInlineCacheTagat(AbstractInstruction * self_in_rewriteInlineCacheTagat, sqInt cacheTag, sqInt callSiteReturnAddress)
  {
  	longAtput(pcRelativeAddressAt(self_in_rewriteInlineCacheTagat, callSiteReturnAddress - 8), cacheTag);
  	return self_in_rewriteInlineCacheTagat;
  }
  
  
  /*	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. */
  
  	/* CogOutOfLineLiteralsARMCompiler>>#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. 
   */
  
  	/* CogOutOfLineLiteralsARMCompiler>>#storeLiteral:beforeFollowingAddress: */
  static AbstractInstruction * NoDbgRegParms
  storeLiteralbeforeFollowingAddress(AbstractInstruction * self_in_storeLiteralbeforeFollowingAddress, sqInt literal, sqInt followingAddress)
  {
  	longAtput(pcRelativeAddressAt(self_in_storeLiteralbeforeFollowingAddress, (instructionIsLDR(self_in_storeLiteralbeforeFollowingAddress, longAt(followingAddress - 4))
  		? (/* begin instructionAddressBefore: */
  			followingAddress - 4)
  		: (/* begin instructionAddressBefore: */
  			(followingAddress - 4) - 4))), literal);
  	return self_in_storeLiteralbeforeFollowingAddress;
  }
  
  
  /*	Update an instruction that depends on a label outside
  	of generated code (e.g. a method or block header). */
  
  	/* CogOutOfLineLiteralsARMCompiler>>#updateLabel: */
  static AbstractInstruction * NoDbgRegParms
  updateLabel(AbstractInstruction * self_in_updateLabel, AbstractInstruction *labelInstruction)
  {
  	if (((self_in_updateLabel->opcode)) != Literal) {
  		assert((((self_in_updateLabel->opcode)) == MoveCwR)
  		 || (((self_in_updateLabel->opcode)) == PushCw));
  		((self_in_updateLabel->operands))[0] = (((labelInstruction->address)) + (((labelInstruction->operands))[1]));
  	}
  	return self_in_updateLabel;
  }
  
  
  /*	Answer if the receiver uses an out-of-line literal. Needs only
  	to work for the opcodes created with gen:literal:operand: et al. */
  
  	/* CogOutOfLineLiteralsARMCompiler>>#usesOutOfLineLiteral */
  static sqInt NoDbgRegParms
  usesOutOfLineLiteral(AbstractInstruction * self_in_usesOutOfLineLiteral)
  {
      sqInt constant;
      sqInt constant1;
      sqInt constant2;
      sqInt constant3;
      sqInt constant4;
      sqInt constant5;
      sqInt i;
      sqInt i1;
      sqInt i2;
      sqInt i3;
      sqInt i4;
      sqInt n;
      sqInt r;
      sqInt value;
      unsigned int value1;
      unsigned int value2;
  
  	
  	switch ((self_in_usesOutOfLineLiteral->opcode)) {
  	case CallFull:
  	case JumpFull:
  	case AddCwR:
  	case AndCwR:
  	case CmpCwR:
  	case OrCwR:
  	case SubCwR:
  	case XorCwR:
  		return 1;
  
  	case AddCqR:
  	case AddCqRR:
  	case CmpCqR:
  	case SubCqR:
  		/* begin rotateable8bitSignedImmediate:ifTrue:ifFalse: */
  		constant = ((self_in_usesOutOfLineLiteral->operands))[0];
  		value = constant;
  		while (1) {
  			if ((value & 0xFF) == value) {
  				n = constant != value;
  				return 0;
  			}
  			for (i1 = 2; i1 <= 30; i1 += 2) {
  				if ((value & (((0xFFU << i1) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i1)))) == value) {
  					r = 32 - i1;
  					i = (((usqInt)(value)) >> i1) | ((((sqInt)((usqInt)(value) << (32 - i1)))) & 0xFFFFFFFFU);
  					n = constant != value;
  					return 0;
  				}
  			}
  			if (!((value == constant)
  			 && (constant != 0))) break;
  			value = -constant;
  		}
  		return 1;
  
  	case AndCqR:
  	case AndCqRR:
  	case OrCqRR:
  		/* begin rotateable8bitBitwiseImmediate:ifTrue:ifFalse: */
  		constant1 = ((self_in_usesOutOfLineLiteral->operands))[0];
  		value1 = constant1;
  		while (1) {
  			if ((value1 & 0xFF) == value1) {
  				n = constant1 != value1;
  				return 0;
  			}
  			for (i2 = 2; i2 <= 30; i2 += 2) {
  				if ((value1 & (((0xFFU << i2) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i2)))) == value1) {
  					r = 32 - i2;
  					i = ((value1) >> i2) | ((value1 << (32 - i2)) & 0xFFFFFFFFU);
  					n = constant1 != value1;
  					return 0;
  				}
  			}
  			if (!(value1 == constant1)) break;
  			value1 = (constant1 < 0
  				? -1 - constant1
  				: (unsigned int)~constant1);
  		}
  		return (1U << (highBit(((self_in_usesOutOfLineLiteral->operands))[0]))) != ((((self_in_usesOutOfLineLiteral->operands))[0]) + 1);
  
  	case OrCqR:
  	case TstCqR:
  	case LoadEffectiveAddressMwrR:
  	case MoveCqR:
  	case MoveM16rR:
  	case PushCq:
  		/* begin rotateable8bitImmediate:ifTrue:ifFalse: */
  		constant2 = ((self_in_usesOutOfLineLiteral->operands))[0];
  		if ((constant2 & 0xFF) == constant2) {
  			return 0;
  		}
  		for (i3 = 2; i3 <= 30; i3 += 2) {
  			if ((constant2 & (((0xFFU << i3) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i3)))) == constant2) {
  				r = 32 - i3;
  				i = (((usqInt)(constant2)) >> i3) | ((((sqInt)((usqInt)(constant2) << (32 - i3)))) & 0xFFFFFFFFU);
  				return 0;
  			}
  		}
  		return 1;
  
  	case XorCqR:
  		/* begin rotateable8bitBitwiseImmediate:ifTrue:ifFalse: */
  		constant3 = ((self_in_usesOutOfLineLiteral->operands))[0];
  		value2 = constant3;
  		while (1) {
  			if ((value2 & 0xFF) == value2) {
  				n = constant3 != value2;
  				return 0;
  			}
  			for (i4 = 2; i4 <= 30; i4 += 2) {
  				if ((value2 & (((0xFFU << i4) & 0xFFFFFFFFU) | (((usqInt)(0xFF)) >> (32 - i4)))) == value2) {
  					r = 32 - i4;
  					i = ((value2) >> i4) | ((value2 << (32 - i4)) & 0xFFFFFFFFU);
  					n = constant3 != value2;
  					return 0;
  				}
  			}
  			if (!(value2 == constant3)) break;
  			value2 = (constant3 < 0
  				? -1 - constant3
  				: (unsigned int)~constant3);
  		}
  		return 1;
  
  	case MoveCwR:
  	case PushCw:
  		return !(((addressIsInInstructions(((AbstractInstruction *) (((self_in_usesOutOfLineLiteral->operands))[0]))))
  		 || ((((AbstractInstruction *) (((self_in_usesOutOfLineLiteral->operands))[0]))) == (methodLabel())))
  		 || (addressIsInCurrentCompilation(((self_in_usesOutOfLineLiteral->operands))[0])));
  
  	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())) < (4096)))
  			? 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())) < (4096)))
  			? 0
  			: 1);
  
  	case MoveRMwr:
  	case MoveRdM64r:
  	case MoveRMbr:
  	case MoveRM16r:
  		/* begin is12BitValue:ifTrue:ifFalse: */
  		constant4 = ((self_in_usesOutOfLineLiteral->operands))[1];
  		if ((SQABS(constant4)) <= 0xFFF) {
  
  			/* (2 raisedTo: 12)-1 */
  			if (constant4 >= 0) {
  				return 0;
  			}
  			else {
  				i = SQABS(constant4);
  				return 0;
  			}
  		}
  		else {
  			return 1;
  		}
  
  	case MoveMbrR:
  	case MoveM64rRd:
  	case MoveMwrR:
  		/* begin is12BitValue:ifTrue:ifFalse: */
  		constant5 = ((self_in_usesOutOfLineLiteral->operands))[0];
  		if ((SQABS(constant5)) <= 0xFFF) {
  
  			/* (2 raisedTo: 12)-1 */
  			if (constant5 >= 0) {
  				return 0;
  			}
  			else {
  				i = SQABS(constant5);
  				return 0;
  			}
  		}
  		else {
  			return 1;
  		}
  
  	default:
  		assert(0);
  
  	}
  	return 0;
  }
  
  	/* CogSimStackEntry>>#ensureSpilledAt:from: */
  static SimStackEntry * NoDbgRegParms
  ensureSpilledAtfrom(SimStackEntry * self_in_ensureSpilledAtfrom, sqInt baseOffset, sqInt baseRegister)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      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;
  		}
  	}
  	else {
  		if (((self_in_ensureSpilledAtfrom->type)) == SSBaseOffset) {
  			/* begin checkQuickConstant:forInstruction: */
  			literal = (self_in_ensureSpilledAtfrom->offset);
  			anInstruction1 = genoperandoperandoperand(MoveMwrR, (self_in_ensureSpilledAtfrom->offset), (self_in_ensureSpilledAtfrom->registerr), TempReg);
  			if (usesOutOfLineLiteral(anInstruction1)) {
  				(anInstruction1->dependent = locateLiteral(literal));
  			}
  			/* begin PushR: */
  			inst = genoperand(PushR, TempReg);
  		}
  		else {
  			assert(((self_in_ensureSpilledAtfrom->type)) == SSRegister);
  			/* begin PushR: */
  			reg = (self_in_ensureSpilledAtfrom->registerr);
  			inst = genoperand(PushR, reg);
  		}
  		(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))))));
  }
  
  
  /*	Receiver is not a forwarder, except in blocks with no inst var access.
  	For now we optimize only the case where receiver is accessed in a method. */
  
  	/* CogSimStackEntry>>#mayBeAForwarder */
  static sqInt NoDbgRegParms
  mayBeAForwarder(SimStackEntry * self_in_mayBeAForwarder)
  {
  	if ((((self_in_mayBeAForwarder->type)) == SSRegister)
  	 && (isNonForwarderReceiver((self_in_mayBeAForwarder->registerr)))) {
  		return 0;
  	}
  	return ((self_in_mayBeAForwarder->type)) != SSConstant;
  }
  
  	/* CogSimStackEntry>>#popToReg: */
  static SimStackEntry * NoDbgRegParms
  popToReg(SimStackEntry * self_in_popToReg, sqInt reg)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      sqInt literal;
      sqInt quickConstant;
      sqInt reg1;
  
  	if ((self_in_popToReg->spilled)) {
  		/* begin PopR: */
  		genoperand(PopR, reg);
  	}
  	else {
  		
  		switch ((self_in_popToReg->type)) {
  		case SSBaseOffset:
  			/* begin checkQuickConstant:forInstruction: */
  			literal = (self_in_popToReg->offset);
  			anInstruction = genoperandoperandoperand(MoveMwrR, (self_in_popToReg->offset), (self_in_popToReg->registerr), reg);
  			if (usesOutOfLineLiteral(anInstruction)) {
  				(anInstruction->dependent = locateLiteral(literal));
  			}
  			break;
  		case SSConstant:
  			if (shouldAnnotateObjectReference((self_in_popToReg->constant))) {
  				annotateobjRef(gMoveCwR((self_in_popToReg->constant), reg), (self_in_popToReg->constant));
  			}
  			else {
  				/* begin MoveCq:R: */
  				quickConstant = (self_in_popToReg->constant);
  				/* begin checkQuickConstant:forInstruction: */
  				anInstruction1 = genoperandoperand(MoveCqR, quickConstant, reg);
  				if (usesOutOfLineLiteral(anInstruction1)) {
  					(anInstruction1->dependent = locateLiteral(quickConstant));
  				}
  			}
  			break;
  		case SSRegister:
  			if (reg != ((self_in_popToReg->registerr))) {
  				/* begin MoveR:R: */
  				reg1 = (self_in_popToReg->registerr);
  				genoperandoperand(MoveRR, reg1, reg);
  			}
  			else {
  				/* begin Label */
  				genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  			}
  			break;
  		default:
  			error("Case not found and no otherwise clause");
  		}
  	}
  	return self_in_popToReg;
  }
  
  
  /*	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)
  		? (/* begin registerMaskFor: */
  			(reg = (self_in_registerMask->registerr)),
  			1U << reg)
  		: 0);
  }
  
  	/* CogSimStackEntry>>#registerMaskOrNone */
  static sqInt NoDbgRegParms
  registerMaskOrNone(SimStackEntry * self_in_registerMaskOrNone)
  {
      sqInt reg;
  
  	return (((self_in_registerMaskOrNone->type)) == SSRegister
  		? (/* begin registerMaskFor: */
  			(reg = (self_in_registerMaskOrNone->registerr)),
  			1U << reg)
  		: 0);
  }
  
  	/* CogSimStackEntry>>#registerOrNone */
  static sqInt NoDbgRegParms
  registerOrNone(SimStackEntry * self_in_registerOrNone)
  {
  	return (((self_in_registerOrNone->type)) == SSRegister
  		? (self_in_registerOrNone->registerr)
  		: NoReg);
  }
  
  	/* CogSimStackEntry>>#storeToReg: */
  static SimStackEntry * NoDbgRegParms
  storeToReg(SimStackEntry * self_in_storeToReg, sqInt reg)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      sqInt literal;
      sqInt quickConstant;
      sqInt reg1;
  
  	
  	switch ((self_in_storeToReg->type)) {
  	case SSBaseOffset:
  	case SSSpill:
  		/* begin checkQuickConstant:forInstruction: */
  		literal = (self_in_storeToReg->offset);
  		anInstruction = genoperandoperandoperand(MoveMwrR, (self_in_storeToReg->offset), (self_in_storeToReg->registerr), reg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(literal));
  		}
  		break;
  	case SSConstant:
  		if (shouldAnnotateObjectReference((self_in_storeToReg->constant))) {
  			annotateobjRef(gMoveCwR((self_in_storeToReg->constant), reg), (self_in_storeToReg->constant));
  		}
  		else {
  			/* begin MoveCq:R: */
  			quickConstant = (self_in_storeToReg->constant);
  			/* begin checkQuickConstant:forInstruction: */
  			anInstruction1 = genoperandoperand(MoveCqR, quickConstant, reg);
  			if (usesOutOfLineLiteral(anInstruction1)) {
  				(anInstruction1->dependent = locateLiteral(quickConstant));
  			}
  		}
  		break;
  	case SSRegister:
  		if (reg != ((self_in_storeToReg->registerr))) {
  			/* begin MoveR:R: */
  			reg1 = (self_in_storeToReg->registerr);
  			genoperandoperand(MoveRR, reg1, reg);
  		}
  		else {
  			/* begin Label */
  			genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  		}
  		break;
  	default:
  		error("Case not found and no otherwise clause");
  	}
  	return self_in_storeToReg;
  }
  
  	/* 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) {
  
  			/* Must copy across state (not using realloc, cuz...) and
  			   must also update existing instructions to refer to the new ones...
  			   It's either this or modify all generation routines to be able to retry
  			   with more literals after running out of literals. */
  			newLiterals = calloc(initialNumLiterals, sizeof(CogAbstractInstruction));
  			if (!(literals == null)) {
  				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;
  		}
  	}
  	litInst = literalInstructionAt(nextLiteralIndex);
  	initializeUniqueLiteral(litInst, aLiteral);
  
  	/* Record the opcodeIndex of the first dependent instruction (the first instruction that references an out-of-line literal) */
  	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
  	on the generated ones
  	so that a later pass will copy the address of each generated literal 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 i;
      sqInt index;
      AbstractInstruction *jump;
      AbstractInstruction *litInst;
  
  	jump = ((AbstractInstruction *) 0);
  	if (generateBranchAround) {
  		/* begin Jump: */
  		jump = genoperand(Jump, ((sqInt)0));
  	}
  	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;
  	}
  	if (generateBranchAround) {
  		jmpTarget(jump, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	}
  	/* begin getOpcodeIndex */
  	firstOpcodeIndex = opcodeIndex;
  	lastDumpedLiteralIndex = nextLiteralIndex;
  	return 0;
  }
  
  
  /*	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]));
  	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 i1;
      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]) & 1))
  		 && (literalInstructionInRange(litInst)))) {
  			return litInst;
  		}
  	}
  	if (nextLiteralIndex >= literalsSize) {
  		/* begin allocateLiterals: */
  		initialNumLiterals = literalsSize + 8;
  		if (initialNumLiterals > literalsSize) {
  
  			/* Must copy across state (not using realloc, cuz...) and
  			   must also update existing instructions to refer to the new ones...
  			   It's either this or modify all generation routines to be able to retry
  			   with more literals after running out of literals. */
  			newLiterals = calloc(initialNumLiterals, sizeof(CogAbstractInstruction));
  			if (!(literals == null)) {
  				for (i1 = 0; i1 < nextLiteralIndex; i1 += 1) {
  					existingInst = literalInstructionAt(i1);
  					newInst = (&(newLiterals[i1]));
  					cloneLiteralFrom(newInst, existingInst);
  					assert(((existingInst->dependent)) == null);
  					(existingInst->dependent = newInst);
  				}
  				for (i1 = 0, iLimiT = (opcodeIndex - 1); i1 <= iLimiT; i1 += 1) {
  					existingInst = abstractInstructionAt(i1);
  					if ((((existingInst->dependent)) != null)
  					 && (((((existingInst->dependent))->opcode)) == Literal)) {
  						(existingInst->dependent = (((existingInst->dependent))->dependent));
  					}
  				}
  			}
  			free(literals);
  			literals = newLiterals;
  			literalsSize = initialNumLiterals;
  		}
  	}
  	litInst = literalInstructionAt(nextLiteralIndex);
  	initializeSharableLiteral(litInst, aLiteral);
  
  	/* Record the opcodeIndex of the first dependent instruction (the first instruction that references an out-of-line literal) */
  	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())));
  }
  
  
  /*	<Integer> */
  
  	/* SimpleStackBasedCogit>>#ceClosureCopyDescriptor: */
  static sqInt NoDbgRegParms
  ceClosureCopyDescriptor(sqInt descriptor)
  {
  	return createClosureNumArgsnumCopiedstartpc(descriptor & 0x3F, (((usqInt)(descriptor)) >> 6) & 0x3F, ((usqInt)(descriptor)) >> 12);
  }
  
  	/* SimpleStackBasedCogit>>#cogMethodHasMachineCodePrim: */
  sqInt
  cogMethodHasMachineCodePrim(CogMethod *aCogMethod)
  {
      sqInt primIndex;
  
  	primIndex = primitiveIndexOfMethodheader((aCogMethod->methodObject), (aCogMethod->objectHeader));
  	return (((primIndex >= 1) && (primIndex <= MaxCompiledPrimitiveIndex)))
  	 && ((((primitiveGeneratorTable[primIndex]).primitiveGenerator)) != null);
  }
  
  
  /*	Compile the jump instruction(s) at the end of the method that dispatch to
  	each block body.
   */
  
  	/* SimpleStackBasedCogit>>#compileBlockDispatch */
  static sqInt
  compileBlockDispatch(void)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *jumpSkip;
  
  	assert(blockCount > 0);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(MoveCqR, 0, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(0));
  	}
  	blockEntryNoContextSwitch = anInstruction;
  	/* begin Jump: */
  	jumpSkip = genoperand(Jump, ((sqInt)0));
  	/* begin MoveR:R: */
  	blockEntryLabel = genoperandoperand(MoveRR, ReceiverResultReg, SendNumArgsReg);
  	jmpTarget(jumpSkip, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	if (blockCount > 1) {
  		genLoadSlotsourceRegdestReg(ClosureStartPCIndex, ReceiverResultReg, TempReg);
  	}
  	compileBlockDispatchFromto(0, blockCount - 1);
  	return 0;
  }
  
  
  /*	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));
  	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));
  	}
  	/* begin JumpZero: */
  	jmpNoError = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	addDependent(methodLabel, annotateAbsolutePCRef(gMoveCwR(((sqInt)methodLabel), ClassReg)));
  	/* begin CallRT: */
  	abstractInstruction = genoperand(Call, ceReapAndResetErrorCodeTrampoline);
  	(abstractInstruction->annotation = IsRelativeCall);
  	jmpTarget(jmpNoError, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  }
  
  
  /*	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 address;
      sqInt address1;
      sqInt address10;
      sqInt address11;
      sqInt address12;
      sqInt address13;
      sqInt address3;
      sqInt address4;
      sqInt address5;
      sqInt address6;
      sqInt address8;
      sqInt address9;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *anInstruction4;
      AbstractInstruction *anInstruction5;
      AbstractInstruction *anInstruction6;
      AbstractInstruction *anInstruction7;
      AbstractInstruction *anInstruction8;
      AbstractInstruction *continuePostSampleNonPrim;
      AbstractInstruction *continuePostSamplePrim;
      AbstractInstruction *jmp;
      AbstractInstruction *jmpSampleNonPrim;
      AbstractInstruction *jmpSamplePrim;
      sqInt offset;
      sqInt offset1;
      sqInt offset2;
      sqInt operand1;
      sqInt operand3;
      sqInt reg;
      sqInt retpc;
  
  
  	/* Save processor fp, sp and return pc in the interpreter's frame stack and instruction pointers */
  	continuePostSampleNonPrim = ((AbstractInstruction *) 0);
  	continuePostSamplePrim = ((AbstractInstruction *) 0);
  	jmpSampleNonPrim = ((AbstractInstruction *) 0);
  	jmpSamplePrim = ((AbstractInstruction *) 0);
  	genExternalizePointersForPrimitiveCall();
  	/* begin genLoadCStackPointersForPrimCall */
  	if (cFramePointerInUse) {
  		genLoadCStackPointers(backEnd);
  	}
  	else {
  		genLoadCStackPointer(backEnd);
  	}
  	if (flags & PrimCallCollectsProfileSamples) {
  
  		/* Test nextProfileTick for being non-zero and call checkProfileTick if so */
  		/* begin MoveAw:R: */
  		address = nextProfileTickAddress();
  		/* begin gen:literal:operand: */
  		checkLiteralforInstruction(address, genoperandoperand(MoveAwR, address, TempReg));
  		/* begin MoveAw:R: */
  		address1 = (nextProfileTickAddress()) + BytesPerWord;
  		/* begin gen:literal:operand: */
  		checkLiteralforInstruction(address1, genoperandoperand(MoveAwR, address1, ClassReg));
  		/* begin OrR:R: */
  		genoperandoperand(OrRR, TempReg, ClassReg);
  		/* begin JumpNonZero: */
  		jmpSampleNonPrim = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  		/* begin Label */
  		continuePostSampleNonPrim = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	}
  	if (recordPrimTrace()) {
  		genFastPrimTraceUsingand(ClassReg, SendNumArgsReg);
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction8 = genoperandoperand(MoveCqR, 0, TempReg);
  	if (usesOutOfLineLiteral(anInstruction8)) {
  		(anInstruction8->dependent = locateLiteral(0));
  	}
  	/* begin MoveR:Aw: */
  	address11 = primFailCodeAddress();
  	/* begin gen:operand:literal: */
  	checkLiteralforInstruction(address11, genoperandoperand(MoveRAw, TempReg, address11));
  	if (methodOrBlockNumArgs != 0) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction1 = genoperandoperand(MoveCqR, methodOrBlockNumArgs, TempReg);
  		if (usesOutOfLineLiteral(anInstruction1)) {
  			(anInstruction1->dependent = locateLiteral(methodOrBlockNumArgs));
  		}
  	}
  	/* begin MoveR:Aw: */
  	address12 = argumentCountAddress();
  	/* begin gen:operand:literal: */
  	checkLiteralforInstruction(address12, genoperandoperand(MoveRAw, TempReg, address12));
  	if (flags & PrimCallNeedsPrimitiveFunction) {
  		/* begin MoveCw:R: */
  		checkLiteralforInstruction(((sqInt)primitiveRoutine), genoperandoperand(MoveCwR, ((sqInt)primitiveRoutine), TempReg));
  		/* begin MoveR:Aw: */
  		address3 = primitiveFunctionPointerAddress();
  		/* begin gen:operand:literal: */
  		primSetFunctionLabel = checkLiteralforInstruction(address3, genoperandoperand(MoveRAw, TempReg, address3));
  	}
  	if (flags & (PrimCallNeedsNewMethod + PrimCallMayCallBack)) {
  
  		/* The ceActivateFailingPrimitiveMethod: machinery can't handle framelessness. */
  		if (flags & PrimCallMayCallBack) {
  			needsFrame = 1;
  		}
  		addDependent(methodLabel, annotateAbsolutePCRef(gMoveCwR(((sqInt)methodLabel), ClassReg)));
  		/* begin MoveMw:r:R: */
  		offset = offsetof(CogMethod, methodObject);
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction2 = genoperandoperandoperand(MoveMwrR, offset, ClassReg, TempReg);
  		if (usesOutOfLineLiteral(anInstruction2)) {
  			(anInstruction2->dependent = locateLiteral(offset));
  		}
  		/* begin MoveR:Aw: */
  		address4 = newMethodAddress();
  		/* begin gen:operand:literal: */
  		checkLiteralforInstruction(address4, genoperandoperand(MoveRAw, TempReg, address4));
  	}
  	/* begin PrefetchAw: */
  	address13 = primFailCodeAddress();
  	/* begin gen:literal: */
  	checkLiteralforInstruction(address13, genoperand(PrefetchAw, address13));
  	if (flags & PrimCallMayCallBack) {
  
  		/* Sideways call the C primitive routine so that we return through cePrimReturnEnterCogCode. */
  		/* On Spur ceActivateFailingPrimitiveMethod: would like to retry if forwarders
  		   are found. So insist on PrimCallNeedsPrimitiveFunction being set too. */
  		assert(flags & PrimCallNeedsPrimitiveFunction);
  		genMarshallNArgsargargargarg(backEnd, 0, null, null, null, null);
  		/* begin genSubstituteReturnAddress: */
  		retpc = (flags & PrimCallCollectsProfileSamples
  			? cePrimReturnEnterCogCodeProfiling
  			: cePrimReturnEnterCogCode);
  		/* begin gen:literal:operand: */
  		checkLiteralforInstruction(retpc, genoperandoperand(MoveCwR, retpc, LR));
  		/* begin gen:literal: */
  		primInvokeInstruction = checkLiteralforInstruction(((sqInt)(((sqInt)primitiveRoutine))), genoperand(JumpFull, ((sqInt)(((sqInt)primitiveRoutine)))));
  		jmp = (jmpSamplePrim = (continuePostSamplePrim = null));
  	}
  	else {
  
  		/* Call the C primitive routine. */
  		genMarshallNArgsargargargarg(backEnd, 0, 0, 0, 0, 0);
  		/* begin gen:literal: */
  		primInvokeInstruction = checkLiteralforInstruction(((sqInt)primitiveRoutine), genoperand(CallFull, ((sqInt)primitiveRoutine)));
  		/* begin genRemoveNArgsFromStack: */
  		assert(0 <= 4);
  		if (flags & PrimCallCollectsProfileSamples) {
  			assert(flags & PrimCallNeedsNewMethod);
  			/* begin MoveAw:R: */
  			address5 = nextProfileTickAddress();
  			/* begin gen:literal:operand: */
  			checkLiteralforInstruction(address5, genoperandoperand(MoveAwR, address5, TempReg));
  			/* begin MoveAw:R: */
  			address6 = (nextProfileTickAddress()) + BytesPerWord;
  			/* begin gen:literal:operand: */
  			checkLiteralforInstruction(address6, genoperandoperand(MoveAwR, address6, ClassReg));
  			/* begin OrR:R: */
  			genoperandoperand(OrRR, TempReg, ClassReg);
  			/* begin JumpNonZero: */
  			jmpSamplePrim = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  			/* begin Label */
  			continuePostSamplePrim = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  		}
  		/* begin MoveAw:R: */
  		address8 = instructionPointerAddress();
  		reg = LinkReg;
  		/* begin gen:literal:operand: */
  		checkLiteralforInstruction(address8, genoperandoperand(MoveAwR, address8, reg));
  		genLoadStackPointers(backEnd);
  		/* begin MoveAw:R: */
  		address9 = primFailCodeAddress();
  		/* begin gen:literal:operand: */
  		checkLiteralforInstruction(address9, genoperandoperand(MoveAwR, address9, TempReg));
  		flag("ask concrete code gen if move sets condition codes?");
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction4 = genoperandoperand(CmpCqR, 0, TempReg);
  		if (usesOutOfLineLiteral(anInstruction4)) {
  			(anInstruction4->dependent = locateLiteral(0));
  		}
  		/* begin JumpNonZero: */
  		jmp = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  		/* begin MoveMw:r:R: */
  		offset1 = 0;
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction5 = genoperandoperandoperand(MoveMwrR, offset1, SPReg, ReceiverResultReg);
  		if (usesOutOfLineLiteral(anInstruction5)) {
  			(anInstruction5->dependent = locateLiteral(offset1));
  		}
  		/* begin RetN: */
  		genoperand(RetN, BytesPerWord);
  	}
  	if (flags & PrimCallCollectsProfileSamples) {
  
  		/* The sample is collected by cePrimReturnEnterCogCode for external calls */
  		if (!(jmpSamplePrim == null)) {
  
  			/* Call ceCheckProfileTick: to record sample and then continue. */
  			jmpTarget(jmpSamplePrim, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  			assert(flags & PrimCallNeedsNewMethod);
  			/* begin gen:literal: */
  			operand1 = ((usqIntptr_t)ceCheckProfileTick);
  			checkLiteralforInstruction(operand1, genoperand(CallFull, operand1));
  			/* begin Jump: */
  			genoperand(Jump, ((sqInt)continuePostSamplePrim));
  		}
  		jmpTarget(jmpSampleNonPrim, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction6 = genoperandoperand(MoveCqR, 0, TempReg);
  		if (usesOutOfLineLiteral(anInstruction6)) {
  			(anInstruction6->dependent = locateLiteral(0));
  		}
  		/* begin MoveR:Aw: */
  		address10 = newMethodAddress();
  		/* begin gen:operand:literal: */
  		checkLiteralforInstruction(address10, genoperandoperand(MoveRAw, TempReg, address10));
  		/* begin gen:literal: */
  		operand3 = ((usqIntptr_t)ceCheckProfileTick);
  		checkLiteralforInstruction(operand3, genoperand(CallFull, operand3));
  		/* begin Jump: */
  		genoperand(Jump, ((sqInt)continuePostSampleNonPrim));
  	}
  	if (!(jmp == null)) {
  
  		/* Jump to restore of receiver reg and proceed to frame build for failure. */
  		jmpTarget(jmp, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  		/* begin MoveMw:r:R: */
  		offset2 = BytesPerWord * (methodOrBlockNumArgs + (0));
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction7 = genoperandoperandoperand(MoveMwrR, offset2, SPReg, ReceiverResultReg);
  		if (usesOutOfLineLiteral(anInstruction7)) {
  			(anInstruction7->dependent = locateLiteral(offset2));
  		}
  	}
  	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 * inst;
      AbstractInstruction * jmpFail;
      sqInt liveRegsMask;
      sqInt n;
      sqInt offset;
  
  	assert(methodOrBlockNumArgs <= 3);
  	if ((methodOrBlockNumArgs > 1 /* numRegArgs */)
  	 || (methodOrBlockNumArgs == 0)) {
  		/* begin registerMaskFor: */
  		liveRegsMask = 1U << ReceiverResultReg;
  	}
  	else {
  		/* begin registerMaskFor:and: */
  		liveRegsMask = (1U << ReceiverResultReg) | (1U << Arg0Reg);
  	}
  	/* begin genSaveRegs: */
  	if ((liveRegsMask & CallerSavedRegisterMask) == 0) {
  		genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	}
  	else {
  		genoperand(PushSTM, liveRegsMask & CallerSavedRegisterMask);
  	}
  	if (methodOrBlockNumArgs > 1 /* numRegArgs */) {
  
  		/* Wrangle args into Arg0Reg, Arg1Reg, SendNumArgsReg & ClassReg */
  		/* offset := self bitCountOf: (liveRegsMask bitAnd: CallerSavedRegisterMask). */
  		error("shouldBeImplemented");
  	}
  	genMarshallNArgsargargargarg(backEnd, methodOrBlockNumArgs + 1, ReceiverResultReg, Arg0Reg, Arg1Reg, SendNumArgsReg);
  	/* begin saveAndRestoreLinkRegUsingCalleeSavedRegNotLiveAtPointOfSendAround: */
  	inst = genoperandoperand(MoveRR, LinkReg, Extra1Reg);
  	/* begin gen:literal: */
  	checkLiteralforInstruction(((sqInt)primitiveRoutine), genoperand(CallFull, ((sqInt)primitiveRoutine)));
  	genoperandoperand(MoveRR, Extra1Reg, LinkReg);
  	/* begin genRemoveNArgsFromStack: */
  	n = methodOrBlockNumArgs + 1;
  	assert(n <= 4);
  	/* begin genRestoreRegs: */
  	if ((liveRegsMask & CallerSavedRegisterMask) == 0) {
  		genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	}
  	else {
  		genoperand(PopLDM, liveRegsMask & CallerSavedRegisterMask);
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(CmpCqR, 0, ABIResultReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(0));
  	}
  	/* begin JumpZero: */
  	jmpFail = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	genWriteCResultIntoReg(backEnd, ReceiverResultReg);
  	/* begin RetN: */
  	offset = (methodOrBlockNumArgs > 1 /* numRegArgs */
  		? (methodOrBlockNumArgs + 1) * BytesPerWord
  		: 0);
  	genoperand(RetN, offset);
  	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 *anInstruction1;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *anInstruction3;
      AbstractInstruction *anInstruction4;
      AbstractInstruction *jumpSelectorMiss;
      sqInt offset;
      sqInt offset1;
  
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, SendNumArgsReg, ClassReg);
  	/* begin maybeShiftClassTagRegisterForMethodCacheProbe: */
  	annotateobjRef(gXorCwR(selector, ClassReg), selector);
  	assert(shift <= (shiftForWord()));
  	if (shift < (shiftForWord())) {
  		/* begin LogicalShiftLeftCq:R: */
  		genoperandoperand(LogicalShiftLeftCqR, (shiftForWord()) - shift, ClassReg);
  	}
  	/* begin AndCq:R: */
  	anInstruction4 = genoperandoperand(AndCqR, ((int)((usqInt)(MethodCacheMask) << (shiftForWord()))), ClassReg);
  	if (usesOutOfLineLiteral(anInstruction4)) {
  		(anInstruction4->dependent = locateLiteral(((int)((usqInt)(MethodCacheMask) << (shiftForWord())))));
  	}
  	if (baseRegOrNone == NoReg) {
  		/* begin MoveMw:r:R: */
  		offset = (((usqInt)(methodCacheAddress()))) + (((int)((usqInt)(MethodCacheSelector) << (shiftForWord()))));
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction = genoperandoperandoperand(MoveMwrR, offset, ClassReg, TempReg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(offset));
  		}
  	}
  	else {
  		/* begin AddR:R: */
  		genoperandoperand(AddRR, baseRegOrNone, ClassReg);
  		/* begin MoveMw:r:R: */
  		anInstruction1 = genoperandoperandoperand(MoveMwrR, ((int)((usqInt)(MethodCacheSelector) << (shiftForWord()))), ClassReg, TempReg);
  		if (usesOutOfLineLiteral(anInstruction1)) {
  			(anInstruction1->dependent = locateLiteral(((int)((usqInt)(MethodCacheSelector) << (shiftForWord())))));
  		}
  	}
  	annotateobjRef(checkLiteralforInstruction(selector, genoperandoperand(CmpCwR, selector, TempReg)), selector);
  	/* begin JumpNonZero: */
  	jumpSelectorMiss = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	if (baseRegOrNone == NoReg) {
  		/* begin MoveMw:r:R: */
  		offset1 = (((usqInt)(methodCacheAddress()))) + (((int)((usqInt)(MethodCacheClass) << (shiftForWord()))));
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction2 = genoperandoperandoperand(MoveMwrR, offset1, ClassReg, TempReg);
  		if (usesOutOfLineLiteral(anInstruction2)) {
  			(anInstruction2->dependent = locateLiteral(offset1));
  		}
  	}
  	else {
  		/* begin MoveMw:r:R: */
  		anInstruction3 = genoperandoperandoperand(MoveMwrR, ((int)((usqInt)(MethodCacheClass) << (shiftForWord()))), ClassReg, TempReg);
  		if (usesOutOfLineLiteral(anInstruction3)) {
  			(anInstruction3->dependent = locateLiteral(((int)((usqInt)(MethodCacheClass) << (shiftForWord())))));
  		}
  	}
  	/* begin CmpR:R: */
  	assert(!((SendNumArgsReg == SPReg)));
  	genoperandoperand(CmpRR, SendNumArgsReg, TempReg);
  	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 *anInstruction1;
      AbstractInstruction *anInstruction2;
      sqInt cacheBaseReg;
      AbstractInstruction *itsAHit;
      AbstractInstruction *jumpBCMethod;
      AbstractInstruction *jumpClassMiss;
      AbstractInstruction *jumpSelectorMiss;
      sqInt offset;
  
  	/* begin preenMethodLabel */
  	(((((AbstractInstruction *) methodLabel))->operands))[1] = 0;
  	compilePICAbort(numArgs);
  	entry = genGetClassTagOfintoscratchReg(ReceiverResultReg, SendNumArgsReg, TempReg);
  	flag("lookupInMethodCacheSel:classTag:");
  	cacheBaseReg = NoReg;
  	jumpSelectorMiss = compileOpenPICMethodCacheProbeForwithShiftbaseRegOrNone(selector, 0, cacheBaseReg);
  	/* begin JumpNonZero: */
  	jumpClassMiss = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	/* begin MoveMw:r:R: */
  	offset = (cacheBaseReg == NoReg
  		? (((usqInt)(methodCacheAddress()))) + (((int)((usqInt)(MethodCacheMethod) << (shiftForWord()))))
  		: ((int)((usqInt)(MethodCacheMethod) << (shiftForWord()))));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperandoperand(MoveMwrR, offset, ClassReg, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(offset));
  	}
  	itsAHit = anInstruction1;
  	genLoadSlotsourceRegdestReg(HeaderIndex, SendNumArgsReg, ClassReg);
  	jumpBCMethod = genJumpImmediate(ClassReg);
  	jmpTarget(jumpBCMethod, picInterpretAbort);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction2 = genoperandoperand(AddCqR, cmNoCheckEntryOffset, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(cmNoCheckEntryOffset));
  	}
  	/* begin JumpR: */
  	genoperand(JumpR, ClassReg);
  	jmpTarget(jumpSelectorMiss, jmpTarget(jumpClassMiss, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
  	jumpSelectorMiss = compileOpenPICMethodCacheProbeForwithShiftbaseRegOrNone(selector, 1, cacheBaseReg);
  	/* begin JumpZero: */
  	genConditionalBranchoperand(JumpZero, ((sqInt)itsAHit));
  	jmpTarget(jumpSelectorMiss, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	jumpSelectorMiss = compileOpenPICMethodCacheProbeForwithShiftbaseRegOrNone(selector, 2, cacheBaseReg);
  	/* begin JumpZero: */
  	genConditionalBranchoperand(JumpZero, ((sqInt)itsAHit));
  	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 /* emptyRegisterMask */);
  }
  
  
  /*	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 *anInstruction1;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *anInstruction3;
      AbstractInstruction *anInstruction4;
      AbstractInstruction *jumpSelectorMiss;
      sqInt offset;
      sqInt offset1;
  
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, SendNumArgsReg, ClassReg);
  	/* begin maybeShiftClassTagRegisterForMethodCacheProbe: */
  	/* begin XorR:R: */
  	genoperandoperand(XorRR, selectorReg, ClassReg);
  	assert(shift <= (shiftForWord()));
  	if (shift < (shiftForWord())) {
  		/* begin LogicalShiftLeftCq:R: */
  		genoperandoperand(LogicalShiftLeftCqR, (shiftForWord()) - shift, ClassReg);
  	}
  	/* begin AndCq:R: */
  	anInstruction4 = genoperandoperand(AndCqR, ((int)((usqInt)(MethodCacheMask) << (shiftForWord()))), ClassReg);
  	if (usesOutOfLineLiteral(anInstruction4)) {
  		(anInstruction4->dependent = locateLiteral(((int)((usqInt)(MethodCacheMask) << (shiftForWord())))));
  	}
  	if (baseRegOrNone == NoReg) {
  		/* begin MoveMw:r:R: */
  		offset = (((usqInt)(methodCacheAddress()))) + (((int)((usqInt)(MethodCacheSelector) << (shiftForWord()))));
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction = genoperandoperandoperand(MoveMwrR, offset, ClassReg, TempReg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(offset));
  		}
  	}
  	else {
  		/* begin AddR:R: */
  		genoperandoperand(AddRR, baseRegOrNone, ClassReg);
  		/* begin MoveMw:r:R: */
  		anInstruction1 = genoperandoperandoperand(MoveMwrR, ((int)((usqInt)(MethodCacheSelector) << (shiftForWord()))), ClassReg, TempReg);
  		if (usesOutOfLineLiteral(anInstruction1)) {
  			(anInstruction1->dependent = locateLiteral(((int)((usqInt)(MethodCacheSelector) << (shiftForWord())))));
  		}
  	}
  	/* begin CmpR:R: */
  	assert(!((selectorReg == SPReg)));
  	genoperandoperand(CmpRR, selectorReg, TempReg);
  	/* begin JumpNonZero: */
  	jumpSelectorMiss = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	if (baseRegOrNone == NoReg) {
  		/* begin MoveMw:r:R: */
  		offset1 = (((usqInt)(methodCacheAddress()))) + (((int)((usqInt)(MethodCacheClass) << (shiftForWord()))));
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction2 = genoperandoperandoperand(MoveMwrR, offset1, ClassReg, TempReg);
  		if (usesOutOfLineLiteral(anInstruction2)) {
  			(anInstruction2->dependent = locateLiteral(offset1));
  		}
  	}
  	else {
  		/* begin MoveMw:r:R: */
  		anInstruction3 = genoperandoperandoperand(MoveMwrR, ((int)((usqInt)(MethodCacheClass) << (shiftForWord()))), ClassReg, TempReg);
  		if (usesOutOfLineLiteral(anInstruction3)) {
  			(anInstruction3->dependent = locateLiteral(((int)((usqInt)(MethodCacheClass) << (shiftForWord())))));
  		}
  	}
  	/* begin CmpR:R: */
  	assert(!((SendNumArgsReg == SPReg)));
  	genoperandoperand(CmpRR, SendNumArgsReg, TempReg);
  	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)
  {
      sqInt code;
      sqInt flags;
      sqInt opcodeIndexAtPrimitive;
      PrimitiveDescriptor *primitiveDescriptor;
      void (*primitiveRoutine)(void);
  
  	if (primitiveIndex == 0) {
  		return 0;
  	}
  	if ((((primitiveDescriptor = primitiveGeneratorOrNil())) != null)
  	 && ((((primitiveDescriptor->primitiveGenerator)) != null)
  	 && ((((primitiveDescriptor->primNumArgs)) < 0)
  	 || (((primitiveDescriptor->primNumArgs)) == (argumentCountOf(methodObj)))))) {
  
  		/* Note opcodeIndex so that any arg load instructions
  		   for unimplemented primitives can be discarded. */
  		opcodeIndexAtPrimitive = opcodeIndex;
  		code = ((primitiveDescriptor->primitiveGenerator))();
  		if ((code < 0)
  		 && (code != UnimplementedPrimitive)) {
  
  			/* Generator failed, so no point continuing... */
  			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 = primitivePropertyFlags(primitiveIndex);
  	if (flags & PrimCallDoNotJIT) {
  		return ShouldNotJIT;
  	}
  	if (flags & PrimCallOnSmalltalkStack) {
  		assert(flags == PrimCallOnSmalltalkStack);
  		return compileMachineCodeInterpreterPrimitive(((void (*)(void)) (mcprimFunctionForPrimitiveIndex(primitiveIndex))));
  	}
  	if ((((primitiveRoutine = functionPointerForCompiledMethodprimitiveIndex(methodObj, primitiveIndex))) == 0)
  	 || (primitiveRoutine == (((void (*)(void)) primitiveFail)))) {
  		return genFastPrimFail();
  	}
  	minValidCallAddress = ((minValidCallAddress < (((usqInt)primitiveRoutine))) ? minValidCallAddress : (((usqInt)primitiveRoutine)));
  	return compileInterpreterPrimitiveflags(primitiveRoutine, flags);
  }
  
  	/* SimpleStackBasedCogit>>#extendedPushBytecode */
  static sqInt
  extendedPushBytecode(void)
  {
      sqInt variableIndex;
      sqInt variableType;
  
  	variableType = (((usqInt)(byte1)) >> 6) & 3;
  	variableIndex = byte1 & 0x3F;
  	if (variableType == 0) {
  		return genPushReceiverVariable(variableIndex);
  	}
  	if (variableType == 1) {
  		return genPushTemporaryVariable(variableIndex);
  	}
  	if (variableType == 2) {
  		return genPushLiteralIndex(variableIndex);
  	}
  	return genPushLiteralVariable(variableIndex);
  }
  
  	/* SimpleStackBasedCogit>>#extendedStoreAndPopBytecode */
  static sqInt
  extendedStoreAndPopBytecode(void)
  {
      AbstractInstruction *abstractInstruction;
      sqInt variableIndex;
      sqInt variableType;
  
  	variableType = (((usqInt)(byte1)) >> 6) & 3;
  	variableIndex = byte1 & 0x3F;
  	if (variableType == 0) {
  		return genStorePopReceiverVariableneedsStoreCheckneedsImmutabilityCheck(1, variableIndex, ((((ssTop())->type)) != SSConstant)
  		 || ((isNonImmediate(((ssTop())->constant)))
  		 && (shouldAnnotateObjectReference(((ssTop())->constant)))), 1);
  	}
  	if (variableType == 1) {
  		genStorePopTemporaryVariable(1, variableIndex);
  		
  #    if IMMUTABILITY
  		/* begin annotateBytecode: */
  		abstractInstruction = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  		(abstractInstruction->annotation = HasBytecodePC);
  #    endif /* IMMUTABILITY */
  		return 0;
  	}
  	if (variableType == 3) {
  		return genStorePopLiteralVariableneedsStoreCheckneedsImmutabilityCheck(1, variableIndex, ((((ssTop())->type)) != SSConstant)
  		 || ((isNonImmediate(((ssTop())->constant)))
  		 && (shouldAnnotateObjectReference(((ssTop())->constant)))), 1);
  	}
  	return EncounteredUnknownBytecode;
  }
  
  	/* SimpleStackBasedCogit>>#extendedStoreBytecode */
  static sqInt
  extendedStoreBytecode(void)
  {
      AbstractInstruction *abstractInstruction;
      sqInt variableIndex;
      sqInt variableType;
  
  	variableType = (((usqInt)(byte1)) >> 6) & 3;
  	variableIndex = byte1 & 0x3F;
  	if (variableType == 0) {
  		return genStorePopReceiverVariableneedsStoreCheckneedsImmutabilityCheck(0, variableIndex, ((((ssTop())->type)) != SSConstant)
  		 || ((isNonImmediate(((ssTop())->constant)))
  		 && (shouldAnnotateObjectReference(((ssTop())->constant)))), 1);
  	}
  	if (variableType == 1) {
  		genStorePopTemporaryVariable(0, variableIndex);
  		
  #    if IMMUTABILITY
  		/* begin annotateBytecode: */
  		abstractInstruction = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  		(abstractInstruction->annotation = HasBytecodePC);
  #    endif /* IMMUTABILITY */
  		return 0;
  	}
  	if (variableType == 3) {
  		return genStorePopLiteralVariableneedsStoreCheckneedsImmutabilityCheck(0, variableIndex, ((((ssTop())->type)) != SSConstant)
  		 || ((isNonImmediate(((ssTop())->constant)))
  		 && (shouldAnnotateObjectReference(((ssTop())->constant)))), 1);
  	}
  	return EncounteredUnknownBytecode;
  }
  
  	/* 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));
  	}
  	/* begin ConvertR:Rd: */
  	genoperandoperand(ConvertRRd, TempReg, DPFPReg2);
  	/* begin CmpRd:Rd: */
  	genoperandoperand(CmpRdRd, DPFPReg2, argReg);
  	return gJumpFPEqual(0);
  }
  
  
  /*	Can use any of the first 32 literals for the selector and pass up to 7
  	arguments. 
   */
  
  	/* SimpleStackBasedCogit>>#genExtendedSendBytecode */
  static sqInt
  genExtendedSendBytecode(void)
  {
  	return genSendnumArgs(byte1 & 0x1F, ((usqInt)(byte1)) >> 5);
  }
  
  	/* SimpleStackBasedCogit>>#genExtendedSuperBytecode */
  static sqInt
  genExtendedSuperBytecode(void)
  {
  	return genSendSupernumArgs(byte1 & 0x1F, ((usqInt)(byte1)) >> 5);
  }
  
  
  /*	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;
  	assert(!(isDirected));
  	return genSendSupernumArgs(litIndex, nArgs);
  }
  
  	/* 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 address1;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction2;
      sqInt offset;
      sqInt wordConstant;
  
  	/* begin MoveAb:R: */
  	address = primTraceLogIndexAddress();
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(address, genoperandoperand(MoveAbR, address, r2));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperandoperand(LoadEffectiveAddressMwrR, 1, r2, r1);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(1));
  	}
  	/* begin MoveR:Ab: */
  	address1 = primTraceLogIndexAddress();
  	/* begin gen:operand:literal: */
  	checkLiteralforInstruction(address1, genoperandoperand(MoveRAb, r1, address1));
  	addDependent(methodLabel, annotateAbsolutePCRef(gMoveCwR(((sqInt)methodLabel), r1)));
  	/* begin MoveMw:r:R: */
  	offset = offsetof(CogMethod, selector);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction2 = genoperandoperandoperand(MoveMwrR, offset, r1, TempReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(offset));
  	}
  	/* begin MoveCw:R: */
  	wordConstant = ((sqInt)(primTraceLogAddress()));
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(wordConstant, genoperandoperand(MoveCwR, wordConstant, r1));
  	/* begin MoveR:Xwr:R: */
  	genoperandoperandoperand(MoveRXwrR, TempReg, r2, r1);
  }
  
  	/* SimpleStackBasedCogit>>#genLongJumpIfFalse */
  static sqInt
  genLongJumpIfFalse(void)
  {
      sqInt distance;
      sqInt target;
  
  	distance = v3LongForwardBranchDistance(generatorAt(byte0), bytecodePC, 0, methodObj);
  	target = (distance + 2) + bytecodePC;
  	return genJumpIfto(falseObject(), target);
  }
  
  	/* SimpleStackBasedCogit>>#genLongJumpIfTrue */
  static sqInt
  genLongJumpIfTrue(void)
  {
      sqInt distance;
      sqInt target;
  
  	distance = v3LongForwardBranchDistance(generatorAt(byte0), bytecodePC, 0, methodObj);
  	target = (distance + 2) + bytecodePC;
  	return genJumpIfto(trueObject(), target);
  }
  
  
  /*	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);
  }
  
  	/* SimpleStackBasedCogit>>#genLongUnconditionalBackwardJump */
  static sqInt
  genLongUnconditionalBackwardJump(void)
  {
      sqInt distance;
  
  	distance = v3LongBranchDistance(generatorAt(byte0), bytecodePC, 0, methodObj);
  	assert(distance < 0);
  	return genJumpBackTo((distance + 2) + bytecodePC);
  }
  
  	/* SimpleStackBasedCogit>>#genLongUnconditionalForwardJump */
  static sqInt
  genLongUnconditionalForwardJump(void)
  {
      sqInt distance;
      sqInt targetpc;
  
  	distance = v3LongBranchDistance(generatorAt(byte0), bytecodePC, 0, methodObj);
  	assert(distance >= 0);
  	targetpc = (distance + 2) + bytecodePC;
  	return genJumpTo(targetpc);
  }
  
  
  /*	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 *anInstruction1;
      AbstractInstruction *anInstruction2;
      sqInt cacheBaseReg;
      AbstractInstruction *itsAHit;
      AbstractInstruction *jumpClassMiss;
      AbstractInstruction *jumpInterpret;
      AbstractInstruction *jumpSelectorMiss;
      sqInt offset;
  
  
  	/* N.B.  Can't assume TempReg already contains the tag because a method can
  	   of course be invoked via the unchecked entry-point, e.g. as does perform:. */
  	genGetInlineCacheClassTagFromintoforEntry(ReceiverResultReg, SendNumArgsReg, 0);
  	flag("lookupInMethodCacheSel:classTag:");
  	cacheBaseReg = NoReg;
  	jumpSelectorMiss = compilePerformMethodCacheProbeForwithShiftbaseRegOrNone(Arg0Reg, 0, cacheBaseReg);
  	/* begin JumpNonZero: */
  	jumpClassMiss = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	/* begin MoveMw:r:R: */
  	offset = (cacheBaseReg == NoReg
  		? (((usqInt)(methodCacheAddress()))) + (((int)((usqInt)(MethodCacheMethod) << (shiftForWord()))))
  		: ((int)((usqInt)(MethodCacheMethod) << (shiftForWord()))));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperandoperand(MoveMwrR, offset, ClassReg, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(offset));
  	}
  	itsAHit = anInstruction1;
  	genLoadSlotsourceRegdestReg(HeaderIndex, SendNumArgsReg, ClassReg);
  
  	/* Adjust arguments and jump to the method's unchecked entry-point. */
  	jumpInterpret = genJumpImmediate(ClassReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction2 = genoperandoperand(AddCqR, cmNoCheckEntryOffset, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(cmNoCheckEntryOffset));
  	}
  	adjustArgumentsForPerform(numArgs);
  	/* begin JumpR: */
  	genoperand(JumpR, ClassReg);
  	jmpTarget(jumpSelectorMiss, jmpTarget(jumpClassMiss, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
  	jumpSelectorMiss = compilePerformMethodCacheProbeForwithShiftbaseRegOrNone(Arg0Reg, 1, cacheBaseReg);
  	/* begin JumpZero: */
  	genConditionalBranchoperand(JumpZero, ((sqInt)itsAHit));
  	jmpTarget(jumpSelectorMiss, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	jumpSelectorMiss = compilePerformMethodCacheProbeForwithShiftbaseRegOrNone(Arg0Reg, 2, cacheBaseReg);
  	/* begin JumpZero: */
  	genConditionalBranchoperand(JumpZero, ((sqInt)itsAHit));
  	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));
  }
  
  	/* SimpleStackBasedCogit>>#genMustBeBooleanTrampolineFor:called: */
  static usqInt 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));
  	}
  	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(ceSendMustBeBoolean, trampolineName, 1, TempReg, null, null, null, 0 /* emptyRegisterMask */, 1, NoReg, 1);
  }
  
  
  /*	Implement 28-bit hashMultiply for SmallInteger and LargePositiveInteger
  	receivers. 
   */
  
  	/* SimpleStackBasedCogit>>#genPrimitiveHashMultiply */
  static sqInt
  genPrimitiveHashMultiply(void)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *anInstruction3;
      AbstractInstruction *anInstruction4;
      AbstractInstruction * jmpFailImm;
      AbstractInstruction * jmpFailNotPositiveLargeInt;
  
  	if (mclassIsSmallInteger()) {
  		genConvertSmallIntegerToIntegerInReg(ReceiverResultReg);
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction = genoperandoperand(MoveCqR, HashMultiplyConstant, TempReg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(HashMultiplyConstant));
  		}
  		/* begin MulR:R: */
  		genMulRR(backEnd, TempReg, ReceiverResultReg);
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction1 = genoperandoperand(AndCqR, HashMultiplyMask, ReceiverResultReg);
  		if (usesOutOfLineLiteral(anInstruction1)) {
  			(anInstruction1->dependent = locateLiteral(HashMultiplyMask));
  		}
  		genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
  		/* begin RetN: */
  		genoperand(RetN, 0);
  		return CompletePrimitive;
  	}
  	jmpFailImm = genJumpImmediate(ReceiverResultReg);
  	genGetCompactClassIndexNonImmOfinto(ReceiverResultReg, ClassReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction2 = genoperandoperand(CmpCqR, ClassLargePositiveIntegerCompactIndex, ClassReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(ClassLargePositiveIntegerCompactIndex));
  	}
  	/* begin JumpNonZero: */
  	jmpFailNotPositiveLargeInt = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	genLoadSlotsourceRegdestReg(0, ReceiverResultReg, ReceiverResultReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction3 = genoperandoperand(MoveCqR, HashMultiplyConstant, TempReg);
  	if (usesOutOfLineLiteral(anInstruction3)) {
  		(anInstruction3->dependent = locateLiteral(HashMultiplyConstant));
  	}
  	/* begin MulR:R: */
  	genMulRR(backEnd, TempReg, ReceiverResultReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction4 = genoperandoperand(AndCqR, HashMultiplyMask, ReceiverResultReg);
  	if (usesOutOfLineLiteral(anInstruction4)) {
  		(anInstruction4->dependent = locateLiteral(HashMultiplyMask));
  	}
  	genConvertIntegerToSmallIntegerInReg(ReceiverResultReg);
  	/* begin RetN: */
  	genoperand(RetN, 0);
  	jmpTarget(jmpFailImm, jmpTarget(jmpFailNotPositiveLargeInt, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
  	return CompletePrimitive;
  }
  
  
  /*	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 address;
      sqInt address1;
      sqInt address3;
      sqInt address6;
      sqInt address7;
      sqInt address8;
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction5;
      AbstractInstruction *anInstruction7;
      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));
  	}
  	if (profiling) {
  
  		/* Test nextProfileTick for being non-zero and call checkProfileTick: if so.
  		   N.B. nextProfileTick is 64-bits so 32-bit systems need to test both halves. */
  		/* begin MoveAw:R: */
  		address = nextProfileTickAddress();
  		/* begin gen:literal:operand: */
  		checkLiteralforInstruction(address, genoperandoperand(MoveAwR, address, TempReg));
  		/* begin MoveAw:R: */
  		address1 = (nextProfileTickAddress()) + BytesPerWord;
  		/* begin gen:literal:operand: */
  		checkLiteralforInstruction(address1, genoperandoperand(MoveAwR, address1, ClassReg));
  		/* begin OrR:R: */
  		genoperandoperand(OrRR, TempReg, ClassReg);
  		/* begin JumpNonZero: */
  		jmpSample = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  		/* begin Label */
  		continuePostSample = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	}
  	/* begin MoveAw:R: */
  	address6 = primFailCodeAddress();
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(address6, genoperandoperand(MoveAwR, address6, TempReg));
  	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));
  	}
  	/* begin JumpNonZero: */
  	jmpFail = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	genLoadStackPointers(backEnd);
  	/* begin PopR: */
  	genoperand(PopR, ReceiverResultReg);
  	/* begin MoveAw:R: */
  	address3 = instructionPointerAddress();
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(address3, genoperandoperand(MoveAwR, address3, PCReg));
  	jmpTarget(jmpFail, gMoveAwR(newMethodAddress(), SendNumArgsReg));
  	/* begin MoveAw:R: */
  	address7 = cStackPointerAddress();
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(address7, genoperandoperand(MoveAwR, address7, SPReg));
  	compileCallFornumArgsargargargargresultRegregsToSave(ceActivateFailingPrimitiveMethod, 1, SendNumArgsReg, null, null, null, NoReg, 0 /* emptyRegisterMask */);
  	/* begin MoveAw:R: */
  	address8 = instructionPointerAddress();
  	reg = LinkReg;
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(address8, genoperandoperand(MoveAwR, address8, reg));
  	genLoadStackPointers(backEnd);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction5 = genoperandoperandoperand(MoveMwrR, 0, SPReg, ReceiverResultReg);
  	if (usesOutOfLineLiteral(anInstruction5)) {
  		(anInstruction5->dependent = locateLiteral(0));
  	}
  	/* begin RetN: */
  	genoperand(RetN, BytesPerWord);
  	if (profiling) {
  
  		/* Call ceCheckProfileTick: to record sample and then continue.  newMethod
  		   should be up-to-date.  Need to save and restore the link reg around this call. */
  		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));
  		genoperand(PopR, LinkReg);
  		/* begin Jump: */
  		genoperand(Jump, ((sqInt)continuePostSample));
  	}
  }
  
  	/* SimpleStackBasedCogit>>#genPushConstantFalseBytecode */
  static sqInt
  genPushConstantFalseBytecode(void)
  {
  	return genPushLiteral(falseObject());
  }
  
  	/* SimpleStackBasedCogit>>#genPushConstantNilBytecode */
  static sqInt
  genPushConstantNilBytecode(void)
  {
  	return genPushLiteral(nilObject());
  }
  
  	/* SimpleStackBasedCogit>>#genPushConstantTrueBytecode */
  static sqInt
  genPushConstantTrueBytecode(void)
  {
  	return genPushLiteral(trueObject());
  }
  
  	/* SimpleStackBasedCogit>>#genPushLiteralConstantBytecode */
  static sqInt
  genPushLiteralConstantBytecode(void)
  {
  	return genPushLiteralIndex(byte0 & 0x1F);
  }
  
  	/* SimpleStackBasedCogit>>#genPushLiteralVariableBytecode */
  static sqInt
  genPushLiteralVariableBytecode(void)
  {
  	return genPushLiteralVariable(byte0 & 0x1F);
  }
  
  	/* SimpleStackBasedCogit>>#genPushQuickIntegerConstantBytecode */
  static sqInt
  genPushQuickIntegerConstantBytecode(void)
  {
  	return genPushLiteral((((usqInt)(byte0 - 117) << 1) | 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));
  		}
  	}
  	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: */
  	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));
  		}
  	}
  	return genUpArrowReturn();
  }
  
  	/* SimpleStackBasedCogit>>#genReturnNil */
  static sqInt
  genReturnNil(void)
  {
      AbstractInstruction *anInstruction;
      sqInt constant;
  
  	/* begin genMoveNilR: */
  	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));
  		}
  	}
  	return genUpArrowReturn();
  }
  
  	/* SimpleStackBasedCogit>>#genReturnTrue */
  static sqInt
  genReturnTrue(void)
  {
      AbstractInstruction *anInstruction;
      sqInt constant;
  
  	/* begin genMoveTrueR: */
  	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));
  		}
  	}
  	return genUpArrowReturn();
  }
  
  
  /*	Can use any of the first 64 literals for the selector and pass up to 3
  	arguments. 
   */
  
  	/* SimpleStackBasedCogit>>#genSecondExtendedSendBytecode */
  static sqInt
  genSecondExtendedSendBytecode(void)
  {
  	return genSendnumArgs(byte1 & 0x3F, ((usqInt)(byte1)) >> 6);
  }
  
  	/* 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>>#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 - (
  #if MULTIPLEBYTECODESETS
  	(bytecodeSetOffset == 256
  		? AltFirstSpecialSelector + 256
  		: FirstSpecialSelector)
  #else /* MULTIPLEBYTECODESETS */
  	FirstSpecialSelector
  #endif /* MULTIPLEBYTECODESETS */
  	);
  	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)))));
  }
  
  
  /*	Collect the branch and send data for cogMethod, storing it into arrayObj. */
  
  	/* SimpleStackBasedCogit>>#mapPCDataFor:into: */
  sqInt
  mapPCDataForinto(CogMethod *cogMethod, sqInt arrayObj)
  {
      sqInt aMethodHeader;
      sqInt aMethodHeader1;
      sqInt aMethodObj;
      sqInt annotation;
      sqInt bcpc;
      sqInt bsOffset;
      sqInt byte;
      CogBlockMethod *cogMethod1;
      BytecodeDescriptor *descriptor;
      sqInt distance;
      sqInt endbcpc;
      sqInt errCode;
      CogMethod *homeMethod;
      sqInt isBackwardBranch;
      sqInt isInBlock;
      sqInt latestContinuation;
      usqInt map;
      sqInt mapByte;
      usqInt mcpc;
      sqInt nExts;
      sqInt nextBcpc;
      sqInt result;
      sqInt startbcpc;
      sqInt targetPC;
  
  	latestContinuation = 0;
  	introspectionDataIndex = 0;
  	introspectionData = arrayObj;
  	if (((cogMethod->stackCheckOffset)) == 0) {
  		assert(introspectionDataIndex == 0);
  		storePointerUncheckedofObjectwithValue(0, introspectionData, nilObject());
  		storePointerUncheckedofObjectwithValue(1, introspectionData, (((usqInt)cmEntryOffset << 1) | 1));
  		storePointerUncheckedofObjectwithValue(2, introspectionData, nilObject());
  		storePointerUncheckedofObjectwithValue(3, introspectionData, (((usqInt)cmNoCheckEntryOffset << 1) | 1));
  		return 4;
  	}
  	/* begin mapFor:bcpc:performUntil:arg: */
  	cogMethod1 = ((CogBlockMethod *) cogMethod);
  	startbcpc = startPCOfMethod((cogMethod->methodObject));
  	assert(((cogMethod1->stackCheckOffset)) > 0);
  
  	/* The stack check maps to the start of the first bytecode,
  	   the first bytecode being effectively after frame build. */
  	mcpc = (((usqInt)cogMethod1)) + ((cogMethod1->stackCheckOffset));
  	result = pcDataForAnnotationMcpcBcpcMethod(null, (0 + (((int)((usqInt)(HasBytecodePC) << 1)))), (((char *) mcpc)), startbcpc, (((void *)cogMethod)));
  	if (result != 0) {
  		errCode = result;
  		goto l7;
  	}
  
  	/* In both CMMethod and CMBlock cases find the start of the map and
  	   skip forward to the bytecode pc map entry for the stack check. */
  	bcpc = startbcpc;
  	if (((cogMethod1->cmType)) == CMMethod) {
  		/* begin cmIsFullBlock */
  		isInBlock = 0;
  		homeMethod = ((CogMethod *) cogMethod1);
  		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;
  		/* begin bytecodeSetOffsetForHeader: */
  		aMethodHeader = (homeMethod->methodHeader);
  		bsOffset = 
  #    if MULTIPLEBYTECODESETS
  			(headerIndicatesAlternateBytecodeSet(aMethodHeader)
  						? 256
  						: 0)
  #    else /* MULTIPLEBYTECODESETS */
  			0
  #    endif /* MULTIPLEBYTECODESETS */
  			;
  		bcpc += deltaToSkipPrimAndErrorStoreInheader(aMethodObj, (homeMethod->methodHeader));
  	}
  	else {
  		isInBlock = 1;
  		assert(bcpc == ((cogMethod1->startpc)));
  		homeMethod = cmHomeMethod(cogMethod1);
  		map = findMapLocationForMcpcinMethod((((usqInt)cogMethod1)) + (sizeof(CogBlockMethod)), homeMethod);
  		assert(map != 0);
  		annotation = ((usqInt)((byteAt(map)))) >> AnnotationShift;
  		assert(((((usqInt)(annotation)) >> AnnotationShift) == HasBytecodePC)
  		 || ((((usqInt)(annotation)) >> AnnotationShift) == IsDisplacementX2N));
  		while (((annotation = ((usqInt)((byteAt(map)))) >> AnnotationShift)) != HasBytecodePC) {
  			map -= 1;
  		}
  
  		/* skip fiducial; i.e. the map entry for the pc immediately following the method header. */
  		map -= 1;
  		aMethodObj = (homeMethod->methodObject);
  		bcpc = startbcpc - (
  #if MULTIPLEBYTECODESETS
  	(headerIndicatesAlternateBytecodeSet((homeMethod->methodHeader))
  		? AltBlockCreationBytecodeSize
  		: BlockCreationBytecodeSize)
  #else /* MULTIPLEBYTECODESETS */
  	BlockCreationBytecodeSize
  #endif /* MULTIPLEBYTECODESETS */
  	);
  		/* begin bytecodeSetOffsetForHeader: */
  		aMethodHeader1 = (homeMethod->methodHeader);
  		bsOffset = 
  #    if MULTIPLEBYTECODESETS
  			(headerIndicatesAlternateBytecodeSet(aMethodHeader1)
  						? 256
  						: 0)
  #    else /* MULTIPLEBYTECODESETS */
  			0
  #    endif /* MULTIPLEBYTECODESETS */
  			;
  		byte = (fetchByteofObject(bcpc, aMethodObj)) + bsOffset;
  		descriptor = generatorAt(byte);
  		endbcpc = (bcpc + ((descriptor->numBytes))) + (((descriptor->isBlockCreation)
  	? (/* begin spanFor:at:exts:in: */
  		((descriptor->spanFunction))(descriptor, bcpc, -1, aMethodObj))
  	: 0));
  		bcpc = startbcpc;
  	}
  	nExts = 0;
  	while ((((usqInt)((byteAt(map)))) >> AnnotationShift) != HasBytecodePC) {
  		map -= 1;
  	}
  	map -= 1;
  	while (((mapByte = byteAt(map))) != MapEnd) {
  
  		/* defensive; we exit on bcpc */
  		if (mapByte >= FirstAnnotation) {
  			annotation = ((usqInt)(mapByte)) >> AnnotationShift;
  			mcpc += (mapByte & DisplacementMask) * 4 /* codeGranularity */;
  			if (annotation >= HasBytecodePC) {
  				if ((annotation == IsSendCall)
  				 && ((((usqInt)(((mapByte = byteAt(map - 1))))) >> AnnotationShift) == IsAnnotationExtension)) {
  					annotation += mapByte & DisplacementMask;
  					map -= 1;
  				}
  				while (1) {
  					byte = (fetchByteofObject(bcpc, aMethodObj)) + bsOffset;
  					descriptor = generatorAt(byte);
  					if (isInBlock) {
  						if (bcpc >= endbcpc) {
  							errCode = 0;
  							goto l7;
  						}
  					}
  					else {
  						if (((descriptor->isReturn))
  						 && (bcpc >= latestContinuation)) {
  							errCode = 0;
  							goto l7;
  						}
  						if ((isBranch(descriptor))
  						 || ((descriptor->isBlockCreation))) {
  							/* begin latestContinuationPCFor:at:exts:in: */
  							distance = ((descriptor->spanFunction))(descriptor, bcpc, nExts, aMethodObj);
  							targetPC = (bcpc + ((descriptor->numBytes))) + (((distance < 0) ? 0 : distance));
  							latestContinuation = ((latestContinuation < targetPC) ? targetPC : latestContinuation);
  						}
  						/* latestContinuation = */ latestContinuation;
  					}
  					nextBcpc = (bcpc + ((descriptor->numBytes))) + (((descriptor->isBlockCreation)
  	? (/* begin spanFor:at:exts:in: */
  		((descriptor->spanFunction))(descriptor, bcpc, nExts, aMethodObj))
  	: 0));
  					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 l7;
  				}
  				bcpc = nextBcpc;
  				nExts = ((descriptor->isExtension)
  					? nExts + 1
  					: 0);
  			}
  		}
  		else {
  			assert(((((usqInt)(mapByte)) >> AnnotationShift) == IsDisplacementX2N)
  			 || ((((usqInt)(mapByte)) >> AnnotationShift) == IsAnnotationExtension));
  			if (mapByte < (((int)((usqInt)(IsAnnotationExtension) << AnnotationShift)))) {
  				mcpc += (((sqInt)((usqInt)((mapByte - DisplacementX2N)) << AnnotationShift))) * 4 /* codeGranularity */;
  			}
  		}
  		map -= 1;
  	}
  	errCode = 0;
  	l7:	/* end mapFor:bcpc:performUntil:arg: */;
  	if (errCode != 0) {
  		assert(errCode == PrimErrNoMemory);
  		return -1;
  	}
  	if (((cogMethod->blockEntryOffset)) != 0) {
  		errCode = blockDispatchTargetsForperformarg(cogMethod, pcDataForBlockEntryMethod, ((sqInt)cogMethod));
  		if (errCode != 0) {
  			assert(errCode == PrimErrNoMemory);
  			return -1;
  		}
  	}
  	return introspectionDataIndex;
  }
  
  	/* SimpleStackBasedCogit>>#numSpecialSelectors */
  static sqInt
  numSpecialSelectors(void)
  {
  	return 
  #  if MULTIPLEBYTECODESETS
  		(bytecodeSetOffset == 256
  				? AltNumSpecialSelectors
  				: NumSpecialSelectors)
  #  else /* MULTIPLEBYTECODESETS */
  		NumSpecialSelectors
  #  endif /* MULTIPLEBYTECODESETS */
  		;
  }
  
  
  /*	Collect the branch and send data for the block method starting at
  	blockEntryMcpc, storing it into picData.
   */
  
  	/* SimpleStackBasedCogit>>#pcDataForBlockEntry:Method: */
  static usqInt NoDbgRegParms
  pcDataForBlockEntryMethod(sqInt blockEntryMcpc, sqInt cogMethod)
  {
  	storePointerUncheckedofObjectwithValue(introspectionDataIndex, introspectionData, nilObject());
  	storePointerUncheckedofObjectwithValue(introspectionDataIndex + 1, introspectionData, (((usqInt)(blockEntryMcpc - blockNoContextSwitchOffset) << 1) | 1));
  	storePointerUncheckedofObjectwithValue(introspectionDataIndex + 2, introspectionData, nilObject());
  	storePointerUncheckedofObjectwithValue(introspectionDataIndex + 3, introspectionData, (((usqInt)blockEntryMcpc << 1) | 1));
  	introspectionDataIndex += 4;
  	return 0;
  }
  
  	/* 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)) {
  
  		/* this is the stackCheck offset */
  		assert(introspectionDataIndex == 0);
  		storePointerUncheckedofObjectwithValue(introspectionDataIndex, introspectionData, nilObject());
  		storePointerUncheckedofObjectwithValue(introspectionDataIndex + 1, introspectionData, (((usqInt)cmEntryOffset << 1) | 1));
  		storePointerUncheckedofObjectwithValue(introspectionDataIndex + 2, introspectionData, nilObject());
  		storePointerUncheckedofObjectwithValue(introspectionDataIndex + 3, introspectionData, (((usqInt)cmNoCheckEntryOffset << 1) | 1));
  		storePointerUncheckedofObjectwithValue(introspectionDataIndex + 4, introspectionData, (((usqInt)(bcpc + 1) << 1) | 1));
  		storePointerUncheckedofObjectwithValue(introspectionDataIndex + 5, introspectionData, (((((((CogMethod *) cogMethodArg))->stackCheckOffset)) << 1) | 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 << 1) | 1));
  		storePointerUncheckedofObjectwithValue(introspectionDataIndex + 1, introspectionData, (((usqInt)actualMcpc << 1) | 1));
  		introspectionDataIndex += 2;
  	}
  	return 0;
  }
  
  
  /*	If there is a generator for the current primitive then answer it;
  	otherwise answer nil. */
  
  	/* SimpleStackBasedCogit>>#primitiveGeneratorOrNil */
  static PrimitiveDescriptor *
  primitiveGeneratorOrNil(void)
  {
      PrimitiveDescriptor *primitiveDescriptor;
  
  	if (isQuickPrimitiveIndex(primitiveIndex)) {
  
  		/* an unused one */
  		primitiveDescriptor = (&(primitiveGeneratorTable[0]));
  		(primitiveDescriptor->primitiveGenerator = quickPrimitiveGeneratorFor(primitiveIndex));
  		return primitiveDescriptor;
  	}
  	if (((primitiveIndex >= 1) && (primitiveIndex <= MaxCompiledPrimitiveIndex))) {
  		return (&(primitiveGeneratorTable[primitiveIndex]));
  	}
  	return null;
  }
  
  	/* 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 callTargetAddress1;
      sqInt extent;
      sqInt flags;
      sqInt primIndex;
  
  	assert(((cogMethod->cmType)) == CMMethod);
  	primIndex = primitiveIndexOfMethodheader((cogMethod->methodObject), (cogMethod->methodHeader));
  	flags = primitivePropertyFlags(primIndex);
  	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, 3778019100U);
  	}
  	else {
  		address = (((usqInt)cogMethod)) + (externalPrimCallOffsets[(cogMethod->cmNumArgs)]);
  		/* begin rewriteCallFullAt:target: */
  		callTargetAddress1 = ((usqInt)primFunctionPointer);
  		extent = rewriteFullTransferAttargetexpectedInstruction(((AbstractInstruction *) backEnd), address, callTargetAddress1, 3778019132U);
  	}
  	if (extent > 0) {
  		flushICacheFromto(backEnd, (((usqInt)cogMethod)) + cmNoCheckEntryOffset, (((usqInt)address)) + extent);
  	}
  }
  
  	/* SimpleStackBasedCogit>>#v3:Block:Code:Size: */
  static sqInt NoDbgRegParms
  v3BlockCodeSize(BytecodeDescriptor *descriptor, sqInt pc, sqInt nExts, sqInt aMethodObj)
  {
  	assert(nExts <= 0);
  	return (((sqInt)((usqInt)((fetchByteofObject(pc + 2, aMethodObj))) << 8))) + (fetchByteofObject(pc + 3, aMethodObj));
  }
  
  
  /*	Answer the distance of a two byte forward long jump. */
  
  	/* SimpleStackBasedCogit>>#v3:LongForward:Branch:Distance: */
  static sqInt NoDbgRegParms
  v3LongForwardBranchDistance(BytecodeDescriptor *descriptor, sqInt pc, sqInt nExts, sqInt aMethodObj)
  {
  	assert(nExts == 0);
  	return (((sqInt)((usqInt)(((fetchByteofObject(pc, aMethodObj)) & 3)) << 8))) + (fetchByteofObject(pc + 1, aMethodObj));
  }
  
  
  /*	Answer the distance of a two byte forward long jump. */
  
  	/* SimpleStackBasedCogit>>#v3:Long:Branch:Distance: */
  static sqInt NoDbgRegParms
  v3LongBranchDistance(BytecodeDescriptor *descriptor, sqInt pc, sqInt nExts, sqInt aMethodObj)
  {
  	assert(nExts == 0);
  	return (((sqInt)((usqInt)((((fetchByteofObject(pc, aMethodObj)) & 7) - 4)) << 8))) + (fetchByteofObject(pc + 1, aMethodObj));
  }
  
  
  /*	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;
  }
  
  	/* SimpleStackBasedCogit>>#voidCogCompiledCode */
  void
  voidCogCompiledCode(void)
  {
      sqInt i;
  
  	clearCogCompiledCode();
  	for (i = 0; i <= MaxNumArgs; i += 1) {
  		externalPrimJumpOffsets[i] = null;
  		externalPrimCallOffsets[i] = null;
  		externalSetPrimOffsets[i] = null;
  	}
  }
  
  
  /*	Add a blockStart for an embedded block. For a binary tree walk block
  	dispatch blocks must be compiled in pc/depth-first order but are scanned
  	in breadth-first
  	order, so do an insertion sort (which of course is really a bubble sort
  	because we
  	have to move everything higher to make room). */
  
  	/* StackToRegisterMappingCogit>>#addBlockStartAt:numArgs:numCopied:span: */
  static BlockStart * NoDbgRegParms
  addBlockStartAtnumArgsnumCopiedspan(sqInt bytecodepc, sqInt numArgs, sqInt numCopied, sqInt span)
  {
      BlockStart *blockStart;
      sqInt i;
      sqInt j;
  
  
  	/* Transcript ensureCr; nextPutAll: 'addBlockStartAt: '; print: bytecodepc; cr; flush. */
  	if (blockCount > 0) {
  		i = blockCount - 1;
  		while (1) {
  
  			/* check for repeat addition during recompilation due to initialNil miscount. */
  			blockStart = (&(blockStarts[i]));
  			if (((blockStart->startpc)) == bytecodepc) {
  				return blockStart;
  			}
  			if (!((((blockStart->startpc)) > bytecodepc)
  			 && (i > 0))) break;
  			i -= 1;
  		}
  		for (j = blockCount; j >= (i + 1); j += -1) {
  			blockStarts[j] = (blockStarts[j - 1]);
  		}
  		blockStart = (&(blockStarts[i + 1]));
  	}
  	else {
  		blockStart = (&(blockStarts[blockCount]));
  	}
  	blockCount += 1;
  	(blockStart->startpc = bytecodepc);
  	(blockStart->numArgs = numArgs);
  	(blockStart->numCopied = numCopied);
  	(blockStart->numInitialNils = 0);
  	(blockStart->stackCheckLabel = null);
  	(blockStart->hasInstVarRef = 0);
  	(blockStart->span = span);
  	return blockStart;
  }
  
  
  /*	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->	retpc */
  /*	Generate 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 *anInstruction10;
      AbstractInstruction *anInstruction11;
      AbstractInstruction *anInstruction12;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *anInstruction3;
      sqInt index;
  
  	assert((numRegArgs()) <= 2);
  	assert(numArgs >= 1);
  	if (numArgs <= 1 /* numRegArgs */) {
  		if (numArgs == 2) {
  			/* begin MoveR:R: */
  			genoperandoperand(MoveRR, Arg1Reg, Arg0Reg);
  		}
  		return;
  	}
  	if ((2) == numArgs) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction2 = genoperandoperandoperand(MoveMwrR, 0, SPReg, Arg0Reg);
  		if (usesOutOfLineLiteral(anInstruction2)) {
  			(anInstruction2->dependent = locateLiteral(0));
  		}
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction3 = genoperandoperand(AddCqR, (numArgs + 1) * BytesPerWord, SPReg);
  		if (usesOutOfLineLiteral(anInstruction3)) {
  			(anInstruction3->dependent = locateLiteral((numArgs + 1) * BytesPerWord));
  		}
  		return;
  	}
  	for (index = (numArgs - 2); index >= 0; index += -1) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction10 = genoperandoperandoperand(MoveMwrR, index * BytesPerWord, SPReg, TempReg);
  		if (usesOutOfLineLiteral(anInstruction10)) {
  			(anInstruction10->dependent = locateLiteral(index * BytesPerWord));
  		}
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction11 = genoperandoperandoperand(MoveRMwr, TempReg, (index + 1) * BytesPerWord, SPReg);
  		if (usesOutOfLineLiteral(anInstruction11)) {
  			(anInstruction11->dependent = locateLiteral((index + 1) * BytesPerWord));
  		}
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction12 = genoperandoperand(AddCqR, BytesPerWord, SPReg);
  	if (usesOutOfLineLiteral(anInstruction12)) {
  		(anInstruction12->dependent = locateLiteral(BytesPerWord));
  	}
  }
  
  
  /*	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 sqInt 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) {
  
  		/* No free register, choose one that does not conflict with regMask */
  		reg = freeAnyRegNotConflictingWith(regMask);
  	}
  	if (reg == ReceiverResultReg) {
  
  		/* If we've allocated RcvrResultReg, it's not live anymore */
  		voidReceiverResultRegContainsSelf();
  	}
  	return reg;
  }
  
  	/* StackToRegisterMappingCogit>>#anyReferencesToRegister:inTopNItems: */
  static sqInt NoDbgRegParms
  anyReferencesToRegisterinTopNItems(sqInt reg, sqInt n)
  {
      sqInt i;
      sqInt regMask;
  
  	/* begin registerMaskFor: */
  	regMask = 1U << reg;
  	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;
  
  	traceSimStack();
  	bytecodePC = start;
  	nExts = (result = 0);
  	descriptor = null;
  	deadCode = 0;
  	while (1) {
  		maybeHaltIfDebugPC();
  		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)));
  			}
  		}
  		traceDescriptor(descriptor);
  		traceSimStack();
  		/* begin patchFixupTargetIfNeeded:nextOpcodeIndex: */
  		if ((((((usqInt)((fixup->targetInstruction)))) >= NeedsNonMergeFixupFlag) && ((((usqInt)((fixup->targetInstruction)))) <= NeedsMergeFixupFlag))) {
  
  			/* There is a fixup for this bytecode.  It must point to the first generated
  			   instruction for this bytecode.  If there isn't one we need to add a label. */
  			if (opcodeIndex == nextOpcodeIndex) {
  				/* begin Label */
  				genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  			}
  			(fixup->targetInstruction = abstractInstructionAt(nextOpcodeIndex));
  		}
  		/* begin maybeDumpLiterals: */
  		if ((mustDumpLiterals(opcodeIndex))
  		 || (((isBranch(descriptor))
  		 && (!(((descriptor->isBranchTrue))
  		 || ((descriptor->isBranchFalse)))))
  		 || ((descriptor->isReturn)))) {
  			dumpLiterals(!(((isBranch(descriptor))
  			 && (!(((descriptor->isBranchTrue))
  			 || ((descriptor->isBranchFalse)))))
  			 || ((descriptor->isReturn))));
  		}
  		/* begin nextBytecodePCFor:exts: */
  		bytecodePC = (bytecodePC + ((descriptor->numBytes))) + (((descriptor->isBlockCreation)
  	? ((descriptor->spanFunction))(descriptor, bytecodePC, nExts, methodObj)
  	: 0));
  		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.");
  	}
  	return result;
  }
  
  	/* StackToRegisterMappingCogit>>#compileBlockBodies */
  static sqInt
  compileBlockBodies(void)
  {
      BlockStart *blockStart;
      sqInt compiledBlocksCount;
      sqInt initialCounterIndex;
      sqInt initialOpcodeIndex;
      sqInt initialStackPtr;
      sqInt (* const pushNilSizeFunction)(sqInt,sqInt) = v3PushNilSizenumInitialNils;
      sqInt result;
      sqInt savedFirstOpcodeIndex;
      sqInt savedLastDumpedLiteralIndex;
      unsigned char savedNeedsFrame;
      sqInt savedNextLiteralIndex;
      sqInt savedNumArgs;
      sqInt savedNumTemps;
  
  	assert(blockCount > 0);
  	savedNeedsFrame = needsFrame;
  	savedNumArgs = methodOrBlockNumArgs;
  	savedNumTemps = methodOrBlockNumTemps;
  	inBlock = InVanillaBlock;
  	compiledBlocksCount = 0;
  	while (compiledBlocksCount < blockCount) {
  		compilationPass = 1;
  		blockStart = blockStartAt(compiledBlocksCount);
  		if (((result = scanBlock(blockStart))) < 0) {
  			return result;
  		}
  		initialOpcodeIndex = opcodeIndex;
  
  		/* for SistaCogit */
  		initialCounterIndex = 0 /* maybeCounterIndex */;
  		/* begin saveForRecompile */
  		savedFirstOpcodeIndex = firstOpcodeIndex;
  		savedNextLiteralIndex = nextLiteralIndex;
  		savedLastDumpedLiteralIndex = lastDumpedLiteralIndex;
  		while (1) {
  			compileBlockEntry(blockStart);
  			initialStackPtr = simStackPtr;
  			if (((result = compileAbstractInstructionsFromthrough(((blockStart->startpc)) + (pushNilSizeFunction(methodObj, ((blockStart->numInitialNils)))), (((blockStart->startpc)) + ((blockStart->span))) - 1))) < 0) {
  				return result;
  			}
  			if (initialStackPtr == simStackPtr) break;
  			assert((initialStackPtr > simStackPtr)
  			 || (deadCode));
  
  			/* for asserts */
  			compilationPass += 1;
  			(blockStart->numInitialNils = (((blockStart->numInitialNils)) + simStackPtr) - initialStackPtr);
  			(((blockStart->fakeHeader))->dependent = null);
  			reinitializeFixupsFromthrough(((blockStart->startpc)) + ((blockStart->numInitialNils)), (((blockStart->startpc)) + ((blockStart->span))) - 1);
  			bzero(abstractOpcodes + initialOpcodeIndex,
  									(opcodeIndex - initialOpcodeIndex) * sizeof(AbstractInstruction));
  			opcodeIndex = initialOpcodeIndex;
  			/* begin resetForRecompile */
  			firstOpcodeIndex = savedFirstOpcodeIndex;
  			nextLiteralIndex = savedNextLiteralIndex;
  			lastDumpedLiteralIndex = savedLastDumpedLiteralIndex;
  					}
  		compiledBlocksCount += 1;
  	}
  	needsFrame = savedNeedsFrame;
  	methodOrBlockNumArgs = savedNumArgs;
  	methodOrBlockNumTemps = savedNumTemps;
  	return 0;
  }
  
  
  /*	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. */
  /*	Build a frame for a block activation. See CoInterpreter
  	class>>initializeFrameIndices. Override to push the register receiver and
  	register arguments, if any, and to correctly
  	initialize the explicitly nilled/pushed temp entries (they are /not/ of
  	type constant nil). */
  
  	/* StackToRegisterMappingCogit>>#compileBlockFrameBuild: */
  static void NoDbgRegParms
  compileBlockFrameBuild(BlockStart *blockStart)
  {
      AbstractInstruction *abstractInstruction;
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction * cascade0;
      sqInt constant;
      sqInt constant1;
      sqInt i;
      sqInt ign;
      sqInt offset;
  
  	/* begin annotateBytecode: */
  	abstractInstruction = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	(abstractInstruction->annotation = HasBytecodePC);
  	/* begin PushR: */
  	genoperand(PushR, LinkReg);
  	/* begin PushR: */
  	genoperand(PushR, FPReg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, SPReg, FPReg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, ReceiverResultReg, ClassReg);
  	cascade0 = (blockStart->fakeHeader);
  	addDependent(cascade0, annotateAbsolutePCRef(gPushCw(((sqInt)((blockStart->fakeHeader))))));
  	/* begin setLabelOffset: */
  	((cascade0->operands))[1] = MFMethodFlagIsBlockFlag;
  	annotateobjRef(gPushCw(nilObject()), nilObject());
  	if ((blockStart->hasInstVarRef)) {
  
  		/* Use ReceiverResultReg for Context to agree with store check trampoline */
  		genLoadSlotsourceRegdestReg(ClosureOuterContextIndex, ClassReg, ReceiverResultReg);
  		genLoadSlotsourceRegdestReg(ReceiverIndex, ReceiverResultReg, Arg0Reg);
  		/* begin genEnsureOopInRegNotForwarded:scratchReg:updatingSlot:in: */
  		assert(0);
  		/* begin genEnsureOopInRegNotForwarded:scratchReg:updatingMw:r: */
  		offset = (ReceiverIndex * BytesPerWord) + BaseHeaderSize;
  		/* begin MoveR:R: */
  		genoperandoperand(MoveRR, Arg0Reg, ReceiverResultReg);
  	}
  	else {
  		genLoadSlotsourceRegdestReg(ClosureOuterContextIndex, ClassReg, Arg0Reg);
  		genLoadSlotsourceRegdestReg(ReceiverIndex, Arg0Reg, ReceiverResultReg);
  	}
  	/* begin PushR: */
  	genoperand(PushR, ReceiverResultReg);
  	for (i = 0; i < ((blockStart->numCopied)); i += 1) {
  		genLoadSlotsourceRegdestReg(i + ClosureFirstCopiedValueIndex, ClassReg, TempReg);
  		/* begin PushR: */
  		genoperand(PushR, TempReg);
  	}
  	(blockStart->stackCheckLabel = compileStackOverflowCheck(1));
  	methodOrBlockNumTemps = (((blockStart->numArgs)) + ((blockStart->numCopied))) + ((blockStart->numInitialNils));
  	initSimStackForFramefulMethod((blockStart->startpc));
  	if (((blockStart->numInitialNils)) > 0) {
  		if (((blockStart->numInitialNils)) > 1) {
  			/* begin genMoveNilR: */
  			constant = nilObject();
  			if (shouldAnnotateObjectReference(constant)) {
  				annotateobjRef(gMoveCwR(constant, TempReg), constant);
  			}
  			else {
  				/* begin checkQuickConstant:forInstruction: */
  				anInstruction = genoperandoperand(MoveCqR, constant, TempReg);
  				if (usesOutOfLineLiteral(anInstruction)) {
  					(anInstruction->dependent = locateLiteral(constant));
  				}
  			}
  			for (ign = 1; ign <= ((blockStart->numInitialNils)); ign += 1) {
  				/* begin PushR: */
  				genoperand(PushR, TempReg);
  			}
  		}
  		else {
  			/* begin genPushConstant: */
  			constant1 = nilObject();
  			if (shouldAnnotateObjectReference(constant1)) {
  				annotateobjRef(gPushCw(constant1), constant1);
  			}
  			else {
  				/* begin checkQuickConstant:forInstruction: */
  				anInstruction1 = genoperand(PushCq, constant1);
  				if (usesOutOfLineLiteral(anInstruction1)) {
  					(anInstruction1->dependent = locateLiteral(constant1));
  				}
  			}
  		}
  	}
  }
  
  
  /*	Make sure ReceiverResultReg holds the receiver, loaded from the closure,
  	which is what is initially in ReceiverResultReg. We must annotate the
  	first instruction in vanilla blocks so that
  	findMethodForStartBcpc:inHomeMethod: can function. We need two annotations
  	because the first is a fiducial. */
  /*	Make sure ReceiverResultReg holds the receiver, loaded from
  	the closure, which is what is initially in ReceiverResultReg */
  
  	/* StackToRegisterMappingCogit>>#compileBlockFramelessEntry: */
  static void NoDbgRegParms
  compileBlockFramelessEntry(BlockStart *blockStart)
  {
      AbstractInstruction *abstractInstruction;
      AbstractInstruction *abstractInstruction1;
      sqInt offset;
  
  	methodOrBlockNumTemps = (((blockStart->numArgs)) + ((blockStart->numCopied))) + ((blockStart->numInitialNils));
  	initSimStackForFramelessBlock((blockStart->startpc));
  	if (!(((blockStart->entryLabel)) == null)) {
  		/* begin annotateBytecode: */
  		abstractInstruction = (blockStart->entryLabel);
  		(abstractInstruction->annotation = HasBytecodePC);
  		/* begin annotateBytecode: */
  		abstractInstruction1 = (blockStart->entryLabel);
  		(abstractInstruction1->annotation = HasBytecodePC);
  	}
  	if ((blockStart->hasInstVarRef)) {
  
  		/* Use ReceiverResultReg for Context to agree with store check trampoline */
  		genLoadSlotsourceRegdestReg(ClosureOuterContextIndex, ReceiverResultReg, ReceiverResultReg);
  		genLoadSlotsourceRegdestReg(ReceiverIndex, ReceiverResultReg, Arg0Reg);
  		/* begin genEnsureOopInRegNotForwarded:scratchReg:updatingSlot:in: */
  		assert(0);
  		/* begin genEnsureOopInRegNotForwarded:scratchReg:updatingMw:r: */
  		offset = (ReceiverIndex * BytesPerWord) + BaseHeaderSize;
  		/* begin MoveR:R: */
  		genoperandoperand(MoveRR, Arg0Reg, ReceiverResultReg);
  	}
  	else {
  		genLoadSlotsourceRegdestReg(ClosureOuterContextIndex, ReceiverResultReg, TempReg);
  		genLoadSlotsourceRegdestReg(ReceiverIndex, TempReg, ReceiverResultReg);
  	}
  }
  
  	/* StackToRegisterMappingCogit>>#compileCogMethod: */
  static CogMethod * NoDbgRegParms
  compileCogMethod(sqInt selector)
  {
      sqInt allocBytes;
      int extra;
      sqInt fixupBytes;
      sqInt numBlocks;
      sqInt numBytecodes;
      sqInt numberOfAbstractOpcodes;
      sqInt numCleanBlocks;
      sqInt opcodeBytes;
      sqInt result;
  
  	methodOrBlockNumTemps = tempCountOf(methodObj);
  	setHasMovableLiteral(0);
  	setHasYoungReferent((isYoungObject(methodObj))
  	 || (isYoung(selector)));
  	methodOrBlockNumArgs = argumentCountOf(methodObj);
  	inBlock = 0;
  	postCompileHook = null;
  	maxLitIndex = -1;
  	extra = ((((primitiveIndex = primitiveIndexOf(methodObj))) > 0)
  	 && (!(isQuickPrimitiveIndex(primitiveIndex)))
  		? 30
  		: 10);
  
  	/* initial estimate.  Actual endPC is determined in scanMethod. */
  	initialPC = startPCOfMethod(methodObj);
  	endPC = (isQuickPrimitiveIndex(primitiveIndex)
  		? initialPC - 1
  		: numBytesOf(methodObj));
  	numBytecodes = (endPC - initialPC) + 1;
  	/* begin allocateOpcodes:bytecodes:ifFail: */
  	numberOfAbstractOpcodes = (numBytecodes + extra) * 10 /* estimateOfAbstractOpcodesPerBytecodes */;
  	numAbstractOpcodes = numberOfAbstractOpcodes;
  	opcodeBytes = (sizeof(CogAbstractInstruction)) * numAbstractOpcodes;
  	fixupBytes = (sizeof(CogBytecodeFixup)) * numAbstractOpcodes;
  
  	/* Document the fact that the MaxStackAllocSize ensures that the number of abstract
  	   opcodes fits in a 16 bit integer (e.g. CogBytecodeFixup's instructionIndex). */
  	allocBytes = opcodeBytes + fixupBytes;
  	assert((((sizeof(CogAbstractInstruction)) + (sizeof(CogBytecodeFixup))) * 49152) > MaxStackAllocSize);
  	if (allocBytes > MaxStackAllocSize) {
  		return ((CogMethod *) MethodTooBig);
  		goto l1;
  	}
  	abstractOpcodes = alloca(allocBytes);
  	bzero(abstractOpcodes, allocBytes);
  	fixups = ((void *)((((usqInt)abstractOpcodes)) + opcodeBytes));
  	zeroOpcodeIndexForNewOpcodes();
  	labelCounter = 0;
  	l1:	/* end allocateOpcodes:bytecodes:ifFail: */;
  	if (((numBlocks = scanMethod())) < 0) {
  		return ((CogMethod *) numBlocks);
  	}
  	numCleanBlocks = scanForCleanBlocks();
  	if (methodFoundInvalidPostScan()) {
  		return ((CogMethod *) ShouldNotJIT);
  	}
  	allocateBlockStarts(numBlocks + numCleanBlocks);
  	blockCount = 0;
  	if (numCleanBlocks > 0) {
  		addCleanBlockStarts();
  	}
  	if (!(maybeAllocAndInitIRCs())) {
  
  		/* Inaccurate error code, but it'll do.  This will likely never fail. */
  		return ((CogMethod *) InsufficientCodeSpace);
  	}
  	blockEntryLabel = null;
  	(methodLabel->dependent = null);
  	if (((result = compileEntireMethod())) < 0) {
  		return ((CogMethod *) result);
  	}
  	return generateCogMethod(selector);
  }
  
  
  /*	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)
  {
      sqInt result;
  
  	regArgsHaveBeenPushed = 0;
  	/* begin preenMethodLabel */
  	(((((AbstractInstruction *) methodLabel))->operands))[1] = 0;
  	compileAbort();
  	compileEntry();
  	if (((result = compilePrimitive())) < 0) {
  		return result;
  	}
  	compileFrameBuild();
  	if (((result = compileMethodBody())) < 0) {
  		return result;
  	}
  	if (blockCount == 0) {
  		return 0;
  	}
  	if (((result = compileBlockBodies())) < 0) {
  		return result;
  	}
  	return compileBlockDispatch();
  }
  
  
  /*	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)
  {
      AbstractInstruction *anInstruction;
      sqInt constant;
      sqInt i;
      sqInt iLimiT;
  
  	
  #  if IMMUTABILITY
  	if (useTwoPaths) {
  		compileTwoPathFrameBuild();
  		return;
  	}
  #  endif /* IMMUTABILITY */
  	if (!needsFrame) {
  		if (useTwoPaths) {
  			compileTwoPathFramelessInit();
  		}
  		initSimStackForFramelessMethod(initialPC);
  		return;
  	}
  	assert(!(useTwoPaths));
  	genPushRegisterArgs();
  	if (!needsFrame) {
  		return;
  	}
  	/* begin PushR: */
  	genoperand(PushR, LinkReg);
  	/* begin PushR: */
  	genoperand(PushR, FPReg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, SPReg, FPReg);
  	addDependent(methodLabel, annotateAbsolutePCRef(gPushCw(((sqInt)methodLabel))));
  	/* begin genMoveNilR: */
  	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));
  		}
  	}
  	/* begin PushR: */
  	genoperand(PushR, SendNumArgsReg);
  	/* begin PushR: */
  	genoperand(PushR, ReceiverResultReg);
  	for (i = (methodOrBlockNumArgs + 1), iLimiT = (temporaryCountOfMethodHeader(methodHeader)); i <= iLimiT; i += 1) {
  		/* begin PushR: */
  		genoperand(PushR, SendNumArgsReg);
  	}
  	if (((primitiveIndexOfMethodheader(methodObj, methodHeader)) > 0)
  	 && ((longStoreBytecodeForHeader(methodHeader)) == (fetchByteofObject((startPCOfMethod(methodObj)) + (sizeOfCallPrimitiveBytecode(methodHeader)), methodObj)))) {
  		compileGetErrorCode();
  	}
  	stackCheckLabel = compileStackOverflowCheck(canContextSwitchIfActivatingheader(methodObj, methodHeader));
  	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;
      sqInt constant;
      sqInt i;
      sqInt iLimiT;
      sqInt jumpImmutable;
      AbstractInstruction * jumpOld;
  
  	assert(useTwoPaths);
  	assert(blockCount == 0);
  	jumpImmutable = genJumpImmutablescratchReg(ReceiverResultReg, TempReg);
  	/* begin genJumpInOldSpace: */
  	
  	/* N.B. FLAGS := destReg - scratchReg */
  	/* begin MoveAw:R: */
  	address = youngStartAddress();
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(address, genoperandoperand(MoveAwR, address, TempReg));
  	/* begin CmpR:R: */
  	assert(!((TempReg == SPReg)));
  	genoperandoperand(CmpRR, TempReg, ReceiverResultReg);
  	/* begin JumpBelow: */
  	jumpOld = genConditionalBranchoperand(JumpBelow, ((sqInt)0));
  	assert(!needsFrame);
  	initSimStackForFramelessMethod(initialPC);
  	/* begin compileMethodBody */
  	if (endPC < initialPC) {
  		goto l8;
  	}
  	compileAbstractInstructionsFromthrough(initialPC + (deltaToSkipPrimAndErrorStoreInheader(methodObj, methodHeader)), endPC);
  	l8:	/* end compileMethodBody */;
  
  	/* reset because it impacts inst var store compilation */
  	useTwoPaths = 0;
  	needsFrame = 1;
  	jmpTarget(jumpOld, jmpTarget(jumpImmutable, genoperandoperand(Label, (labelCounter += 1), bytecodePC)));
  	genPushRegisterArgs();
  	if (!needsFrame) {
  		return;
  	}
  	/* begin PushR: */
  	genoperand(PushR, LinkReg);
  	/* begin PushR: */
  	genoperand(PushR, FPReg);
  	/* begin MoveR:R: */
  	genoperandoperand(MoveRR, SPReg, FPReg);
  	addDependent(methodLabel, annotateAbsolutePCRef(gPushCw(((sqInt)methodLabel))));
  	/* begin genMoveNilR: */
  	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));
  		}
  	}
  	/* begin PushR: */
  	genoperand(PushR, SendNumArgsReg);
  	/* begin PushR: */
  	genoperand(PushR, ReceiverResultReg);
  	for (i = (methodOrBlockNumArgs + 1), iLimiT = (temporaryCountOfMethodHeader(methodHeader)); i <= iLimiT; i += 1) {
  		/* begin PushR: */
  		genoperand(PushR, SendNumArgsReg);
  	}
  	if (((primitiveIndexOfMethodheader(methodObj, methodHeader)) > 0)
  	 && ((longStoreBytecodeForHeader(methodHeader)) == (fetchByteofObject((startPCOfMethod(methodObj)) + (sizeOfCallPrimitiveBytecode(methodHeader)), methodObj)))) {
  		compileGetErrorCode();
  	}
  	stackCheckLabel = compileStackOverflowCheck(canContextSwitchIfActivatingheader(methodObj, methodHeader));
  	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)
  {
      sqInt address;
      AbstractInstruction * jumpOld;
  
  	assert(!(IMMUTABILITY));
  	assert(!(needsFrame));
  	assert(useTwoPaths);
  	/* begin genJumpInOldSpace: */
  	
  	/* N.B. FLAGS := destReg - scratchReg */
  	/* begin MoveAw:R: */
  	address = youngStartAddress();
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(address, genoperandoperand(MoveAwR, address, TempReg));
  	/* begin CmpR:R: */
  	assert(!((TempReg == SPReg)));
  	genoperandoperand(CmpRR, TempReg, ReceiverResultReg);
  	/* begin JumpBelow: */
  	jumpOld = genConditionalBranchoperand(JumpBelow, ((sqInt)0));
  	initSimStackForFramelessMethod(initialPC);
  	/* begin compileMethodBody */
  	if (endPC < initialPC) {
  		goto l5;
  	}
  	compileAbstractInstructionsFromthrough(initialPC + (deltaToSkipPrimAndErrorStoreInheader(methodObj, methodHeader)), endPC);
  	l5:	/* end compileMethodBody */;
  
  	/* reset because it impacts inst var store compilation */
  	useTwoPaths = 0;
  	jmpTarget(jumpOld, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  }
  
  	/* StackToRegisterMappingCogit>>#cPICMissTrampolineFor: */
  static sqInt NoDbgRegParms
  cPICMissTrampolineFor(sqInt numArgs)
  {
  	return picMissTrampolines[((numArgs < (2)) ? numArgs : (2))];
  }
  
  
  /*	Replaces the Blue Book double-extended send [132], in which the first byte
  	was wasted on 8 bits of argument count. 
  	Here we use 3 bits for the operation sub-type (opType), and the remaining
  	5 bits for argument count where needed. 
  	The last byte give access to 256 instVars or literals. 
  	See also secondExtendedSendBytecode
   */
  
  	/* StackToRegisterMappingCogit>>#doubleExtendedDoAnythingBytecode */
  static sqInt
  doubleExtendedDoAnythingBytecode(void)
  {
      AbstractInstruction *abstractInstruction;
      AbstractInstruction *abstractInstruction1;
      AbstractInstruction *abstractInstruction2;
      sqInt opType;
  
  	opType = ((usqInt)(byte1)) >> 5;
  	if (opType == 0) {
  		return genSendnumArgs(byte2, byte1 & 0x1F);
  	}
  	if (opType == 1) {
  		return genSendSupernumArgs(byte2, byte1 & 0x1F);
  	}
  	
  	switch (opType) {
  	case 2:
  		if (isReadMediatedContextInstVarIndex(byte2)) {
  			genPushMaybeContextReceiverVariable(byte2);
  		}
  		else {
  			genPushReceiverVariable(byte2);
  			/* begin annotateInstructionForBytecode */
  			if (prevInstIsPCAnnotated()) {
  				/* begin Nop */
  				abstractInstruction = gen(Nop);
  			}
  			else {
  				/* begin Label */
  				abstractInstruction = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  			}
  			(abstractInstruction->annotation = HasBytecodePC);
  			return 0;
  		}
  		break;
  	case 3:
  		genPushLiteralIndex(byte2);
  		/* begin annotateInstructionForBytecode */
  		if (prevInstIsPCAnnotated()) {
  			/* begin Nop */
  			abstractInstruction1 = gen(Nop);
  		}
  		else {
  			/* begin Label */
  			abstractInstruction1 = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  		}
  		(abstractInstruction1->annotation = HasBytecodePC);
  		return 0;
  
  	case 4:
  		genPushLiteralVariable(byte2);
  		break;
  	case 7:
  		genStorePopLiteralVariableneedsStoreCheckneedsImmutabilityCheck(0, byte2, ((((ssTop())->type)) != SSConstant)
  		 || ((isNonImmediate(((ssTop())->constant)))
  		 && (shouldAnnotateObjectReference(((ssTop())->constant)))), 1);
  		
  #    if IMMUTABILITY
  
  		/* genStorePop:LiteralVariable: annotates; don't annotate twice */
  		return 0;
  #    endif /* IMMUTABILITY */
  		break;
  	default:
  		
  		/* 5 & 6 */
  		if (isWriteMediatedContextInstVarIndex(byte2)) {
  			genStorePopMaybeContextReceiverVariableneedsStoreCheckneedsImmutabilityCheck(opType == 6, byte2, ((((ssTop())->type)) != SSConstant)
  			 || ((isNonImmediate(((ssTop())->constant)))
  			 && (shouldAnnotateObjectReference(((ssTop())->constant)))), 1);
  		}
  		else {
  			genStorePopReceiverVariableneedsStoreCheckneedsImmutabilityCheck(opType == 6, byte2, ((((ssTop())->type)) != SSConstant)
  			 || ((isNonImmediate(((ssTop())->constant)))
  			 && (shouldAnnotateObjectReference(((ssTop())->constant)))), 1);
  		}
  		
  #    if IMMUTABILITY
  
  		/* genStorePop:...ReceiverVariable: annotate; don't annotate twice */
  		return 0;
  #    endif /* IMMUTABILITY */
  ;
  	}
  	assert(needsFrame);
  	assert(!(prevInstIsPCAnnotated()));
  	/* begin annotateBytecode: */
  	abstractInstruction2 = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	(abstractInstruction2->annotation = HasBytecodePC);
  	return 0;
  }
  
  	/* StackToRegisterMappingCogit>>#duplicateTopBytecode */
  static sqInt
  duplicateTopBytecode(void)
  {
      SimStackEntry desc;
  
  	/* begin ssTopDescriptor */
  	desc = simStack[simStackPtr];
  	return ssPushDesc(desc);
  }
  
  
  /*	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: */
  static BytecodeFixup * NoDbgRegParms
  ensureFixupAt(sqInt targetPC)
  {
      BytecodeFixup *fixup;
  
  	/* begin fixupAt: */
  	fixup = fixupAtIndex(targetPC - initialPC);
  	traceFixupmerge(fixup, 1);
  	if ((((usqInt)((fixup->targetInstruction)))) <= NeedsNonMergeFixupFlag) {
  
  		/* convert a non-merge into a merge */
  		/* begin becomeMergeFixup */
  		(fixup->targetInstruction) = ((AbstractInstruction *) NeedsMergeFixupFlag);
  		(fixup->simStackPtr = simStackPtr);
  			}
  	else {
  		if ((fixup->isTargetOfBackwardBranch)) {
  
  			/* this is the target of a backward branch and
  			   so doesn't have a simStackPtr assigned yet. */
  			(fixup->simStackPtr = simStackPtr);
  					}
  		else {
  			assert(((fixup->simStackPtr)) == simStackPtr);
  					}
  	}
  	/* begin 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);
  	traceFixupmerge(fixup, 1);
  	if (((fixup->targetInstruction)) == 0) {
  		/* begin becomeNonMergeFixup */
  		(fixup->targetInstruction) = ((AbstractInstruction *) NeedsNonMergeFixupFlag);
  	}
  	/* begin recordBcpc: */
  	return fixup;
  }
  
  	/* StackToRegisterMappingCogit>>#ensureReceiverResultRegContainsSelf */
  static void
  ensureReceiverResultRegContainsSelf(void)
  {
  	if (needsFrame) {
  		if (!((((simSelf())->liveRegister)) == ReceiverResultReg)) {
  			/* begin ssAllocateRequiredReg: */
  			ssAllocateRequiredRegMaskupThroughupThroughNative(1U << ReceiverResultReg, simStackPtr, simNativeStackPtr);
  			/* begin putSelfInReceiverResultReg */
  			storeToReg(simSelf(), ReceiverResultReg);
  			((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(bytecodeSetOffset + 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)
  {
      sqInt cond;
      sqInt currentTarget;
      BytecodeDescriptor *descriptor;
      sqInt nExts;
      sqInt nextPC;
      sqInt span;
  
  	cond = 0;
  	nextPC = (currentTarget = targetBytecodePC);
  	while(1) {
  		nExts = 0;
  		while (1) {
  			/* begin generatorForPC: */
  			descriptor = generatorAt(bytecodeSetOffset + (fetchByteofObject(nextPC, methodObj)));
  			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);
  			if (span < 0) {
  
  				/* Do *not* follow backward branches; these are interrupt points and should not be elided. */
  				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(bytecodeSetOffset + (fetchByteofObject(nextPC, methodObj)));
  				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 & (1U << ((desc->registerr))))) {
  				reg = (desc->registerr);
  			}
  		}
  		index += 1;
  	}
  	assert(!((reg == NoReg)));
  	/* begin ssAllocateRequiredReg: */
  	ssAllocateRequiredRegMaskupThroughupThroughNative(1U << reg, simStackPtr, simNativeStackPtr);
  	return reg;
  }
  
  
  /*	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);
  		/* begin PopR: */
  		genoperand(PopR, FPReg);
  		/* begin PopR: */
  		genoperand(PopR, LinkReg);
  	}
  	/* begin RetN: */
  	genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  
  	/* can't fall through */
  	deadCode = 1;
  	return 0;
  }
  
  
  /*	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;
      usqInt 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));
  	}
  	genLoadStackPointers(backEnd);
  	/* begin PopR: */
  	genoperand(PopR, ClassReg);
  	/* begin PopR: */
  	genoperand(PopR, TempReg);
  	/* begin PopR: */
  	reg = LinkReg;
  	genoperand(PopR, reg);
  	if (numArgs > 0) {
  		if (numArgs > 1) {
  			/* begin PopR: */
  			genoperand(PopR, Arg1Reg);
  			assert((numRegArgs()) == 2);
  		}
  		/* begin PopR: */
  		genoperand(PopR, Arg0Reg);
  	}
  	/* begin PopR: */
  	genoperand(PopR, ReceiverResultReg);
  	/* begin JumpR: */
  	genoperand(JumpR, TempReg);
  	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);
  }
  
  
  /*	Override to push the register receiver and register arguments, if any. */
  
  	/* StackToRegisterMappingCogit>>#genExternalizePointersForPrimitiveCall */
  static sqInt
  genExternalizePointersForPrimitiveCall(void)
  {
      sqInt address;
  
  	genPushRegisterArgs();
  	/* begin MoveR:Aw: */
  	address = instructionPointerAddress();
  	/* begin gen:operand:literal: */
  	checkLiteralforInstruction(address, genoperandoperand(MoveRAw, LinkReg, address));
  	return genSaveStackPointers(backEnd);
  }
  
  
  /*	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");
  	ceEnterCogCodePopReceiverReg = enterCogCodePopReceiver;
  	/* begin genEnilopmartFor:forCall:called: */
  	realCECallCogCodePopReceiverReg = genEnilopmartForandandforCallcalled(ReceiverResultReg, NoReg, NoReg, 1, "realCECallCogCodePopReceiverReg");
  	ceCallCogCodePopReceiverReg = callCogCodePopReceiver;
  	/* begin genEnilopmartFor:and:forCall:called: */
  	realCECallCogCodePopReceiverAndClassRegs = genEnilopmartForandandforCallcalled(ReceiverResultReg, ClassReg, NoReg, 1, "realCECallCogCodePopReceiverAndClassRegs");
  	ceCallCogCodePopReceiverAndClassRegs = callCogCodePopReceiverAndClassRegs;
  #  else /* Debug */
  	/* begin genEnilopmartFor:forCall:called: */
  	ceEnterCogCodePopReceiverReg = genEnilopmartForandandforCallcalled(ReceiverResultReg, NoReg, NoReg, 0, "ceEnterCogCodePopReceiverReg");
  	/* begin genEnilopmartFor:forCall:called: */
  	ceCallCogCodePopReceiverReg = genEnilopmartForandandforCallcalled(ReceiverResultReg, NoReg, NoReg, 1, "ceCallCogCodePopReceiverReg");
  	/* begin genEnilopmartFor:and:forCall:called: */
  	ceCallCogCodePopReceiverAndClassRegs = genEnilopmartForandandforCallcalled(ReceiverResultReg, ClassReg, NoReg, 1, "ceCallCogCodePopReceiverAndClassRegs");
  #  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");
  	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");
  	ceCallCogCodePopReceiverArg1Arg0Regs = genEnilopmartForandandforCallcalled(ReceiverResultReg, Arg0Reg, Arg1Reg, 1, "ceCallCogCodePopReceiverArg1Arg0Regs");
  #  endif /* Debug */
  	ceCall0ArgsPIC = genCallPICEnilopmartNumArgs(0);
  	ceCall1ArgsPIC = genCallPICEnilopmartNumArgs(1);
  	
  }
  
  
  /*	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;
      sqInt pcDependentIndex;
  
  	absoluteAddress = eventualAbsoluteAddress;
  	pcDependentIndex = 0;
  	for (i = 0; i < opcodeIndex; i += 1) {
  		abstractInstruction = abstractInstructionAt(i);
  		maybeBreakGeneratingFromto(absoluteAddress, (absoluteAddress + ((abstractInstruction->maxSize))) - 1);
  		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);
  			assert(((abstractInstruction->machineCodeSize)) == ((abstractInstruction->maxSize)));
  		}
  	}
  	for (j = 0; j < pcDependentIndex; j += 1) {
  		fixup = fixupAtIndex(j);
  		abstractInstruction = abstractInstructionAt((fixup->instructionIndex));
  		maybeBreakGeneratingFromto((abstractInstruction->address), (((abstractInstruction->address)) + ((abstractInstruction->maxSize))) - 1);
  		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 numArgs;
      sqInt numArgsLimiT;
  
  	for (numArgs = 0, numArgsLimiT = (2); numArgs <= numArgsLimiT; numArgs += 1) {
  		methodAbortTrampolines[numArgs] = (genMethodAbortTrampolineFor(numArgs));
  	}
  	for (numArgs = 0, numArgsLimiT = (2); numArgs <= numArgsLimiT; numArgs += 1) {
  		picAbortTrampolines[numArgs] = (genPICAbortTrampolineFor(numArgs));
  	}
  	for (numArgs = 0, numArgsLimiT = (2); numArgs <= numArgsLimiT; 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)
  	: SendNumArgsReg)));
  	}
  	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)
  	: SendNumArgsReg)));
  	}
  	firstSend = ordinarySendTrampolines[0];
  	lastSend = superSendTrampolines[NumSendTrampolines - 1];
  }
  
  
  /*	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)
  {
  	ceTraceLinkedSendTrampoline = genTrampolineForcalledargregsToSave(ceTraceLinkedSend, "ceTraceLinkedSendTrampoline", ReceiverResultReg, CallerSavedRegisterMask);
  	ceTraceBlockActivationTrampoline = genTrampolineForcalledregsToSave(ceTraceBlockActivation, "ceTraceBlockActivationTrampoline", CallerSavedRegisterMask);
  	ceTraceStoreTrampoline = genTrampolineForcalledargargregsToSave(ceTraceStoreOfinto, "ceTraceStoreTrampoline", TempReg, ReceiverResultReg, CallerSavedRegisterMask);
  }
  
  
  /*	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 *anInstruction1;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *anInstruction3;
      AbstractInstruction *anInstruction4;
      AbstractInstruction *anInstruction5;
      sqInt constant;
      sqInt constant1;
      sqInt constant11;
      sqInt constant2;
      sqInt constant3;
      sqInt constant4;
      AbstractInstruction *jumpEqual;
      AbstractInstruction *jumpNotEqual;
      AbstractInstruction *label;
      sqInt resultReg;
  
  	/* begin Label */
  	label = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	/* begin genCmpArgIsConstant:rcvrIsConstant:argReg:rcvrReg: */
  	assert((argReg != NoReg)
  	 || (rcvrRegOrNone != NoReg));
  	if (argIsConstant) {
  		/* begin genCmpConstant:R: */
  		constant4 = ((ssTop())->constant);
  		if (shouldAnnotateObjectReference(constant4)) {
  			annotateobjRef(checkLiteralforInstruction(constant4, genoperandoperand(CmpCwR, constant4, rcvrRegOrNone)), constant4);
  		}
  		else {
  			/* begin checkQuickConstant:forInstruction: */
  			anInstruction = genoperandoperand(CmpCqR, constant4, rcvrRegOrNone);
  			if (usesOutOfLineLiteral(anInstruction)) {
  				(anInstruction->dependent = locateLiteral(constant4));
  			}
  		}
  	}
  	else {
  		if (rcvrIsConstant) {
  			/* begin genCmpConstant:R: */
  			constant11 = ((ssValue(1))->constant);
  			if (shouldAnnotateObjectReference(constant11)) {
  				annotateobjRef(checkLiteralforInstruction(constant11, genoperandoperand(CmpCwR, constant11, argReg)), constant11);
  			}
  			else {
  				/* begin checkQuickConstant:forInstruction: */
  				anInstruction1 = genoperandoperand(CmpCqR, constant11, argReg);
  				if (usesOutOfLineLiteral(anInstruction1)) {
  					(anInstruction1->dependent = locateLiteral(constant11));
  				}
  			}
  		}
  		else {
  			/* begin CmpR:R: */
  			assert(!((argReg == SPReg)));
  			genoperandoperand(CmpRR, argReg, rcvrRegOrNone);
  		}
  	}
  	ssPop(2);
  	resultReg = (rcvrRegOrNone == NoReg
  		? argReg
  		: rcvrRegOrNone);
  	/* begin JumpZero: */
  	jumpEqual = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	if (!argIsConstant) {
  		/* begin genEnsureOopInRegNotForwarded:scratchReg:jumpBackTo: */
  	}
  	if (!rcvrIsConstant) {
  		/* begin genEnsureOopInRegNotForwarded:scratchReg:jumpBackTo: */
  	}
  	if (orNot) {
  		/* begin genMoveTrueR: */
  		constant = trueObject();
  		if (shouldAnnotateObjectReference(constant)) {
  			annotateobjRef(gMoveCwR(constant, resultReg), constant);
  		}
  		else {
  			/* begin checkQuickConstant:forInstruction: */
  			anInstruction2 = genoperandoperand(MoveCqR, constant, resultReg);
  			if (usesOutOfLineLiteral(anInstruction2)) {
  				(anInstruction2->dependent = locateLiteral(constant));
  			}
  		}
  	}
  	else {
  		/* begin genMoveFalseR: */
  		constant1 = falseObject();
  		if (shouldAnnotateObjectReference(constant1)) {
  			annotateobjRef(gMoveCwR(constant1, resultReg), constant1);
  		}
  		else {
  			/* begin checkQuickConstant:forInstruction: */
  			anInstruction3 = genoperandoperand(MoveCqR, constant1, resultReg);
  			if (usesOutOfLineLiteral(anInstruction3)) {
  				(anInstruction3->dependent = locateLiteral(constant1));
  			}
  		}
  	}
  	/* begin Jump: */
  	jumpNotEqual = genoperand(Jump, ((sqInt)0));
  	jmpTarget(jumpEqual, (orNot
  		? (/* begin genMoveFalseR: */
  			(constant2 = falseObject()),
  			(shouldAnnotateObjectReference(constant2)
  					? annotateobjRef(gMoveCwR(constant2, resultReg), constant2)
  					: (/* begin checkQuickConstant:forInstruction: */
  						(anInstruction4 = genoperandoperand(MoveCqR, constant2, resultReg)),
  						(usesOutOfLineLiteral(anInstruction4)
  								? (anInstruction4->dependent = locateLiteral(constant2))
  								: 0),
  						anInstruction4)))
  		: (/* begin genMoveTrueR: */
  			(constant3 = trueObject()),
  			(shouldAnnotateObjectReference(constant3)
  					? annotateobjRef(gMoveCwR(constant3, resultReg), constant3)
  					: (/* begin checkQuickConstant:forInstruction: */
  						(anInstruction5 = genoperandoperand(MoveCqR, constant3, resultReg)),
  						(usesOutOfLineLiteral(anInstruction5)
  								? (anInstruction5->dependent = locateLiteral(constant3))
  								: 0),
  						anInstruction5)))));
  	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 through 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 genVanillaInlinedIdenticalOrNotIf(orNot);
  }
  
  	/* StackToRegisterMappingCogit>>#genJumpBackTo: */
  static sqInt NoDbgRegParms
  genJumpBackTo(sqInt targetBytecodePC)
  {
      AbstractInstruction *abstractInstruction;
      AbstractInstruction *abstractInstruction1;
      sqInt address;
      sqInt i;
      void *jumpTarget;
      void *jumpTarget1;
  
  	/* begin ssFlushTo: */
  	assert(tempsValidAndVolatileEntriesSpilled());
  	if (simSpillBase <= simStackPtr) {
  		for (i = (((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) < simStackPtr) ? ((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) : simStackPtr)); i <= simStackPtr; i += 1) {
  			assert(needsFrame);
  			ensureSpilledAtfrom(simStackAt(i), frameOffsetOfTemporary(i - 1), FPReg);
  		}
  		simSpillBase = simStackPtr + 1;
  	}
  
  	/* can't fall through */
  	deadCode = 1;
  	/* begin MoveAw:R: */
  	address = stackLimitAddress();
  	/* begin gen:literal:operand: */
  	checkLiteralforInstruction(address, genoperandoperand(MoveAwR, address, TempReg));
  	/* begin CmpR:R: */
  	assert(!((TempReg == SPReg)));
  	genoperandoperand(CmpRR, TempReg, SPReg);
  	/* begin JumpAboveOrEqual: */
  	jumpTarget = fixupAtIndex(targetBytecodePC - initialPC);
  	genConditionalBranchoperand(JumpAboveOrEqual, ((sqInt)jumpTarget));
  	/* begin CallRT: */
  	abstractInstruction = genoperand(Call, ceCheckForInterruptTrampoline);
  	(abstractInstruction->annotation = IsRelativeCall);
  	/* begin annotateBytecode: */
  	abstractInstruction1 = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	(abstractInstruction1->annotation = HasBytecodePC);
  	/* begin Jump: */
  	jumpTarget1 = fixupAtIndex(targetBytecodePC - initialPC);
  	genoperand(Jump, ((sqInt)jumpTarget1));
  	return 0;
  }
  
  	/* StackToRegisterMappingCogit>>#genJumpIf:to: */
  static sqInt NoDbgRegParms
  genJumpIfto(sqInt boolean, sqInt targetBytecodePC)
  {
      AbstractInstruction *abstractInstruction;
      AbstractInstruction *abstractInstruction1;
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      CogSimStackEntry *desc;
      sqInt eventualTarget;
      BytecodeFixup *fixup;
      sqInt i;
      void *jumpTarget;
      AbstractInstruction *ok;
      sqInt quickConstant;
  
  	eventualTarget = eventualTargetOf(targetBytecodePC);
  	/* begin ssFlushTo: */
  	assert(tempsValidAndVolatileEntriesSpilled());
  	if (simSpillBase <= (simStackPtr - 1)) {
  		for (i = (((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) < (simStackPtr - 1)) ? ((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) : (simStackPtr - 1))); i < simStackPtr; i += 1) {
  			assert(needsFrame);
  			ensureSpilledAtfrom(simStackAt(i), frameOffsetOfTemporary(i - 1), FPReg);
  		}
  		simSpillBase = (simStackPtr - 1) + 1;
  	}
  	desc = ssTop();
  	ssPop(1);
  	if ((((desc->type)) == SSConstant)
  	 && ((((desc->constant)) == (trueObject()))
  	 || (((desc->constant)) == (falseObject())))) {
  
  		/* Must arrange there's a fixup at the target whether it is jumped to or
  		   not so that the simStackPtr can be kept correct. */
  
  		/* Must annotate the bytecode for correct pc mapping. */
  		fixup = ensureFixupAt(eventualTarget);
  		/* begin annotateBytecode: */
  		if (((desc->constant)) == boolean) {
  			/* begin Jump: */
  			abstractInstruction = genoperand(Jump, ((sqInt)fixup));
  		}
  		else {
  			if (prevInstIsPCAnnotated()) {
  				/* begin Nop */
  				abstractInstruction = gen(Nop);
  			}
  			else {
  				/* begin Label */
  				abstractInstruction = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  			}
  		}
  		(abstractInstruction->annotation = HasBytecodePC);
  		extA = 0;
  		return 0;
  	}
  	popToReg(desc, 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));
  		}
  	}
  	/* begin JumpZero: */
  	jumpTarget = ensureFixupAt(eventualTarget);
  	genConditionalBranchoperand(JumpZero, ((sqInt)jumpTarget));
  	if (extA & 1) {
  		extA = 0;
  		/* begin annotateBytecode: */
  		abstractInstruction1 = lastOpcode();
  		(abstractInstruction1->annotation = HasBytecodePC);
  		return 0;
  	}
  	extA = 0;
  	/* begin CmpCq:R: */
  	quickConstant = (boolean == (falseObject())
  		? (trueObject()) - (falseObject())
  		: (falseObject()) - (trueObject()));
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperand(CmpCqR, quickConstant, TempReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(quickConstant));
  	}
  	/* begin JumpZero: */
  	ok = genConditionalBranchoperand(JumpZero, ((sqInt)0));
  	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;
      sqInt i;
      sqInt i1;
  
  	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))
  	: 0));
  		ssPop(1);
  		/* begin ssFlushTo: */
  		assert(tempsValidAndVolatileEntriesSpilled());
  		if (simSpillBase <= simStackPtr) {
  			for (i = (((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) < simStackPtr) ? ((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) : simStackPtr)); i <= simStackPtr; i += 1) {
  				assert(needsFrame);
  				ensureSpilledAtfrom(simStackAt(i), frameOffsetOfTemporary(i - 1), FPReg);
  			}
  			simSpillBase = simStackPtr + 1;
  		}
  		fixup = ensureFixupAt(eventualTarget);
  		ssPop(-1);
  	}
  	else {
  		/* begin ssFlushTo: */
  		assert(tempsValidAndVolatileEntriesSpilled());
  		if (simSpillBase <= simStackPtr) {
  			for (i1 = (((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) < simStackPtr) ? ((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) : simStackPtr)); i1 <= simStackPtr; i1 += 1) {
  				assert(needsFrame);
  				ensureSpilledAtfrom(simStackAt(i1), frameOffsetOfTemporary(i1 - 1), FPReg);
  			}
  			simSpillBase = simStackPtr + 1;
  		}
  		fixup = ensureFixupAt(eventualTarget);
  	}
  
  	/* can't fall through */
  	deadCode = 1;
  	/* begin Jump: */
  	genoperand(Jump, ((sqInt)fixup));
  	return 0;
  }
  
  	/* StackToRegisterMappingCogit>>#genMarshalledSend:numArgs:sendTable: */
  static sqInt NoDbgRegParms
  genMarshalledSendnumArgssendTable(sqInt selectorIndex, sqInt numArgs, sqInt *sendTable)
  {
      AbstractInstruction *anInstruction;
      sqInt annotation;
  
  	assert(needsFrame);
  	/* begin annotationForSendTable: */
  	if (sendTable == ordinarySendTrampolines) {
  		annotation = IsSendCall;
  		goto l3;
  	}
  	assert(sendTable == superSendTrampolines);
  	annotation = IsSuperSend;
  	l3:	/* end annotationForSendTable: */;
  	if ((annotation == IsSuperSend)
  	 || (0)) {
  		/* begin genEnsureOopInRegNotForwarded:scratchReg: */
  	}
  	if (numArgs >= (NumSendTrampolines - 1)) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction = genoperandoperand(MoveCqR, numArgs, SendNumArgsReg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(numArgs));
  		}
  	}
  	genLoadInlineCacheWithSelector(selectorIndex);
  	((genoperand(Call, sendTable[((numArgs < (NumSendTrampolines - 1)) ? numArgs : (NumSendTrampolines - 1))]))->annotation = annotation);
  	/* begin voidReceiverOptStatus */
  	((simSelf())->liveRegister = NoReg);
  	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 usqInt NoDbgRegParms
  genMethodAbortTrampolineFor(sqInt numArgs)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *jumpSICMiss;
  
  	zeroOpcodeIndex();
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperand(CmpCqR, 0, ReceiverResultReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(0));
  	}
  	/* begin JumpNonZero: */
  	jumpSICMiss = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	/* begin MoveR:Mw:r: */
  	anInstruction = genoperandoperandoperand(MoveRMwr, LinkReg, 0, SPReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(0));
  	}
  	compileTrampolineFornumArgsargargargargregsToSavepushLinkRegresultReg(ceStackOverflow, 1, SendNumArgsReg, null, null, null, 0 /* emptyRegisterMask */, 0, NoReg);
  	jmpTarget(jumpSICMiss, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	genPushRegisterArgsForAbortMissNumArgs(backEnd, numArgs);
  	return genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(ceSICMiss, trampolineNamenumRegArgs("ceMethodAbort", numArgs), 1, ReceiverResultReg, null, null, null, 0 /* emptyRegisterMask */, 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 usqInt NoDbgRegParms
  genPICAbortTrampolineFor(sqInt numArgs)
  {
  	zeroOpcodeIndex();
  	genPushRegisterArgsForAbortMissNumArgs(backEnd, numArgs);
  	return genInnerPICAbortTrampoline(trampolineNamenumRegArgs("cePICAbort", numArgs));
  }
  
  	/* StackToRegisterMappingCogit>>#genPICMissTrampolineFor: */
  static usqInt NoDbgRegParms
  genPICMissTrampolineFor(sqInt numArgs)
  {
      usqInt startAddress;
  
  	startAddress = methodZoneBase;
  	zeroOpcodeIndex();
  	genPushRegisterArgsForNumArgsscratchReg(backEnd, numArgs, SendNumArgsReg);
  	genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(ceCPICMissreceiver, trampolineNamenumRegArgs("cePICMiss", numArgs), 2, ClassReg, ReceiverResultReg, null, null, 0 /* emptyRegisterMask */, 1, NoReg, 1);
  	return startAddress;
  }
  
  	/* StackToRegisterMappingCogit>>#genPopStackBytecode */
  static sqInt
  genPopStackBytecode(void)
  {
      AbstractInstruction *anInstruction;
  
  	if (((ssTop())->spilled)) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction = genoperandoperand(AddCqR, BytesPerWord, SPReg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(BytesPerWord));
  		}
  	}
  	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. */
  /*	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>>#genPrimitiveClosureValue */
  static sqInt
  genPrimitiveClosureValue(void)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction11;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *anInstruction3;
      AbstractInstruction *anInstruction4;
      AbstractInstruction *jumpBCMethod;
      AbstractInstruction *jumpFail1;
      AbstractInstruction *jumpFail2;
      AbstractInstruction *jumpFail3;
      AbstractInstruction *jumpFail4;
      AbstractInstruction *jumpFailNArgs;
      sqInt literal;
      sqInt offset1;
      void (*primitiveRoutine)(void);
      sqInt quickConstant;
      sqInt quickConstant1;
      sqInt quickConstant2;
      sqInt result;
  
  	genPushRegisterArgs();
  	genLoadSlotsourceRegdestReg(ClosureNumArgsIndex, ReceiverResultReg, TempReg);
  	/* begin checkQuickConstant:forInstruction: */
  	literal = (((usqInt)methodOrBlockNumArgs << 1) | 1);
  	anInstruction1 = genoperandoperand(CmpCqR, (((usqInt)methodOrBlockNumArgs << 1) | 1), TempReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(literal));
  	}
  	/* begin JumpNonZero: */
  	jumpFailNArgs = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	genLoadSlotsourceRegdestReg(ClosureOuterContextIndex, ReceiverResultReg, ClassReg);
  	jumpFail1 = genJumpImmediate(ClassReg);
  	genGetCompactClassIndexNonImmOfinto(ClassReg, TempReg);
  	genCmpClassMethodContextCompactIndexR(TempReg);
  	/* begin JumpNonZero: */
  	jumpFail2 = genConditionalBranchoperand(JumpNonZero, ((sqInt)0));
  	genLoadSlotsourceRegdestReg(MethodIndex, ClassReg, SendNumArgsReg);
  	jumpFail3 = genJumpImmediate(SendNumArgsReg);
  	/* begin genGetFormatOf:into: */
  	anInstruction2 = genoperandoperandoperand(MoveMwrR, 0, SendNumArgsReg, TempReg);
  	if (usesOutOfLineLiteral(anInstruction2)) {
  		(anInstruction2->dependent = locateLiteral(0));
  	}
  	/* begin LogicalShiftRightCq:R: */
  	quickConstant = instFormatFieldLSB();
  	genoperandoperand(LogicalShiftRightCqR, quickConstant, TempReg);
  	/* begin AndCq:R: */
  	quickConstant1 = (1U << (instFormatFieldWidth())) - 1;
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction11 = genoperandoperand(AndCqR, quickConstant1, TempReg);
  	if (usesOutOfLineLiteral(anInstruction11)) {
  		(anInstruction11->dependent = locateLiteral(quickConstant1));
  	}
  	/* begin CmpCq:R: */
  	quickConstant2 = firstCompiledMethodFormat();
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction3 = genoperandoperand(CmpCqR, quickConstant2, TempReg);
  	if (usesOutOfLineLiteral(anInstruction3)) {
  		(anInstruction3->dependent = locateLiteral(quickConstant2));
  	}
  	/* begin JumpLess: */
  	jumpFail4 = genConditionalBranchoperand(JumpLess, ((sqInt)0));
  	genLoadSlotsourceRegdestReg(HeaderIndex, SendNumArgsReg, ClassReg);
  	jumpBCMethod = genJumpImmediate(ClassReg);
  	/* begin MoveM16:r:R: */
  	offset1 = offsetof(CogMethod, blockEntryOffset);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction4 = genoperandoperandoperand(MoveM16rR, offset1, ClassReg, TempReg);
  	if (usesOutOfLineLiteral(anInstruction4)) {
  		(anInstruction4->dependent = locateLiteral(offset1));
  	}
  	/* begin AddR:R: */
  	genoperandoperand(AddRR, ClassReg, TempReg);
  	primitiveRoutine = functionPointerForCompiledMethodprimitiveIndex(methodObj, primitiveIndex);
  	if (primitiveRoutine == primitiveClosureValueNoContextSwitch) {
  		if (blockNoContextSwitchOffset == null) {
  			return NotFullyInitialized;
  		}
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction = genoperandoperand(SubCqR, blockNoContextSwitchOffset, TempReg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(blockNoContextSwitchOffset));
  		}
  	}
  	/* begin JumpR: */
  	genoperand(JumpR, TempReg);
  	jmpTarget(jumpBCMethod, jmpTarget(jumpFail1, jmpTarget(jumpFail2, jmpTarget(jumpFail3, jmpTarget(jumpFail4, genoperandoperand(Label, (labelCounter += 1), bytecodePC))))));
  	if (((result = compileInterpreterPrimitiveflags(primitiveRoutine, primitivePropertyFlags(primitiveIndex)))) < 0) {
  		return result;
  	}
  	jmpTarget(jumpFailNArgs, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	return CompletePrimitive;
  }
  
  
  /*	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 > 1 /* numRegArgs */) {
  		/* begin MoveMw:r:R: */
  		offset = (methodOrBlockNumArgs - 1) * BytesPerWord;
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction = genoperandoperandoperand(MoveMwrR, offset, SPReg, Arg0Reg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(offset));
  		}
  	}
  	return genLookupForPerformNumArgs(methodOrBlockNumArgs);
  }
  
  	/* StackToRegisterMappingCogit>>#genPushActiveContextBytecode */
  static sqInt
  genPushActiveContextBytecode(void)
  {
  	assert(needsFrame);
  	voidReceiverResultRegContainsSelf();
  	/* begin ssAllocateCallReg: */
  	ssAllocateRequiredRegMaskupThroughupThroughNative(CallerSavedRegisterMask | (1U << ReceiverResultReg), simStackPtr, simNativeStackPtr);
  	genGetActiveContextNumArgslargeinBlock(methodOrBlockNumArgs, methodNeedsLargeContext(methodObj), inBlock);
  	return ssPushRegister(ReceiverResultReg);
  }
  
  
  /*	Block compilation. At this point in the method create the block. Note its
  	start and defer generating code for it until after the method and any
  	other preceding
  	blocks. The block's actual code will be compiled later. */
  /*	143 10001111 llllkkkk jjjjjjjj iiiiiiii	Push Closure Num Copied llll Num
  	Args kkkk BlockSize jjjjjjjjiiiiiiii */
  
  	/* StackToRegisterMappingCogit>>#genPushClosureCopyCopiedValuesBytecode */
  static sqInt
  genPushClosureCopyCopiedValuesBytecode(void)
  {
      sqInt i1;
      sqInt numArgs;
      sqInt numCopied;
      sqInt startpc;
  
  	assert(needsFrame);
  	startpc = bytecodePC + (((generatorAt(byte0))->numBytes));
  	addBlockStartAtnumArgsnumCopiedspan(startpc, (numArgs = byte1 & 15), (numCopied = ((usqInt)(byte1)) >> 4), (((sqInt)((usqInt)(byte2) << 8))) + byte3);
  	/* begin genOutlineClosure:numArgs:numCopied: */
  	if (numCopied > 0) {
  		/* begin ssFlushTo: */
  		assert(tempsValidAndVolatileEntriesSpilled());
  		if (simSpillBase <= simStackPtr) {
  			for (i1 = (((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) < simStackPtr) ? ((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) : simStackPtr)); i1 <= simStackPtr; i1 += 1) {
  				assert(needsFrame);
  				ensureSpilledAtfrom(simStackAt(i1), frameOffsetOfTemporary(i1 - 1), FPReg);
  			}
  			simSpillBase = simStackPtr + 1;
  		}
  	}
  	voidReceiverResultRegContainsSelf();
  	/* begin ssAllocateCallReg:and: */
  	ssAllocateRequiredRegMaskupThroughupThroughNative(CallerSavedRegisterMask | ((1U << SendNumArgsReg) | (1U << ReceiverResultReg)), simStackPtr, simNativeStackPtr);
  	genCreateClosureAtnumArgsnumCopiedcontextNumArgslargeinBlock(startpc + 1, numArgs, numCopied, methodOrBlockNumArgs, methodNeedsLargeContext(methodObj), inBlock);
  	if (numCopied > 0) {
  		ssPop(numCopied);
  	}
  	ssPushRegister(ReceiverResultReg);
  	return 0;
  }
  
  
  /*	<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 freeReg;
  
  
  	/* If followed by a directed super send bytecode, avoid generating any code yet.
  	   The association will be passed to the directed send trampoline in a register
  	   and fully dereferenced only when first linked.  It will be ignored in later sends. */
  	association = getLiteral(literalIndex);
  	
  	/* N.B. Do _not_ use ReceiverResultReg to avoid overwriting receiver in assignment in frameless methods. */
  	/* So far descriptors are not rich enough to describe the entire dereference so generate the register
  	   load but don't push the result.  There is an order-of-evaluation issue if we defer the dereference. */
  	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));
  		}
  	}
  	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 *abstractInstruction1;
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *jmpDone;
      AbstractInstruction *jmpSingle;
  
  	/* begin ssAllocateCallReg:and: */
  	ssAllocateRequiredRegMaskupThroughupThroughNative(CallerSavedRegisterMask | ((1U << ReceiverResultReg) | (1U << SendNumArgsReg)), simStackPtr, simNativeStackPtr);
  	ensureReceiverResultRegContainsSelf();
  	/* begin genPushMaybeContextSlotIndex: */
  	assert(needsFrame);
  	if (CallerSavedRegisterMask & (1U << ReceiverResultReg)) {
  
  		/* We have no way of reloading ReceiverResultReg since we need the inst var value as the result. */
  		voidReceiverResultRegContainsSelf();
  	}
  	if (slotIndex == InstructionPointerIndex) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction = genoperandoperand(MoveCqR, slotIndex, SendNumArgsReg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(slotIndex));
  		}
  		/* begin CallRT: */
  		abstractInstruction = genoperand(Call, ceFetchContextInstVarTrampoline);
  		(abstractInstruction->annotation = IsRelativeCall);
  		return ssPushRegister(SendNumArgsReg);
  	}
  	genLoadSlotsourceRegdestReg(SenderIndex, ReceiverResultReg, TempReg);
  	jmpSingle = genJumpNotSmallIntegerInScratchReg(TempReg);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction1 = genoperandoperand(MoveCqR, slotIndex, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction1)) {
  		(anInstruction1->dependent = locateLiteral(slotIndex));
  	}
  	/* begin CallRT: */
  	abstractInstruction1 = genoperand(Call, ceFetchContextInstVarTrampoline);
  	(abstractInstruction1->annotation = IsRelativeCall);
  	/* begin Jump: */
  	jmpDone = genoperand(Jump, ((sqInt)0));
  	jmpTarget(jmpSingle, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	genLoadSlotsourceRegdestReg(slotIndex, ReceiverResultReg, SendNumArgsReg);
  	jmpTarget(jmpDone, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	return ssPushRegister(SendNumArgsReg);
  }
  
  	/* StackToRegisterMappingCogit>>#genPushNewArrayBytecode */
  static sqInt
  genPushNewArrayBytecode(void)
  {
      sqInt i;
      sqInt i1;
      int popValues;
      sqInt size;
  
  	assert(needsFrame);
  	voidReceiverResultRegContainsSelf();
  	if ((popValues = byte1 > 0x7F)) {
  		/* begin ssFlushTo: */
  		assert(tempsValidAndVolatileEntriesSpilled());
  		if (simSpillBase <= simStackPtr) {
  			for (i1 = (((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) < simStackPtr) ? ((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) : simStackPtr)); i1 <= simStackPtr; i1 += 1) {
  				assert(needsFrame);
  				ensureSpilledAtfrom(simStackAt(i1), frameOffsetOfTemporary(i1 - 1), FPReg);
  			}
  			simSpillBase = simStackPtr + 1;
  		}
  	}
  	else {
  		/* begin ssAllocateCallReg:and: */
  		ssAllocateRequiredRegMaskupThroughupThroughNative(CallerSavedRegisterMask | ((1U << SendNumArgsReg) | (1U << ReceiverResultReg)), simStackPtr, simNativeStackPtr);
  	}
  	size = byte1 & 0x7F;
  	if (!popValues) {
  		if (tryCollapseTempVectorInitializationOfSize(size)) {
  			return 0;
  		}
  	}
  	genNewArrayOfSizeinitialized(size, !popValues);
  	if (popValues) {
  		for (i = (size - 1); i >= 0; i += -1) {
  			/* begin PopR: */
  			genoperand(PopR, TempReg);
  			genStoreSourceRegslotIndexintoNewObjectInDestReg(TempReg, i, ReceiverResultReg);
  		}
  		ssPop(size);
  	}
  	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 > 1 /* numRegArgs */))) {
  		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));
  	}
  	/* begin availableRegOrNoneNotConflictingWith: */
  	regMask = 1U << tempVectReg;
  	remoteTempReg = availableRegisterOrNoneFor(backEnd, (liveRegisters()) | regMask);
  	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 */
  			storeToReg(simSelf(), ReceiverResultReg);
  		}
  	}
  	return genUpArrowReturn();
  }
  
  	/* StackToRegisterMappingCogit>>#genReturnTopFromBlock */
  static sqInt
  genReturnTopFromBlock(void)
  {
  	assert(inBlock > 0);
  	popToReg(ssTop(), ReceiverResultReg);
  	ssPop(1);
  	return genBlockReturn();
  }
  
  	/* StackToRegisterMappingCogit>>#genReturnTopFromMethod */
  static sqInt
  genReturnTopFromMethod(void)
  {
  	popToReg(ssTop(), ReceiverResultReg);
  	ssPop(1);
  	return genUpArrowReturn();
  }
  
  	/* 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 usqInt NoDbgRegParms
  genSendTrampolineFornumArgscalledargargargarg(void *aRoutine, sqInt numArgs, char *aString, sqInt regOrConst0, sqInt regOrConst1, sqInt regOrConst2, sqInt regOrConst3)
  {
      sqInt routine;
      usqInt startAddress;
  
  	startAddress = methodZoneBase;
  	zeroOpcodeIndex();
  	genPushRegisterArgsForNumArgsscratchReg(backEnd, numArgs, SendNumArgsReg);
  	/* begin selectorIndexDereferenceRoutine */
  	routine = null;
  	if (!(routine == null)) {
  
  		/* Explicitly save LinkReg via ExtraReg2; it's presumably faster than pushing/popping */
  		/* begin MoveR:R: */
  		genoperandoperand(MoveRR, LinkReg, Extra2Reg);
  		/* begin Call: */
  		genoperand(Call, routine);
  		/* begin MoveR:R: */
  		genoperandoperand(MoveRR, Extra2Reg, LinkReg);
  	}
  	genTrampolineForcallednumArgsargargargargregsToSavepushLinkRegresultRegappendOpcodes(aRoutine, aString, 4, regOrConst0, regOrConst1, regOrConst2, regOrConst3, 0 /* emptyRegisterMask */, 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 *anInstruction1;
      AbstractInstruction *anInstruction2;
      AbstractInstruction *anInstruction3;
      AbstractInstruction *anInstruction4;
      AbstractInstruction *anInstruction5;
      AbstractInstruction *anInstruction6;
      AbstractInstruction *anInstruction7;
      sqInt argInt;
      int argIsConst;
      sqInt argIsInt;
      sqInt i;
      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))) & 1));
  	rcvrIsInt = (((rcvrIsConst = (((ssValue(1))->type)) == SSConstant))
  	 && ((((rcvrInt = ((ssValue(1))->constant))) & 1)))
  	 || ((mclassIsSmallInteger())
  	 && (isSameEntryAs(ssValue(1), simSelf())));
  	if (argIsInt
  	 && (rcvrIsInt
  	 && (rcvrIsConst))) {
  		rcvrInt = (rcvrInt >> 1);
  		argInt = (argInt >> 1);
  		
  		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)) {
  
  			/* Must annotate the bytecode for correct pc mapping. */
  			return (ssPop(2),
  				ssPushAnnotatedConstant((((usqInt)result << 1) | 1)));
  		}
  		return genSpecialSelectorSend();
  	}
  	if ((rcvrIsConst
  	 && (!rcvrIsInt))
  	 || (argIsConst
  	 && (!argIsInt))) {
  		return genSpecialSelectorSend();
  	}
  	if (!(argIsInt
  		 || (rcvrIsInt))) {
  		return genSpecialSelectorSend();
  	}
  	if (argIsInt) {
  		/* begin ssFlushTo: */
  		assert(tempsValidAndVolatileEntriesSpilled());
  		if (simSpillBase <= (simStackPtr - 2)) {
  			for (i = (((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) < (simStackPtr - 2)) ? ((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) : (simStackPtr - 2))); i <= (simStackPtr - 2); i += 1) {
  				assert(needsFrame);
  				ensureSpilledAtfrom(simStackAt(i), frameOffsetOfTemporary(i - 1), FPReg);
  			}
  			simSpillBase = (simStackPtr - 2) + 1;
  		}
  		popToReg(ssValue(1), ReceiverResultReg);
  		ssPop(2);
  	}
  	else {
  		marshallSendArguments(1);
  	}
  	jumpNotSmallInts = (!(rcvrIsInt
   && (argIsInt))
  		? (argIsInt
  				? genJumpNotSmallInteger(ReceiverResultReg)
  				: (rcvrIsInt
  						? genJumpNotSmallInteger(Arg0Reg)
  						: (/* begin genJumpNotSmallIntegersIn:and:scratch: */
  							genoperandoperand(MoveRR, ReceiverResultReg, TempReg),
  							/* begin AndR:R: */
  							genoperandoperand(AndRR, Arg0Reg, TempReg),
  							genJumpNotSmallIntegerInScratchReg(TempReg))))
  		: 0);
  	
  	switch ((primDescriptor->opcode)) {
  	case AddRR:
  		if (argIsInt) {
  			/* begin checkQuickConstant:forInstruction: */
  			anInstruction = genoperandoperand(AddCqR, argInt - ConstZero, ReceiverResultReg);
  			if (usesOutOfLineLiteral(anInstruction)) {
  				(anInstruction->dependent = locateLiteral(argInt - ConstZero));
  			}
  			/* begin JumpNoOverflow: */
  			jumpContinue = genConditionalBranchoperand(JumpNoOverflow, ((sqInt)0));
  			/* begin checkQuickConstant:forInstruction: */
  			anInstruction1 = genoperandoperand(SubCqR, argInt - ConstZero, ReceiverResultReg);
  			if (usesOutOfLineLiteral(anInstruction1)) {
  				(anInstruction1->dependent = locateLiteral(argInt - ConstZero));
  			}
  		}
  		else {
  			genRemoveSmallIntegerTagsInScratchReg(ReceiverResultReg);
  			/* begin AddR:R: */
  			genoperandoperand(AddRR, Arg0Reg, ReceiverResultReg);
  			/* begin JumpNoOverflow: */
  			jumpContinue = genConditionalBranchoperand(JumpNoOverflow, ((sqInt)0));
  			if (rcvrIsInt
  			 && (rcvrIsConst)) {
  				/* begin checkQuickConstant:forInstruction: */
  				anInstruction2 = genoperandoperand(MoveCqR, rcvrInt, ReceiverResultReg);
  				if (usesOutOfLineLiteral(anInstruction2)) {
  					(anInstruction2->dependent = locateLiteral(rcvrInt));
  				}
  			}
  			else {
  				/* begin SubR:R: */
  				genoperandoperand(SubRR, Arg0Reg, ReceiverResultReg);
  				genSetSmallIntegerTagsIn(ReceiverResultReg);
  			}
  		}
  		break;
  	case SubRR:
  		if (argIsInt) {
  			/* begin checkQuickConstant:forInstruction: */
  			anInstruction3 = genoperandoperand(SubCqR, argInt - ConstZero, ReceiverResultReg);
  			if (usesOutOfLineLiteral(anInstruction3)) {
  				(anInstruction3->dependent = locateLiteral(argInt - ConstZero));
  			}
  			/* begin JumpNoOverflow: */
  			jumpContinue = genConditionalBranchoperand(JumpNoOverflow, ((sqInt)0));
  			/* begin checkQuickConstant:forInstruction: */
  			anInstruction4 = genoperandoperand(AddCqR, argInt - ConstZero, ReceiverResultReg);
  			if (usesOutOfLineLiteral(anInstruction4)) {
  				(anInstruction4->dependent = locateLiteral(argInt - ConstZero));
  			}
  		}
  		else {
  			genRemoveSmallIntegerTagsInScratchReg(Arg0Reg);
  			/* begin SubR:R: */
  			genoperandoperand(SubRR, Arg0Reg, ReceiverResultReg);
  			/* begin JumpNoOverflow: */
  			jumpContinue = genConditionalBranchoperand(JumpNoOverflow, ((sqInt)0));
  			/* begin AddR:R: */
  			genoperandoperand(AddRR, Arg0Reg, ReceiverResultReg);
  			genSetSmallIntegerTagsIn(Arg0Reg);
  		}
  		break;
  	case AndRR:
  		if (argIsInt) {
  			/* begin checkQuickConstant:forInstruction: */
  			anInstruction5 = genoperandoperand(AndCqR, argInt, ReceiverResultReg);
  			if (usesOutOfLineLiteral(anInstruction5)) {
  				(anInstruction5->dependent = locateLiteral(argInt));
  			}
  		}
  		else {
  			/* begin AndR:R: */
  			genoperandoperand(AndRR, Arg0Reg, ReceiverResultReg);
  		}
  		jumpContinue = (!(jumpNotSmallInts == null)
  			? (/* begin Jump: */
  				genoperand(Jump, ((sqInt)0)))
  			: 0);
  		break;
  	case OrRR:
  		if (argIsInt) {
  			/* begin checkQuickConstant:forInstruction: */
  			anInstruction6 = genoperandoperand(OrCqR, argInt, ReceiverResultReg);
  			if (usesOutOfLineLiteral(anInstruction6)) {
  				(anInstruction6->dependent = locateLiteral(argInt));
  			}
  		}
  		else {
  			/* begin OrR:R: */
  			genoperandoperand(OrRR, Arg0Reg, ReceiverResultReg);
  		}
  		jumpContinue = (!(jumpNotSmallInts == null)
  			? (/* begin Jump: */
  				genoperand(Jump, ((sqInt)0)))
  			: 0);
  		break;
  	default:
  		error("Case not found and no otherwise clause");
  	}
  	if (jumpNotSmallInts == null) {
  		if (!(jumpContinue)) {
  
  			/* overflow cannot happen */
  			/* begin annotateInstructionForBytecode */
  			if (prevInstIsPCAnnotated()) {
  				/* begin Nop */
  				abstractInstruction = gen(Nop);
  			}
  			else {
  				/* begin Label */
  				abstractInstruction = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  			}
  			(abstractInstruction->annotation = HasBytecodePC);
  			ssPushRegister(ReceiverResultReg);
  			return 0;
  		}
  	}
  	else {
  		jmpTarget(jumpNotSmallInts, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	}
  	if (argIsInt) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction7 = genoperandoperand(MoveCqR, argInt, Arg0Reg);
  		if (usesOutOfLineLiteral(anInstruction7)) {
  			(anInstruction7->dependent = locateLiteral(argInt));
  		}
  	}
  	index = byte0 - (
  #if MULTIPLEBYTECODESETS
  	(bytecodeSetOffset == 256
  		? AltFirstSpecialSelector + 256
  		: FirstSpecialSelector)
  #else /* MULTIPLEBYTECODESETS */
  	FirstSpecialSelector
  #endif /* MULTIPLEBYTECODESETS */
  	);
  	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());
  	ssPop(1);
  	if ((topReg == NoReg)
  	 || (topReg == ClassReg)) {
  		/* begin ssAllocateRequiredReg:and: */
  		requiredReg1 = (topReg = SendNumArgsReg);
  		ssAllocateRequiredRegMaskupThroughupThroughNative((1U << requiredReg1) | (1U << ClassReg), simStackPtr, simNativeStackPtr);
  	}
  	else {
  		/* begin ssAllocateRequiredReg: */
  		ssAllocateRequiredRegMaskupThroughupThroughNative(1U << ClassReg, simStackPtr, simNativeStackPtr);
  	}
  	ssPush(1);
  	popToReg(ssTop(), topReg);
  	genGetClassObjectOfintoscratchRegmayBeAForwarder(topReg, ClassReg, TempReg, mayBeAForwarder(ssTop()));
  	return (ssPop(1),
  		ssPushRegister(ClassReg));
  }
  
  	/* StackToRegisterMappingCogit>>#genSpecialSelectorComparison */
  static sqInt
  genSpecialSelectorComparison(void)
  {
      AbstractInstruction *abstractInstruction;
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      sqInt argInt;
      sqInt argIsIntConst;
      BytecodeDescriptor *branchDescriptor;
      BytecodeDescriptor *branchDescriptor1;
      sqInt i;
      sqInt index;
      sqInt inlineCAB;
      AbstractInstruction *jumpNotSmallInts;
      void *jumpTarget;
      sqInt nExts;
      sqInt nextPC;
      sqInt nextPC1;
      sqInt postBranchPC;
      sqInt postBranchPC1;
      BytecodeDescriptor *primDescriptor;
      BytecodeDescriptor *primDescriptor1;
      int rcvrIsConst;
      sqInt rcvrIsInt;
      sqInt targetBytecodePC;
      sqInt targetPC;
  
  	/* begin ssFlushTo: */
  	assert(tempsValidAndVolatileEntriesSpilled());
  	if (simSpillBase <= (simStackPtr - 2)) {
  		for (i = (((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) < (simStackPtr - 2)) ? ((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) : (simStackPtr - 2))); i <= (simStackPtr - 2); i += 1) {
  			assert(needsFrame);
  			ensureSpilledAtfrom(simStackAt(i), frameOffsetOfTemporary(i - 1), FPReg);
  		}
  		simSpillBase = (simStackPtr - 2) + 1;
  	}
  	primDescriptor = generatorAt(byte0);
  	argIsIntConst = ((((ssTop())->type)) == SSConstant)
  	 && ((((argInt = ((ssTop())->constant))) & 1));
  	rcvrIsInt = (((rcvrIsConst = (((ssValue(1))->type)) == SSConstant))
  	 && (((((ssValue(1))->constant)) & 1)))
  	 || ((mclassIsSmallInteger())
  	 && (isSameEntryAs(ssValue(1), simSelf())));
  	if (argIsIntConst
  	 && (rcvrIsInt
  	 && (rcvrIsConst))) {
  		return genStaticallyResolvedSpecialSelectorComparison();
  	}
  	/* begin extractMaybeBranchDescriptorInto: */
  	primDescriptor1 = generatorAt(byte0);
  	nextPC1 = bytecodePC + ((primDescriptor1->numBytes));
  	nExts = 0;
  	while (1) {
  		while (1) {
  			/* begin generatorForPC: */
  			branchDescriptor1 = generatorAt(bytecodeSetOffset + (fetchByteofObject(nextPC1, methodObj)));
  			if (!((branchDescriptor1->isExtension))) break;
  			nExts += 1;
  			nextPC1 += (branchDescriptor1->numBytes);
  		}
  		/* begin isUnconditionalBranch */
  		if (!((isBranch(branchDescriptor1))
  		 && (!(((branchDescriptor1->isBranchTrue))
  		 || ((branchDescriptor1->isBranchFalse)))))) break;
  		nextPC1 = eventualTargetOf((nextPC1 + ((branchDescriptor1->numBytes))) + (((branchDescriptor1->spanFunction))(branchDescriptor1, nextPC1, nExts, methodObj)));
  	}
  	targetBytecodePC = (postBranchPC1 = 0);
  	if (((branchDescriptor1->isBranchTrue))
  	 || ((branchDescriptor1->isBranchFalse))) {
  		targetBytecodePC = eventualTargetOf((nextPC1 + ((branchDescriptor1->numBytes))) + (((branchDescriptor1->spanFunction))(branchDescriptor1, nextPC1, nExts, methodObj)));
  		postBranchPC1 = eventualTargetOf(nextPC1 + ((branchDescriptor1->numBytes)));
  	}
  	else {
  		nextPC1 = bytecodePC + ((primDescriptor1->numBytes));
  	}
  	branchDescriptor = branchDescriptor1;
  	nextPC = nextPC1;
  	postBranchPC = postBranchPC1;
  	targetPC = targetBytecodePC;
  
  	/* Further, only interested in inlining = and ~= if there's a SmallInteger constant involved.
  	   The relational operators successfully statically predict SmallIntegers; the equality operators do not. */
  	inlineCAB = ((branchDescriptor->isBranchTrue))
  	 || ((branchDescriptor->isBranchFalse));
  	if (inlineCAB
  	 && ((((primDescriptor->opcode)) == JumpZero)
  	 || (((primDescriptor->opcode)) == JumpNonZero))) {
  		inlineCAB = argIsIntConst
  		 || (rcvrIsInt);
  	}
  	if (!inlineCAB) {
  		return genSpecialSelectorSend();
  	}
  	if (argIsIntConst) {
  		popToReg(ssValue(1), ReceiverResultReg);
  		ssPop(2);
  	}
  	else {
  		marshallSendArguments(1);
  	}
  	jumpNotSmallInts = (!(rcvrIsInt
   && (argIsIntConst))
  		? (argIsIntConst
  				? genJumpNotSmallInteger(ReceiverResultReg)
  				: (rcvrIsInt
  						? genJumpNotSmallInteger(Arg0Reg)
  						: (/* begin genJumpNotSmallIntegersIn:and:scratch: */
  							genoperandoperand(MoveRR, ReceiverResultReg, TempReg),
  							/* begin AndR:R: */
  							genoperandoperand(AndRR, Arg0Reg, TempReg),
  							genJumpNotSmallIntegerInScratchReg(TempReg))))
  		: 0);
  	if (argIsIntConst) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction = genoperandoperand(CmpCqR, argInt, ReceiverResultReg);
  		if (usesOutOfLineLiteral(anInstruction)) {
  			(anInstruction->dependent = locateLiteral(argInt));
  		}
  	}
  	else {
  		/* begin CmpR:R: */
  		assert(!((Arg0Reg == SPReg)));
  		genoperandoperand(CmpRR, Arg0Reg, ReceiverResultReg);
  	}
  	genConditionalBranchoperand(((branchDescriptor->isBranchTrue)
  		? (primDescriptor->opcode)
  		: inverseBranchFor((primDescriptor->opcode))), ((usqInt)(ensureNonMergeFixupAt(targetPC))));
  	/* begin Jump: */
  	jumpTarget = ensureNonMergeFixupAt(postBranchPC);
  	genoperand(Jump, ((sqInt)jumpTarget));
  	if (!(jumpNotSmallInts)) {
  		/* begin annotateInstructionForBytecode */
  		if (prevInstIsPCAnnotated()) {
  			/* begin Nop */
  			abstractInstruction = gen(Nop);
  		}
  		else {
  			/* begin Label */
  			abstractInstruction = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  		}
  		(abstractInstruction->annotation = HasBytecodePC);
  		ensureFixupAt(postBranchPC);
  		ensureFixupAt(targetPC);
  		deadCode = 1;
  		return 0;
  	}
  	jmpTarget(jumpNotSmallInts, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	if (argIsIntConst) {
  		/* begin checkQuickConstant:forInstruction: */
  		anInstruction1 = genoperandoperand(MoveCqR, argInt, Arg0Reg);
  		if (usesOutOfLineLiteral(anInstruction1)) {
  			(anInstruction1->dependent = locateLiteral(argInt));
  		}
  	}
  	index = byte0 - (
  #if MULTIPLEBYTECODESETS
  	(bytecodeSetOffset == 256
  		? AltFirstSpecialSelector + 256
  		: FirstSpecialSelector)
  #else /* MULTIPLEBYTECODESETS */
  	FirstSpecialSelector
  #endif /* MULTIPLEBYTECODESETS */
  	);
  	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()));
  }
  
  
  /*	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;
      sqInt i;
      sqInt topReg;
  
  	assert(needsFrame);
  	/* begin genLoadLiteralVariable:in: */
  	association = getLiteral(litVarIndex);
  	voidReceiverResultRegContainsSelf();
  	/* begin ssAllocateRequiredReg: */
  	ssAllocateRequiredRegMaskupThroughupThroughNative(1U << ReceiverResultReg, simStackPtr, simNativeStackPtr);
  	/* 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));
  		}
  	}
  	/* begin genGenericStorePop:slotIndex:destReg:needsStoreCheck:needsRestoreRcvr:needsImmutabilityCheck: */
  	
  #  if IMMUTABILITY
  	if (needsImmCheck) {
  		/* begin ssAllocateRequiredReg:upThrough: */
  		ssAllocateRequiredRegMaskupThroughupThroughNative(1U << ClassReg, simStackPtr - 1, simNativeStackPtr);
  		ssStoreAndReplacePoptoReg(popBoolean, ClassReg);
  		/* begin ssFlushTo: */
  		assert(tempsValidAndVolatileEntriesSpilled());
  		if (simSpillBase <= simStackPtr) {
  			for (i = (((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) < simStackPtr) ? ((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) : simStackPtr)); i <= simStackPtr; i += 1) {
  				assert(needsFrame);
  				ensureSpilledAtfrom(simStackAt(i), frameOffsetOfTemporary(i - 1), FPReg);
  			}
  			simSpillBase = simStackPtr + 1;
  		}
  		return genStoreWithImmutabilityCheckSourceRegslotIndexdestRegscratchRegneedsStoreCheckneedRestoreRcvr(ClassReg, ValueIndex, ReceiverResultReg, TempReg, needsStoreCheck, 0);
  	}
  #  endif /* IMMUTABILITY */
  	topReg = allocateRegForStackEntryAtnotConflictingWith(0, 1U << ReceiverResultReg);
  	ssStorePoptoReg(popBoolean, topReg);
  	return genStoreSourceRegslotIndexdestRegscratchReginFrameneedsStoreCheck(topReg, ValueIndex, ReceiverResultReg, TempReg, needsFrame, needsStoreCheck);
  }
  
  
  /*	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 *anInstruction;
      sqInt i;
      AbstractInstruction *immutabilityFailure;
      AbstractInstruction *mutableJump;
  
  	immutabilityFailure = ((AbstractInstruction *) 0);
  	assert(needsFrame);
  	ssFlushUpThroughReceiverVariable(slotIndex);
  	ensureReceiverResultRegContainsSelf();
  	/* begin genGenericStorePop:MaybeContextSlotIndex:needsStoreCheck:needsRestoreRcvr:needsImmutabilityCheck: */
  	assert(needsFrame);
  	
  #  if IMMUTABILITY
  	if (needsImmCheck) {
  		mutableJump = genJumpMutablescratchReg(ReceiverResultReg, TempReg);
  		genStoreTrampolineCall(slotIndex);
  		/* begin putSelfInReceiverResultReg */
  		storeToReg(simSelf(), ReceiverResultReg);
  		/* begin Jump: */
  		immutabilityFailure = genoperand(Jump, ((sqInt)0));
  		jmpTarget(mutableJump, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	}
  #  endif /* IMMUTABILITY */
  	ssPop(1);
  	/* begin ssAllocateCallReg:and: */
  	ssAllocateRequiredRegMaskupThroughupThroughNative(CallerSavedRegisterMask | ((1U << ClassReg) | (1U << SendNumArgsReg)), simStackPtr, simNativeStackPtr);
  	ssPush(1);
  	genLoadSlotsourceRegdestReg(SenderIndex, ReceiverResultReg, TempReg);
  	ssStoreAndReplacePoptoReg(popBoolean, ClassReg);
  	/* begin ssFlushTo: */
  	assert(tempsValidAndVolatileEntriesSpilled());
  	if (simSpillBase <= simStackPtr) {
  		for (i = (((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) < simStackPtr) ? ((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) : simStackPtr)); i <= simStackPtr; i += 1) {
  			assert(needsFrame);
  			ensureSpilledAtfrom(simStackAt(i), frameOffsetOfTemporary(i - 1), FPReg);
  		}
  		simSpillBase = simStackPtr + 1;
  	}
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperand(MoveCqR, slotIndex, SendNumArgsReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(slotIndex));
  	}
  	/* begin CallRT: */
  	abstractInstruction = genoperand(Call, ceStoreContextInstVarTrampoline);
  	(abstractInstruction->annotation = IsRelativeCall);
  	
  #  if IMMUTABILITY
  	if (needsImmCheck) {
  		jmpTarget(immutabilityFailure, genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	}
  #  endif /* IMMUTABILITY */
  	return 0;
  }
  
  	/* StackToRegisterMappingCogit>>#genStorePop:ReceiverVariable:needsStoreCheck:needsImmutabilityCheck: */
  static sqInt NoDbgRegParms
  genStorePopReceiverVariableneedsStoreCheckneedsImmutabilityCheck(sqInt popBoolean, sqInt slotIndex, sqInt needsStoreCheck, sqInt needsImmCheck)
  {
      sqInt i;
      sqInt needsImmCheck1;
      sqInt needsStoreCheck1;
      sqInt topReg;
  
  	ssFlushUpThroughReceiverVariable(slotIndex);
  	ensureReceiverResultRegContainsSelf();
  	/* begin genGenericStorePop:slotIndex:destReg:needsStoreCheck:needsRestoreRcvr:needsImmutabilityCheck: */
  	needsStoreCheck1 = (!useTwoPaths)
  	 && (needsStoreCheck);
  	needsImmCheck1 = needsImmCheck
  	 && (!useTwoPaths);
  	
  #  if IMMUTABILITY
  	if (needsImmCheck1) {
  		/* begin ssAllocateRequiredReg:upThrough: */
  		ssAllocateRequiredRegMaskupThroughupThroughNative(1U << ClassReg, simStackPtr - 1, simNativeStackPtr);
  		ssStoreAndReplacePoptoReg(popBoolean, ClassReg);
  		/* begin ssFlushTo: */
  		assert(tempsValidAndVolatileEntriesSpilled());
  		if (simSpillBase <= simStackPtr) {
  			for (i = (((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) < simStackPtr) ? ((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) : simStackPtr)); i <= simStackPtr; i += 1) {
  				assert(needsFrame);
  				ensureSpilledAtfrom(simStackAt(i), frameOffsetOfTemporary(i - 1), FPReg);
  			}
  			simSpillBase = simStackPtr + 1;
  		}
  		return genStoreWithImmutabilityCheckSourceRegslotIndexdestRegscratchRegneedsStoreCheckneedRestoreRcvr(ClassReg, slotIndex, ReceiverResultReg, TempReg, needsStoreCheck1, 1);
  	}
  #  endif /* IMMUTABILITY */
  	topReg = allocateRegForStackEntryAtnotConflictingWith(0, 1U << ReceiverResultReg);
  	ssStorePoptoReg(popBoolean, topReg);
  	return genStoreSourceRegslotIndexdestRegscratchReginFrameneedsStoreCheck(topReg, slotIndex, ReceiverResultReg, TempReg, needsFrame, needsStoreCheck1);
  }
  
  
  /*	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;
      sqInt topReg;
  
  	assert(needsFrame);
  	/* begin ssAllocateRequiredReg: */
  	ssAllocateRequiredRegMaskupThroughupThroughNative(1U << ReceiverResultReg, simStackPtr, simNativeStackPtr);
  	voidReceiverResultRegContainsSelf();
  	/* begin MoveMw:r:R: */
  	offset = frameOffsetOfTemporary(remoteTempIndex);
  	/* begin checkQuickConstant:forInstruction: */
  	anInstruction = genoperandoperandoperand(MoveMwrR, offset, FPReg, ReceiverResultReg);
  	if (usesOutOfLineLiteral(anInstruction)) {
  		(anInstruction->dependent = locateLiteral(offset));
  	}
  	/* begin genGenericStorePop:slotIndex:destReg:needsStoreCheck:needsRestoreRcvr:needsImmutabilityCheck: */
  	
  #  if IMMUTABILITY
  	
  #  endif /* IMMUTABILITY */
  	topReg = allocateRegForStackEntryAtnotConflictingWith(0, 1U << ReceiverResultReg);
  	ssStorePoptoReg(popBoolean, topReg);
  	return genStoreSourceRegslotIndexdestRegscratchReginFrameneedsStoreCheck(topReg, slotIndex, ReceiverResultReg, TempReg, needsFrame, needsStoreCheck);
  }
  
  	/* 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));
  	}
  	((simStackAt(tempIndex + 1))->bcptr = bytecodePC);
  	return 0;
  }
  
  
  /*	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 *abstractInstruction1;
      sqInt i;
      sqInt offset;
  
  
  	/* can't fall through */
  	deadCode = 1;
  	if (inBlock > 0) {
  		assert(needsFrame);
  		/* begin ssFlushTo: */
  		assert(tempsValidAndVolatileEntriesSpilled());
  		if (simSpillBase <= simStackPtr) {
  			for (i = (((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) < simStackPtr) ? ((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) : simStackPtr)); i <= simStackPtr; i += 1) {
  				assert(needsFrame);
  				ensureSpilledAtfrom(simStackAt(i), frameOffsetOfTemporary(i - 1), FPReg);
  			}
  			simSpillBase = simStackPtr + 1;
  		}
  		/* begin CallRT: */
  		abstractInstruction = genoperand(Call, ceNonLocalReturnTrampoline);
  		(abstractInstruction->annotation = IsRelativeCall);
  		/* begin annotateBytecode: */
  		abstractInstruction1 = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  		(abstractInstruction1->annotation = HasBytecodePC);
  		return 0;
  	}
  	if (
  #  if IMMUTABILITY
  		needsFrame
  			 && (!useTwoPaths)
  #  else /* IMMUTABILITY */
  		needsFrame
  #  endif /* IMMUTABILITY */
  		) {
  		/* begin MoveR:R: */
  		genoperandoperand(MoveRR, FPReg, SPReg);
  		/* begin PopR: */
  		genoperand(PopR, FPReg);
  		/* begin PopR: */
  		genoperand(PopR, LinkReg);
  		/* begin RetN: */
  		genoperand(RetN, (methodOrBlockNumArgs + 1) * BytesPerWord);
  	}
  	else {
  		/* begin RetN: */
  		offset = ((methodOrBlockNumArgs > 1 /* numRegArgs */)
  		 || (regArgsHaveBeenPushed)
  			? (methodOrBlockNumArgs + 1) * BytesPerWord
  			: 0);
  		genoperand(RetN, offset);
  	}
  	return 0;
  }
  
  	/* StackToRegisterMappingCogit>>#genVanillaInlinedIdenticalOrNotIf: */
  static sqInt NoDbgRegParms
  genVanillaInlinedIdenticalOrNotIf(sqInt orNot)
  {
      AbstractInstruction *anInstruction;
      AbstractInstruction *anInstruction1;
      AbstractInstruction *anInstruction2;
      int argIsConstant;
      sqInt argNeedsReg;
      sqInt argReg;
      sqInt argReg1;
      BytecodeDescriptor *branchDescriptor;
      BytecodeDescriptor *branchDescriptor1;
      sqInt constant;
      sqInt constant1;
      sqInt i;
      void *jumpTarget;
      void *jumpTarget1;
      void *jumpTarget2;
      void *jumpTarget3;
      sqInt nExts;
      sqInt nextPC;
      sqInt nextPC1;
      sqInt postBranchPC;
      sqInt postBranchPC1;
      BytecodeDescriptor *primDescriptor;
      sqInt rcvrIsConstant;
      sqInt rcvrNeedsReg;
      sqInt rcvrReg;
      sqInt rcvrReg1;
      sqInt reg;
      sqInt rNext1;
      sqInt rTop1;
      sqInt targetBytecodePC;
      sqInt targetPC;
      sqInt topRegistersMask;
  
  	/* begin extractMaybeBranchDescriptorInto: */
  	primDescriptor = generatorAt(byte0);
  	nextPC1 = bytecodePC + ((primDescriptor->numBytes));
  	nExts = 0;
  	while (1) {
  		while (1) {
  			/* begin generatorForPC: */
  			branchDescriptor1 = generatorAt(bytecodeSetOffset + (fetchByteofObject(nextPC1, methodObj)));
  			if (!((branchDescriptor1->isExtension))) break;
  			nExts += 1;
  			nextPC1 += (branchDescriptor1->numBytes);
  		}
  		/* begin isUnconditionalBranch */
  		if (!((isBranch(branchDescriptor1))
  		 && (!(((branchDescriptor1->isBranchTrue))
  		 || ((branchDescriptor1->isBranchFalse)))))) break;
  		nextPC1 = eventualTargetOf((nextPC1 + ((branchDescriptor1->numBytes))) + (((branchDescriptor1->spanFunction))(branchDescriptor1, nextPC1, nExts, methodObj)));
  	}
  	targetBytecodePC = (postBranchPC1 = 0);
  	if (((branchDescriptor1->isBranchTrue))
  	 || ((branchDescriptor1->isBranchFalse))) {
  		targetBytecodePC = eventualTargetOf((nextPC1 + ((branchDescriptor1->numBytes))) + (((branchDescriptor1->spanFunction))(branchDescriptor1, nextPC1, nExts, methodObj)));
  		postBranchPC1 = eventualTargetOf(nextPC1 + ((branchDescriptor1->numBytes)));
  	}
  	else {
  		nextPC1 = bytecodePC + ((primDescriptor->numBytes));
  	}
  	branchDescriptor = branchDescriptor1;
  	nextPC = nextPC1;
  	postBranchPC = postBranchPC1;
  	targetPC = targetBytecodePC;
  
  	/* They can't be both constants to use correct machine opcodes.
  	   However annotable constants can't be resolved statically, hence we need to careful. */
  	argIsConstant = (((ssTop())->type)) == SSConstant;
  	rcvrIsConstant = (!argIsConstant)
  	 && ((((ssValue(1))->type)) == SSConstant);
  	/* begin allocateEqualsEqualsRegistersArgNeedsReg:rcvrNeedsReg:into: */
  	argNeedsReg = !argIsConstant;
  	rcvrNeedsReg = !rcvrIsConstant;
  	assert(argNeedsReg
  	 || (rcvrNeedsReg));
  	argReg1 = (rcvrReg1 = NoReg);
  	if (argNeedsReg) {
  		if (rcvrNeedsReg) {
  			/* begin allocateRegForStackTopTwoEntriesInto: */
  			topRegistersMask = 0;
  			rTop1 = (rNext1 = NoReg);
  			if ((registerOrNone(ssTop())) != NoReg) {
  				rTop1 = registerOrNone(ssTop());
  			}
  			if ((registerOrNone(ssValue(1))) != NoReg) {
  				/* begin registerMaskFor: */
  				reg = (rNext1 = registerOrNone(ssValue(1)));
  				topRegistersMask = 1U << reg;
  			}
  			if (rTop1 == NoReg) {
  				rTop1 = allocateRegNotConflictingWith(topRegistersMask);
  			}
  			if (rNext1 == NoReg) {
  				rNext1 = allocateRegNotConflictingWith(1U << rTop1);
  			}
  			assert(!(((rTop1 == NoReg)
   || (rNext1 == NoReg))));
  			argReg1 = rTop1;
  			rcvrReg1 = rNext1;
  			popToReg(ssTop(), argReg1);
  			popToReg(ssValue(1), rcvrReg1);
  		}
  		else {
  			argReg1 = allocateRegForStackEntryAtnotConflictingWith(0, 0);
  			popToReg(ssTop(), argReg1);
  			if (((ssValue(1))->spilled)) {
  				/* begin checkQuickConstant:forInstruction: */
  				anInstruction2 = genoperandoperand(AddCqR, BytesPerWord, SPReg);
  				if (usesOutOfLineLiteral(anInstruction2)) {
  					(anInstruction2->dependent = locateLiteral(BytesPerWord));
  				}
  			}
  		}
  	}
  	else {
  		assert(rcvrNeedsReg);
  		assert(!((((ssTop())->spilled))));
  		rcvrReg1 = allocateRegForStackEntryAtnotConflictingWith(1, 0);
  		popToReg(ssValue(1), rcvrReg1);
  	}
  	assert(!((argNeedsReg
   && (argReg1 == NoReg))));
  	assert(!((rcvrNeedsReg
   && (rcvrReg1 == NoReg))));
  	rcvrReg = rcvrReg1;
  	argReg = argReg1;
  	if (!(((branchDescriptor->isBranchTrue))
  		 || ((branchDescriptor->isBranchFalse)))) {
  		return genIdenticalNoBranchArgIsConstantrcvrIsConstantargRegrcvrRegorNotIf(argIsConstant, rcvrIsConstant, argReg, rcvrReg, orNot);
  	}
  	/* begin ssFlushTo: */
  	assert(tempsValidAndVolatileEntriesSpilled());
  	if (simSpillBase <= (simStackPtr - 2)) {
  		for (i = (((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) < (simStackPtr - 2)) ? ((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) : (simStackPtr - 2))); i <= (simStackPtr - 2); i += 1) {
  			assert(needsFrame);
  			ensureSpilledAtfrom(simStackAt(i), frameOffsetOfTemporary(i - 1), FPReg);
  		}
  		simSpillBase = (simStackPtr - 2) + 1;
  	}
  	/* begin genCmpArgIsConstant:rcvrIsConstant:argReg:rcvrReg: */
  	assert((argReg != NoReg)
  	 || (rcvrReg != NoReg));
  	if (argIsConstant) {
  		/* begin genCmpConstant:R: */
  		constant = ((ssTop())->constant);
  		if (shouldAnnotateObjectReference(constant)) {
  			annotateobjRef(checkLiteralforInstruction(constant, genoperandoperand(CmpCwR, constant, rcvrReg)), constant);
  		}
  		else {
  			/* begin checkQuickConstant:forInstruction: */
  			anInstruction = genoperandoperand(CmpCqR, constant, rcvrReg);
  			if (usesOutOfLineLiteral(anInstruction)) {
  				(anInstruction->dependent = locateLiteral(constant));
  			}
  		}
  	}
  	else {
  		if (rcvrIsConstant) {
  			/* begin genCmpConstant:R: */
  			constant1 = ((ssValue(1))->constant);
  			if (shouldAnnotateObjectReference(constant1)) {
  				annotateobjRef(checkLiteralforInstruction(constant1, genoperandoperand(CmpCwR, constant1, argReg)), constant1);
  			}
  			else {
  				/* begin checkQuickConstant:forInstruction: */
  				anInstruction1 = genoperandoperand(CmpCqR, constant1, argReg);
  				if (usesOutOfLineLiteral(anInstruction1)) {
  					(anInstruction1->dependent = locateLiteral(constant1));
  				}
  			}
  		}
  		else {
  			/* begin CmpR:R: */
  			assert(!((argReg == SPReg)));
  			genoperandoperand(CmpRR, argReg, rcvrReg);
  		}
  	}
  	ssPop(2);
  	if ((((fixupAt(nextPC))->targetInstruction)) == 0) {
  
  		/* The next instruction is dead.  we can skip it. */
  		deadCode = 1;
  		ensureFixupAt(targetPC);
  		ensureFixupAt(postBranchPC);
  	}
  	else {
  		assert(!(deadCode));
  	}
  	if (orNot == ((branchDescriptor->isBranchTrue))) {
  
  		/* a == b ifFalse: ... or a ~~ b ifTrue: ... jump on equal to post-branch pc */
  		ensureNonMergeFixupAt(targetPC);
  		/* begin JumpZero: */
  		jumpTarget = ensureNonMergeFixupAt(postBranchPC);
  		genConditionalBranchoperand(JumpZero, ((sqInt)jumpTarget));
  		/* begin Jump: */
  		jumpTarget1 = ensureNonMergeFixupAt(targetPC);
  		genoperand(Jump, ((sqInt)jumpTarget1));
  	}
  	else {
  
  		/* orNot is true for ~~ */
  		/* a == b ifTrue: ... or a ~~ b ifFalse: ... jump on equal to target pc */
  		/* begin JumpZero: */
  		jumpTarget2 = ensureNonMergeFixupAt(targetPC);
  		genConditionalBranchoperand(JumpZero, ((sqInt)jumpTarget2));
  		/* begin Jump: */
  		jumpTarget3 = ensureNonMergeFixupAt(postBranchPC);
  		genoperand(Jump, ((sqInt)jumpTarget3));
  	}
  	if (!deadCode) {
  		ssPushConstant(trueObject());
  	}
  	return 0;
  }
  
  	/* StackToRegisterMappingCogit>>#initSimStackForFramefulMethod: */
  static void NoDbgRegParms
  initSimStackForFramefulMethod(sqInt startpc)
  {
      CogSimStackEntry * cascade0;
      CogSimStackEntry *desc;
      sqInt i;
  
  
  	/* N.B. Includes num args */
  	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);
  	}
  
  	/* N.B. Includes num args */
  	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 <= 1 /* numRegArgs */))) {
  		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;
  	}
  
  
  /*	Do not inline (inBlock access) */
  
  	/* StackToRegisterMappingCogit>>#isNonForwarderReceiver: */
  static sqInt NoDbgRegParms
  isNonForwarderReceiver(sqInt reg)
  {
  	return ((((simSelf())->liveRegister)) == ReceiverResultReg)
  	 && ((inBlock == 0)
  	 && (reg == ReceiverResultReg));
  }
  
  	/* StackToRegisterMappingCogit>>#liveRegisters */
  static sqInt
  liveRegisters(void)
  {
      sqInt i;
      sqInt regsSet;
  
  	if (needsFrame) {
  		regsSet = 0;
  	}
  	else {
  		/* begin registerMaskFor: */
  		regsSet = 1U << ReceiverResultReg;
  		if ((methodOrBlockNumArgs <= 1 /* numRegArgs */)
  		 && (methodOrBlockNumArgs > 0)) {
  			regsSet = regsSet | (1U << Arg0Reg);
  					}
  	}
  	for (i = (((simSpillBase < 0) ? 0 : simSpillBase)); i <= simStackPtr; i += 1) {
  		regsSet = regsSet | (registerMask(simStackAt(i)));
  	}
  	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);
  	}
  	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)
  {
      sqInt anyRefs;
      CogSimStackEntry * cascade0;
      sqInt i;
      sqInt i1;
      sqInt i2;
      sqInt numSpilled;
  
  	/* begin ssFlushTo: */
  	assert(tempsValidAndVolatileEntriesSpilled());
  	if (simSpillBase <= ((simStackPtr - numArgs) - 1)) {
  		for (i2 = (((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) < ((simStackPtr - numArgs) - 1)) ? ((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) : ((simStackPtr - numArgs) - 1))); i2 < (simStackPtr - numArgs); i2 += 1) {
  			assert(needsFrame);
  			ensureSpilledAtfrom(simStackAt(i2), frameOffsetOfTemporary(i2 - 1), FPReg);
  		}
  		simSpillBase = ((simStackPtr - numArgs) - 1) + 1;
  	}
  	if (numArgs > 1 /* numRegArgs */) {
  
  		/* If there are no spills and no references to ReceiverResultReg
  		   the fetch of ReceiverResultReg from the stack can be avoided
  		   by assigning directly to ReceiverResultReg and pushing it. */
  		numSpilled = numberOfSpillsInTopNItems(numArgs + 1);
  		anyRefs = anyReferencesToRegisterinTopNItems(ReceiverResultReg, numArgs + 1);
  		if ((numSpilled > 0)
  		 || (anyRefs)) {
  			/* begin ssFlushTo: */
  			assert(tempsValidAndVolatileEntriesSpilled());
  			if (simSpillBase <= simStackPtr) {
  				for (i = (((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) < simStackPtr) ? ((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) : simStackPtr)); i <= simStackPtr; i += 1) {
  					assert(needsFrame);
  					ensureSpilledAtfrom(simStackAt(i), frameOffsetOfTemporary(i - 1), FPReg);
  				}
  				simSpillBase = simStackPtr + 1;
  			}
  			storeToReg(simStackAt(simStackPtr - numArgs), ReceiverResultReg);
  		}
  		else {
  			cascade0 = simStackAt(simStackPtr - numArgs);
  			storeToReg(cascade0, ReceiverResultReg);
  			(cascade0->type = SSRegister);
  			(cascade0->registerr = ReceiverResultReg);
  			/* begin ssFlushTo: */
  			assert(tempsValidAndVolatileEntriesSpilled());
  			if (simSpillBase <= simStackPtr) {
  				for (i1 = (((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) < simStackPtr) ? ((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) : simStackPtr)); i1 <= simStackPtr; i1 += 1) {
  					assert(needsFrame);
  					ensureSpilledAtfrom(simStackAt(i1), frameOffsetOfTemporary(i1 - 1), FPReg);
  				}
  				simSpillBase = simStackPtr + 1;
  			}
  		}
  	}
  	else {
  
  		/* Move the args to the register arguments, being careful to do
  		   so last to first so e.g. previous contents don't get overwritten.
  		   Also check for any arg registers in use by other args. */
  		if (numArgs > 0) {
  			/* begin ssAllocateRequiredReg:upThrough: */
  			ssAllocateRequiredRegMaskupThroughupThroughNative(1U << Arg0Reg, simStackPtr - 1, simNativeStackPtr);
  		}
  		if (numArgs > 0) {
  			popToReg(simStackAt((simStackPtr - numArgs) + 1), Arg0Reg);
  		}
  		popToReg(simStackAt(simStackPtr - numArgs), ReceiverResultReg);
  	}
  	ssPop(numArgs + 1);
  }
  
  
  /*	For assert checking; or rather for avoiding assert fails when dealing with
  	the hack for block temps in the SqueakV3PlusClosures bytecode set.
   */
  
  	/* StackToRegisterMappingCogit>>#maybeCompilingFirstPassOfBlockWithInitialPushNil */
  static sqInt
  maybeCompilingFirstPassOfBlockWithInitialPushNil(void)
  {
  	return (inBlock == InVanillaBlock)
  	 && ((methodOrBlockNumTemps > methodOrBlockNumArgs)
  	 && (compilationPass == 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;
      sqInt i1;
  
  	/* begin assertCorrectSimStackPtr */
  	assert((simSpillBase >= methodOrBlockNumTemps)
  	 || ((maybeCompilingFirstPassOfBlockWithInitialPushNil())
  	 && (simSpillBase > methodOrBlockNumArgs)));
  	if (needsFrame
  	 && (simSpillBase > 0)) {
  		assert((((simStackAt(simSpillBase - 1))->spilled)) == 1);
  		assert((simSpillBase > simStackPtr)
  		 || ((((simStackAt(simSpillBase))->spilled)) == 0));
  	}
  	if (((fixup->targetInstruction)) == 0) {
  		return 0;
  	}
  	if ((((usqInt)((fixup->targetInstruction)))) == NeedsNonMergeFixupFlag) {
  		deadCode = 0;
  		return 0;
  	}
  	assert(isMergeFixup(fixup));
  	traceMerge(fixup);
  	if (deadCode) {
  
  		/* case 3 */
  		/* Would like to assert fixup simStackPtr >= methodOrBlockNumTemps
  		   but can't because of the initialNils hack. */
  		assert((((fixup->simStackPtr)) >= methodOrBlockNumTemps)
  		 || (maybeCompilingFirstPassOfBlockWithInitialPushNil()));
  		simStackPtr = (fixup->simStackPtr);
  			}
  	else {
  
  		/* case 4 */
  		/* begin ssFlushTo: */
  		assert(tempsValidAndVolatileEntriesSpilled());
  		if (simSpillBase <= simStackPtr) {
  			for (i = (((((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) < simStackPtr) ? ((((((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) < simStackPtr) ? (((simSpillBase < (methodOrBlockNumTemps + 1)) ? (methodOrBlockNumTemps + 1) : simSpillBase)) : simStackPtr)) : simStackPtr)); i <= simStackPtr; i += 1) {
  				assert(needsFrame);
  				ensureSpilledAtfrom(simStackAt(i), frameOffsetOfTemporary(i - 1), FPReg);
  			}
  			simSpillBase = simStackPtr + 1;
  		}
  	}
  	deadCode = 0;
  	if ((fixup->isTargetOfBackwardBranch)) {
  		(fixup->simStackPtr = simStackPtr);
  			}
  	(fixup->targetInstruction = genoperandoperand(Label, (labelCounter += 1), bytecodePC));
  	assert(simStackPtr == ((fixup->simStackPtr)));
  	/* begin restoreSimStackAtMergePoint: */
  	((simSelf())->liveRegister = NoReg);
  	for (i1 = (methodOrBlockNumTemps + 1); i1 <= simStackPtr; i1 += 1) {
  		cascade0 = simStackAt(i1);
  		(cascade0->type = SSSpill);
  		(cascade0->offset = FoxMFReceiver - ((i1 - methodOrBlockNumArgs) * BytesPerOop));
  		(cascade0->registerr = FPReg);
  		(cascade0->spilled = 1);
  	}
  	simSpillBase = simStackPtr + 1;
  	return 0;
  }
  
  	/* StackToRegisterMappingCogit>>#methodAbortTrampolineFor: */
  static sqInt NoDbgRegParms
  methodAbortTrampolineFor(sqInt numArgs)
  {
  	return methodAbortTrampolines[((numArgs < (2)) ? numArgs : (2))];
  }
  
  
  /*	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;
  }
  
  	/* 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)) ? numArgs : (2))];
  }
  
  	/* 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;
  }
  
  
  /*	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;
  }
  
  
  /*	When a block must be recompiled due to overestimating the
  	numInitialNils fixups must be restored, which means rescannning
  	since backward branches need their targets initialized. */
  
  	/* StackToRegisterMappingCogit>>#reinitializeFixupsFrom:through: */
  static void NoDbgRegParms
  reinitializeFixupsFromthrough(sqInt start, sqInt end)
  {
      BytecodeDescriptor *descriptor;
      sqInt distance;
      BytecodeFixup * fixup;
      sqInt nExts;
      sqInt pc;
      BytecodeFixup * self_in_reinitialize;
      sqInt targetPC;
  
  	pc = start;
  	nExts = 0;
  	while (pc <= end) {
  		/* begin reinitialize */
  		self_in_reinitialize = fixupAtIndex(pc - initialPC);
  		(self_in_reinitialize->targetInstruction) = 0;
  		(self_in_reinitialize->simStackPtr) = 0;
  		byte0 = (fetchByteofObject(pc, methodObj)) + bytecodeSetOffset;
  		descriptor = generatorAt(byte0);
  		if ((isBranch(descriptor))
  		 && ((assert(((descriptor->spanFunction)) != null),
  		(((descriptor->spanFunction))(descriptor, pc, nExts, methodObj)) < 0))) {
  			/* begin spanFor:at:exts:in: */
  			distance = ((descriptor->spanFunction))(descriptor, pc, nExts, methodObj);
  			targetPC = (pc + ((descriptor->numBytes))) + distance;
  			/* begin initializeFixupAt: */
  			fixup = fixupAtIndex(targetPC - initialPC);
  			/* begin initializeFixup: */
  			(fixup->targetInstruction) = ((AbstractInstruction *) NeedsMergeFixupFlag);
  			/* begin setIsBackwardBranchFixup */
  			(fixup->isTargetOfBackwardBranch) = 1;
  		}
  		if ((descriptor->isBlockCreation)) {
  			/* begin spanFor:at:exts:in: */
  			distance = ((descriptor->spanFunction))(descriptor, pc, nExts, methodObj);
  			pc = (pc + ((descriptor->numBytes))) + distance;
  		}
  		else {
  			pc += (descriptor->numBytes);
  		}
  		nExts = ((descriptor->isExtension)
  			? nExts + 1
  			: 0);
  	}
  }
  
  
  /*	Scan the block to determine if the block needs a frame or not */
  
  	/* StackToRegisterMappingCogit>>#scanBlock: */
  static sqInt NoDbgRegParms
  scanBlock(BlockStart *blockStart)
  {
      BytecodeDescriptor *descriptor;
      sqInt end;
      sqInt framelessStackDelta;
      sqInt nExts;
      sqInt numPushNils;
      sqInt (* const numPushNilsFunction)(struct _BytecodeDescriptor *,sqInt,sqInt,sqInt) = v3NumPushNils;
      sqInt pc;
      sqInt pushingNils;
  
  	needsFrame = 0;
  	prevBCDescriptor = null;
  	methodOrBlockNumArgs = (blockStart->numArgs);
  	inBlock = InVanillaBlock;
  	pc = (blockStart->startpc);
  	end = ((blockStart->startpc)) + ((blockStart->span));
  	framelessStackDelta = (nExts = (extA = (numExtB = (extB = 0))));
  	pushingNils = 1;
  	while (pc < end) {
  		byte0 = (fetchByteofObject(pc, methodObj)) + bytecodeSetOffset;
  		descriptor = generatorAt(byte0);
  		if ((descriptor->isExtension)) {
  			loadSubsequentBytesForDescriptorat(descriptor, pc);
  			((descriptor->generator))();
  		}
  		if (!needsFrame) {
  			if ((((descriptor->needsFrameFunction)) == null)
  			 || (((descriptor->needsFrameFunction))(framelessStackDelta))) {
  				needsFrame = 1;
  			}
  			else {
  				framelessStackDelta += (descriptor->stackDelta);
  			}
  		}
  		if (pushingNils
  		 && (!((descriptor->isExtension)))) {
  
  			/* Count the initial number of pushed nils acting as temp initializers.  We can't tell
  			   whether an initial pushNil is an operand reference or a temp initializer, except
  			   when the pushNil is a jump target (has a fixup), which never happens:
  			   self systemNavigation browseAllSelect:
  			   [:m| | ebc |
  			   (ebc := m embeddedBlockClosures
  			   select: [:ea| ea decompile statements first isMessage]
  			   thenCollect: [:ea| ea decompile statements first selector]) notEmpty
  			   and: [(#(whileTrue whileFalse whileTrue: whileFalse:) intersection: ebc) notEmpty]]
  			   or if the bytecode set has a push multiple nils bytecode.  We simply count initial nils.
  			   Rarely we may end up over-estimating.  We will correct by checking the stack depth
  			   at the end of the block in compileBlockBodies. */
  			if (((numPushNils = numPushNilsFunction(descriptor, pc, nExts, methodObj))) > 0) {
  				assert(((descriptor->numBytes)) == 1);
  				(blockStart->numInitialNils = ((blockStart->numInitialNils)) + numPushNils);
  			}
  			else {
  				pushingNils = 0;
  			}
  		}
  		/* begin nextBytecodePCFor:at:exts:in: */
  		pc = (pc + ((descriptor->numBytes))) + (((descriptor->isBlockCreation)
  	? ((descriptor->spanFunction))(descriptor, pc, nExts, methodObj)
  	: 0));
  		if ((descriptor->isExtension)) {
  			nExts += 1;
  		}
  		else {
  			nExts = (extA = (numExtB = (extB = 0)));
  		}
  		prevBCDescriptor = descriptor;
  	}
  	if (!needsFrame) {
  		assert((framelessStackDelta >= 0)
  		 && (((blockStart->numInitialNils)) >= framelessStackDelta));
  		(blockStart->numInitialNils = ((blockStart->numInitialNils)) - framelessStackDelta);
  	}
  	return 0;
  }
  
  
  /*	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.
  	- how many blocks it creates
  	Answer the block count or on error a negative error code */
  
  	/* StackToRegisterMappingCogit>>#scanMethod */
  static sqInt
  scanMethod(void)
  {
      BytecodeDescriptor *descriptor;
      sqInt distance;
      BytecodeFixup * fixup;
      sqInt framelessStackDelta;
      sqInt latestContinuation;
      sqInt nExts;
      sqInt numBlocks;
      sqInt pc;
      sqInt seenInstVarStore;
      sqInt targetPC;
  
  	needsFrame = (useTwoPaths = (seenInstVarStore = 0));
  	prevBCDescriptor = null;
  	if ((primitiveIndex > 0)
  	 && (isQuickPrimitiveIndex(primitiveIndex))) {
  		return 0;
  	}
  	pc = (latestContinuation = initialPC);
  	numBlocks = (framelessStackDelta = (nExts = (extA = (numExtB = (extB = 0)))));
  	while (pc <= endPC) {
  		byte0 = (fetchByteofObject(pc, methodObj)) + bytecodeSetOffset;
  		descriptor = generatorAt(byte0);
  		if ((descriptor->isExtension)) {
  			if (((descriptor->opcode)) == Nop) {
  
  				/* unknown bytecode tag; see Cogit class>>#generatorTableFrom: */
  				return EncounteredUnknownBytecode;
  			}
  			loadSubsequentBytesForDescriptorat(descriptor, pc);
  			((descriptor->generator))();
  		}
  		if (((descriptor->isReturn))
  		 && (pc >= latestContinuation)) {
  			endPC = pc;
  		}
  		if (!needsFrame) {
  			if ((((descriptor->needsFrameFunction)) == null)
  			 || (((descriptor->needsFrameFunction))(framelessStackDelta))) {
  
  				/* With immutability we win simply by avoiding a frame build if the receiver is young and not immutable. */
  				
  #        if IMMUTABILITY
  				if ((descriptor->is1ByteInstVarStore)) {
  					useTwoPaths = 1;
  				}
  				else {
  					needsFrame = 1;
  					useTwoPaths = 0;
  				}
  #        else /* IMMUTABILITY */
  				needsFrame = 1;
  				useTwoPaths = 0;
  #        endif /* IMMUTABILITY */
  			}
  			else {
  
  				/* Without immutability we win if there are two or more stores and the receiver is new. */
  				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);
  			targetPC = (pc + ((descriptor->numBytes))) + distance;
  			if ((assert(((descriptor->spanFunction)) != null),
  			(((descriptor->spanFunction))(descriptor, pc, nExts, methodObj)) < 0)) {
  				/* begin initializeFixupAt: */
  				fixup = fixupAtIndex(targetPC - initialPC);
  				/* begin initializeFixup: */
  				(fixup->targetInstruction) = ((AbstractInstruction *) NeedsMergeFixupFlag);
  				/* begin setIsBackwardBranchFixup */
  				(fixup->isTargetOfBackwardBranch) = 1;
  			}
  			else {
  				latestContinuation = ((latestContinuation < targetPC) ? targetPC : latestContinuation);
  			}
  		}
  		/* begin maybeDealWithUnsafeJumpForDescriptor:pc:latestContinuation: */
  		/* latestContinuation = */ latestContinuation;
  		if ((descriptor->isBlockCreation)) {
  			numBlocks += 1;
  			/* begin spanFor:at:exts:in: */
  			distance = ((descriptor->spanFunction))(descriptor, pc, nExts, methodObj);
  			targetPC = (pc + ((descriptor->numBytes))) + distance;
  			latestContinuation = ((latestContinuation < targetPC) ? targetPC : latestContinuation);
  		}
  		pc += (descriptor->numBytes);
  		nExts = ((descriptor->isExtension)
  			? nExts + 1
  			: (extA = (numExtB = (extB = 0))));
  		prevBCDescriptor = descriptor;
  	}
  	return numBlocks;
  }
  
  	/* StackToRegisterMappingCogit>>#ssAllocateRequiredRegMask:upThrough:upThroughNative: */
  static void NoDbgRegParms
  ssAllocateRequiredRegMaskupThroughupThroughNative(sqInt requiredRegsMask, sqInt stackPtr, sqInt nativeStackPtr)
  {
      sqInt i;
      sqInt i1;
      sqInt lastRequired;
      sqInt lastRequiredNative;
      sqInt liveRegs;
  
  	lastRequired = -1;
  
  	/* compute live regs while noting the last occurrence of required regs.
  	   If these are not free we must spill from simSpillBase to last occurrence.
  	   Note we are conservative here; we could allocate FPReg in frameless methods. */
  	lastRequiredNative = -1;
  	/* begin registerMaskFor:and: */
  	liveRegs = (1U << FPReg) | (1U << SPReg);
  	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 (i1 = (((((((((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)); i1 <= lastRequired; i1 += 1) {
  				assert(needsFrame);
  				ensureSpilledAtfrom(simStackAt(i1), frameOffsetOfTemporary(i1 - 1), FPReg);
  			}
  			simSpillBase = lastRequired + 1;
  		}
  		assert(!(((liveRegisters()) & requiredRegsMask)));
  	}
  }
  
  
  /*	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;
  			}
  			goto l1;
  		}
  	}
  	l1:	/* 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;
  			}
  			goto l1;
  		}
  	}
  	l1:	/* end ssFlushUpThrough: */;
  }
  
  	/* StackToRegisterMappingCogit>>#ssPop: */
  static void NoDbgRegParms
  ssPop(sqInt n)
  {
      sqInt i;
  
  	assert(((simStackPtr - n) >= methodOrBlockNumTemps)
  	 || (((!needsFrame)
  	 && ((simStackPtr - n) >= 0))
  	 || (maybeCompilingFirstPassOfBlockWithInitialPushNil())));
  	simStackPtr -= n;
  	/* begin updateSimSpillBase */
  	assert(((simSpillBase > methodOrBlockNumTemps)
  	 && (simStackPtr >= methodOrBlockNumTemps))
  	 || (maybeCompilingFirstPassOfBlockWithInitialPushNil()));
  	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));
  }
  
  	/* StackToRegisterMappingCogit>>#ssPushAnnotatedConstant: */
  static sqInt NoDbgRegParms
  ssPushAnnotatedConstant(sqInt literal)
  {
      AbstractInstruction *abstractInstruction;
  
  	ssPushConstant(literal);
  	/* begin annotateInstructionForBytecode */
  	if (prevInstIsPCAnnotated()) {
  		/* begin Nop */
  		abstractInstruction = gen(Nop);
  	}
  	else {
  		/* begin Label */
  		abstractInstruction = genoperandoperand(Label, (labelCounter += 1), bytecodePC);
  	}
  	(abstractInstruction->annotation = HasBytecodePC);
  	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))
  	 || (maybeCompilingFirstPassOfBlockWithInitialPushNil()));
  	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));
  	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))
  	 || (maybeCompilingFirstPassOfBlockWithInitialPushNil()));
  	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));
  	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))
  	 || (maybeCompilingFirstPassOfBlockWithInitialPushNil()));
  	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));
  	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))
  	 || (maybeCompilingFirstPassOfBlockWithInitialPushNil()));
  	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));
  	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);
  	ssStorePoptoReg(popBoolean
  	 || (topSpilled), reg);
  	if (!popBoolean) {
  		if (!topSpilled) {
  			ssPop(1);
  		}
  		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);
  	}
  	ssStorePoptoReg(popBoolean, actualReg);
  	return actualReg;
  }
  
  
  /*	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>>#ssStorePop:toReg: */
  static void NoDbgRegParms
  ssStorePoptoReg(sqInt popBoolean, sqInt reg)
  {
  	if (popBoolean) {
  		popToReg(ssTop(), reg);
  		ssPop(1);
  	}
  	else {
  		storeToReg(ssTop(), reg);
  	}
  }
  
  	/* 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 culprit;
      sqInt i;
  
  	culprit = 0;
  	for (i = 1; i <= methodOrBlockNumTemps; i += 1) {
  		if (!(((((simStackAt(i))->type)) == SSBaseOffset)
  			 || (maybeCompilingFirstPassOfBlockWithInitialPushNil()))) {
  			if (!(culprit)) {
  				culprit = i;
  			}
  			return 0;
  		}
  	}
  	for (i = (methodOrBlockNumTemps + 1); i < simSpillBase; i += 1) {
  		if (!(((simStackAt(i))->spilled))) {
  			if (!(culprit)) {
  				culprit = i;
  			}
  			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 pc1;
      sqInt pc2;
      BytecodeDescriptor *pushArrayDesc;
      BytecodeDescriptor *pushValueDesc;
      sqInt reg;
      sqInt remoteTempIndex;
      BytecodeDescriptor *storeArrayDesc;
      BytecodeDescriptor *storeValueDesc;
      sqInt tempIndex;
  
  	if (slots != 1) {
  		return 0;
  	}
  	/* begin generatorForPC: */
  	pushArrayDesc = generatorAt(bytecodeSetOffset + (fetchByteofObject(bytecodePC, methodObj)));
  	assert(((pushArrayDesc->generator)) == genPushNewArrayBytecode);
  	/* begin generatorForPC: */
  	pc = bytecodePC + ((pushArrayDesc->numBytes));
  	storeArrayDesc = generatorAt(bytecodeSetOffset + (fetchByteofObject(pc, methodObj)));
  	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: */
  	pc1 = (bytecodePC + ((pushArrayDesc->numBytes))) + ((storeArrayDesc->numBytes));
  	pushValueDesc = generatorAt(bytecodeSetOffset + (fetchByteofObject(pc1, methodObj)));
  	if (!((((pushValueDesc->generator)) == genPushLiteralConstantBytecode)
  		 || ((((pushValueDesc->generator)) == genPushQuickIntegerConstantBytecode)
  		 || (((pushValueDesc->generator)) == genPushTemporaryVariableBytecode)))) {
  		return 0;
  	}
  	/* begin generatorForPC: */
  	pc2 = ((bytecodePC + ((pushArrayDesc->numBytes))) + ((storeArrayDesc->numBytes))) + ((pushValueDesc->numBytes));
  	storeValueDesc = generatorAt(bytecodeSetOffset + (fetchByteofObject(pc2, methodObj)));
  	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)));
  
  	/* + pushArrayDesc numBytes this gets added by nextBytecodePCFor:at:exts:in: */
  	bytecodePC = ((bytecodePC + ((storeArrayDesc->numBytes))) + ((pushValueDesc->numBytes))) + ((storeValueDesc->numBytes));
  	return 1;
  }
  
  	/* StackToRegisterMappingCogit>>#v3PushNilSize:numInitialNils: */
  static sqInt NoDbgRegParms
  v3PushNilSizenumInitialNils(sqInt aMethodObj, sqInt numInitialNils)
  {
  	return numInitialNils;
  }
  
  	/* StackToRegisterMappingCogit>>#v3:Num:Push:Nils: */
  static sqInt NoDbgRegParms
  v3NumPushNils(BytecodeDescriptor *descriptor, sqInt pc, sqInt nExts, sqInt aMethodObj)
  {
  	return (((descriptor->generator)) == genPushConstantNilBytecode
  		? 1
  		: 0);
  }
  
  	/* 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 i1;
      sqInt spillIndex;
  
  	/* begin voidReceiverOptStatus */
  	((simSelf())->liveRegister = NoReg);
  	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 (i1 = (((((((((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)); i1 <= spillIndex; i1 += 1) {
  				assert(needsFrame);
  				ensureSpilledAtfrom(simStackAt(i1), frameOffsetOfTemporary(i1 - 1), FPReg);
  			}
  			simSpillBase = spillIndex + 1;
  		}
  	}
  }
  