text: /* Automatically generated by
  	VMPluginCodeGenerator VMMaker.oscog-eem.2397 uuid: b696a3c2-2443-4c71-94ef-04a4a9a8c426
     from
  	IA32ABIPlugin VMMaker.oscog-eem.2397 uuid: b696a3c2-2443-4c71-94ef-04a4a9a8c426
   */
  static char __buildInfo[] = "IA32ABIPlugin VMMaker.oscog-eem.2397 uuid: b696a3c2-2443-4c71-94ef-04a4a9a8c426 " __DATE__ ;
  
  
  
  #include "config.h"
  #include <math.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include <time.h>
  #include <setjmp.h>
  
  /* Default EXPORT macro that does nothing (see comment in sq.h): */
  #define EXPORT(returnType) returnType
  
  /* Do not include the entire sq.h file but just those parts needed. */
  #include "sqConfig.h"			/* Configuration options */
  #include "sqVirtualMachine.h"	/*  The virtual machine proxy definition */
  #include "sqPlatformSpecific.h"	/* Platform specific definitions */
  
  #define true 1
  #define false 0
  #define null 0  /* using 'null' because nil is predefined in Think C */
  #ifdef SQUEAK_BUILTIN_PLUGIN
  # undef EXPORT
  # define EXPORT(returnType) static returnType
  #endif
  
  #include "vmCallback.h"
  #include "ia32abi.h"
  #include "sqAssert.h"
  #include "sqMemoryAccess.h"
  
  
  /*** Constants ***/
  #define PrimErrBadArgument 3
  #define PrimErrBadIndex 4
  #define PrimErrBadReceiver 2
  #define PrimErrInappropriate 6
  #define PrimErrNoCMemory 10
  #define PrimErrNoMemory 9
  #define PrimErrNoModification 8
  #define PrimErrNotFound 11
  #if !defined(STACKVM) /* Allow this to be overridden on the compiler command line */
  # define STACKVM 1
  #endif
  
  typedef struct {
  	int	type;
  	int	pad;
  	union {
  								sqIntptr_t valword;
  								struct { int low, high; } valleint64;
  								struct { int high, low; } valbeint64;
  								double valflt64;
  								struct { void *addr; sqIntptr_t size; } valstruct;
  							}	crvrvs;
   } VMCallbackReturnValue;
  
  
  
  /*** Function Prototypes ***/
  EXPORT(const char*) getModuleName(void);
  static sqInt indexlengthinRange(sqInt byteIndex, sqInt length, sqInt rcvr);
  EXPORT(sqInt) isAlien(sqInt anOop);
  EXPORT(sqInt) primAddressField(void);
  EXPORT(sqInt) primAddressFieldPut(void);
  EXPORT(sqInt) primAlienReplace(void);
  EXPORT(sqInt) primAllocateExecutablePage(void);
  EXPORT(sqInt) primBoxedFree(void);
  EXPORT(sqInt) primCallOutDoubleReturn(void);
  EXPORT(sqInt) primCallOutFloatReturn(void);
  EXPORT(sqInt) primCallOutIntegralReturn(void);
  EXPORT(sqInt) primCalloc(void);
  EXPORT(sqInt) primDoubleAt(void);
  EXPORT(sqInt) primDoubleAtPut(void);
  EXPORT(sqInt) primDrainOSEventQueue(void);
  EXPORT(sqInt) primFloatAt(void);
  EXPORT(sqInt) primFloatAtPut(void);
  EXPORT(sqInt) primFree(void);
  EXPORT(sqInt) primInIOProcessEventsFlagAddress(void);
  EXPORT(sqInt) primInLibraryFindSymbol(void);
  EXPORT(sqInt) primLoadLibrary(void);
  EXPORT(sqInt) primMalloc(void);
  EXPORT(sqInt) primReturnAsFromContextThrough(void);
  EXPORT(sqInt) primReturnFromContextThrough(void);
  EXPORT(sqInt) primSignedByteAt(void);
  EXPORT(sqInt) primSignedByteAtPut(void);
  EXPORT(sqInt) primSignedLongAt(void);
  EXPORT(sqInt) primSignedLongAtPut(void);
  EXPORT(sqInt) primSignedLongLongAt(void);
  EXPORT(sqInt) primSignedLongLongAtPut(void);
  EXPORT(sqInt) primSignedShortAt(void);
  EXPORT(sqInt) primSignedShortAtPut(void);
  EXPORT(sqInt) primSignedWordAt(void);
  EXPORT(sqInt) primSignedWordAtPut(void);
  EXPORT(sqInt) primSizeField(void);
  EXPORT(sqInt) primSizeFieldPut(void);
  EXPORT(sqInt) primStrlenFromStartIndex(void);
  EXPORT(sqInt) primStrlenThroughPointerAtIndex(void);
  EXPORT(sqInt) primThunkEntryAddress(void);
  EXPORT(sqInt) primUnsignedByteAt(void);
  EXPORT(sqInt) primUnsignedByteAtPut(void);
  EXPORT(sqInt) primUnsignedLongAt(void);
  EXPORT(sqInt) primUnsignedLongAtPut(void);
  EXPORT(sqInt) primUnsignedLongLongAt(void);
  EXPORT(sqInt) primUnsignedLongLongAtPut(void);
  EXPORT(sqInt) primUnsignedShortAt(void);
  EXPORT(sqInt) primUnsignedShortAtPut(void);
  EXPORT(sqInt) primUnsignedWordAt(void);
  EXPORT(sqInt) primUnsignedWordAtPut(void);
  EXPORT(sqInt) primVarArgsCallOutDoubleReturn(void);
  EXPORT(sqInt) primVarArgsCallOutFloatReturn(void);
  EXPORT(sqInt) primVarArgsCallOutIntegralReturn(void);
  EXPORT(sqInt) setInterpreter(struct VirtualMachine*anInterpreter);
  static sqInt sizeField(sqInt rcvr);
  static sqInt startOfByteData(sqInt rcvr);
  static sqInt startOfData(sqInt rcvr);
  static sqInt startOfDatawithSize(sqInt rcvr, sqInt sizeField);
  
  
  /*** Variables ***/
  
  #if defined(SQUEAK_BUILTIN_PLUGIN)
  
  # define isIntegerObject(oop) ((oop) & 1)
  
  # if SPURVM
  extern sqInt classIndexOf(sqInt);
  #	define LargeNegativeIntegerClassIndex 32
  #	define LargePositiveIntegerClassIndex 33
  #	if BytesPerOop == 4
  #	  define isImmediate(oop) ((oop) & 3)
  #	else
  #	  define isImmediate(oop) ((oop) & 7)
  #	endif
  #	define isKindOfInteger(oop) (isImmediate(oop) ? isIntegerObject(oop) : (unsigned)(classIndexOf(oop) - LargeNegativeIntegerClassIndex) <= 1)
  #	define isLargeIntegerObject(oop) (!isImmediate(oop) && (unsigned)(classIndexOf(oop) - LargeNegativeIntegerClassIndex) <= 1)
  #	define isLargeNegativeIntegerObject(oop) (!isImmediate(oop) && classIndexOf(oop) == LargeNegativeIntegerClassIndex)
  #	define isLargePositiveIntegerObject(oop) (!isImmediate(oop) && classIndexOf(oop) == LargePositiveIntegerClassIndex)
  # endif /* SPURVM */
  #endif /* defined(SQUEAK_BUILTIN_PLUGIN) */
  
  #if !defined(isKindOfInteger)
  # define isLargeNegativeIntegerObject(oop) (fetchClassOf(oop) == classLargeNegativeInteger())
  # define isLargePositiveIntegerObject(oop) (fetchClassOf(oop) == classLargePositiveInteger())
  # define isLargeIntegerObject(oop) (isLargeNegativeIntegerObject(oop) || isLargePositiveIntegerObject(oop))
  # define isKindOfInteger(oop) (isIntegerObject(oop) || isLargeNegativeIntegerObject(oop) || isLargePositiveIntegerObject(oop))
  #endif
  
  #if !defined(SQUEAK_BUILTIN_PLUGIN)
  static sqInt (*byteSizeOf)(sqInt oop);
  static sqInt (*classAlien)(void);
  static sqInt (*classLargeNegativeInteger)(void);
  static sqInt (*classLargePositiveInteger)(void);
  static sqInt (*classSemaphore)(void);
  static sqInt (*failed)(void);
  static sqInt (*falseObject)(void);
  static sqInt (*fetchClassOf)(sqInt oop);
  static void * (*firstIndexableField)(sqInt oop);
  static double (*floatValueOf)(sqInt oop);
  static sqInt * (*getStackPointer)(void);
  static sqInt (*includesBehaviorThatOf)(sqInt aClass, sqInt aSuperclass);
  static sqInt (*instantiateClassindexableSize)(sqInt classPointer, sqInt size);
  static sqInt (*integerObjectOf)(sqInt value);
  static sqInt (*integerValueOf)(sqInt oop);
  static void * (*ioLoadModuleOfLength)(sqInt moduleNameIndex, sqInt moduleLength);
  static void * (*ioLoadSymbolOfLengthFromModule)(sqInt functionNameIndex, sqInt functionLength, sqInt moduleHandle);
  static sqInt (*isArray)(sqInt oop);
  static sqInt (*isBytes)(sqInt oop);
  static sqInt (*isInMemory)(sqInt address);
  static sqInt (*isIntegerObject)(sqInt objectPointer);
  static sqInt (*isNonImmediate)(sqInt anObject);
  #if IMMUTABILITY
  static sqInt (*isOopImmutable)(sqInt oop);
  #endif /* IMMUTABILITY */
  static sqInt (*isWordsOrBytes)(sqInt oop);
  static sqInt (*methodArgumentCount)(void);
  static sqInt (*methodReturnValue)(sqInt oop);
  static sqInt (*pop)(sqInt nItems);
  static sqInt (*popthenPush)(sqInt nItems, sqInt oop);
  static sqInt (*positive32BitIntegerFor)(unsigned int integerValue);
  static usqInt (*positive32BitValueOf)(sqInt oop);
  static sqInt (*positive64BitIntegerFor)(usqLong integerValue);
  static usqLong (*positive64BitValueOf)(sqInt oop);
  static usqIntptr_t (*positiveMachineIntegerValueOf)(sqInt oop);
  static sqInt (*primitiveFailFor)(sqInt reasonCode);
  static sqInt (*pushFloat)(double  f);
  static sqInt (*returnAsThroughCallbackContext)(sqInt returnTypeOop, VMCallbackContext *vmCallbackContext, sqInt callbackMethodContext);
  static sqInt (*signalNoResume)(sqInt aSemaphore);
  static sqInt (*signed32BitIntegerFor)(sqInt integerValue);
  static int (*signed32BitValueOf)(sqInt oop);
  static sqInt (*signed64BitIntegerFor)(sqLong integerValue);
  static sqLong (*signed64BitValueOf)(sqInt oop);
  static sqIntptr_t (*signedMachineIntegerValueOf)(sqInt oop);
  static sqInt (*stSizeOf)(sqInt oop);
  static sqInt (*stackIntegerValue)(sqInt offset);
  static sqInt (*stackObjectValue)(sqInt offset);
  static usqIntptr_t (*stackPositiveMachineIntegerValue)(sqInt offset);
  static sqInt (*stackValue)(sqInt offset);
  static sqInt (*trueObject)(void);
  #else /* !defined(SQUEAK_BUILTIN_PLUGIN) */
  extern sqInt byteSizeOf(sqInt oop);
  extern sqInt classAlien(void);
  extern sqInt classLargeNegativeInteger(void);
  extern sqInt classLargePositiveInteger(void);
  extern sqInt classSemaphore(void);
  extern sqInt failed(void);
  extern sqInt falseObject(void);
  extern sqInt fetchClassOf(sqInt oop);
  extern void * firstIndexableField(sqInt oop);
  extern double floatValueOf(sqInt oop);
  extern sqInt * getStackPointer(void);
  extern sqInt includesBehaviorThatOf(sqInt aClass, sqInt aSuperclass);
  extern sqInt instantiateClassindexableSize(sqInt classPointer, sqInt size);
  extern sqInt integerObjectOf(sqInt value);
  extern sqInt integerValueOf(sqInt oop);
  extern void * ioLoadModuleOfLength(sqInt moduleNameIndex, sqInt moduleLength);
  extern void * ioLoadSymbolOfLengthFromModule(sqInt functionNameIndex, sqInt functionLength, sqInt moduleHandle);
  extern sqInt isArray(sqInt oop);
  extern sqInt isBytes(sqInt oop);
  extern sqInt isInMemory(sqInt address);
  #if !defined(isIntegerObject)
  extern sqInt isIntegerObject(sqInt objectPointer);
  #endif
  extern sqInt isNonImmediate(sqInt anObject);
  #if IMMUTABILITY
  #if IMMUTABILITY
  extern sqInt isOopImmutable(sqInt oop);
  #endif /* IMMUTABILITY */
  #else
  # define isOopImmutable(oop) 0
  #endif
  extern sqInt isWordsOrBytes(sqInt oop);
  extern sqInt methodArgumentCount(void);
  extern sqInt methodReturnValue(sqInt oop);
  extern sqInt pop(sqInt nItems);
  extern sqInt popthenPush(sqInt nItems, sqInt oop);
  extern sqInt positive32BitIntegerFor(unsigned int integerValue);
  extern usqInt positive32BitValueOf(sqInt oop);
  extern sqInt positive64BitIntegerFor(usqLong integerValue);
  extern usqLong positive64BitValueOf(sqInt oop);
  extern usqIntptr_t positiveMachineIntegerValueOf(sqInt oop);
  extern sqInt primitiveFailFor(sqInt reasonCode);
  extern sqInt pushFloat(double  f);
  extern sqInt returnAsThroughCallbackContext(sqInt returnTypeOop, VMCallbackContext *vmCallbackContext, sqInt callbackMethodContext);
  extern sqInt signalNoResume(sqInt aSemaphore);
  extern sqInt signed32BitIntegerFor(sqInt integerValue);
  extern int signed32BitValueOf(sqInt oop);
  extern sqInt signed64BitIntegerFor(sqLong integerValue);
  extern sqLong signed64BitValueOf(sqInt oop);
  extern sqIntptr_t signedMachineIntegerValueOf(sqInt oop);
  extern sqInt stSizeOf(sqInt oop);
  extern sqInt stackIntegerValue(sqInt offset);
  extern sqInt stackObjectValue(sqInt offset);
  extern usqIntptr_t stackPositiveMachineIntegerValue(sqInt offset);
  extern sqInt stackValue(sqInt offset);
  extern sqInt trueObject(void);
  extern
  #endif
  struct VirtualMachine* interpreterProxy;
  static const char *moduleName =
  #ifdef SQUEAK_BUILTIN_PLUGIN
  	"IA32ABI VMMaker.oscog-eem.2397 (i)"
  #else
  	"IA32ABI VMMaker.oscog-eem.2397 (e)"
  #endif
  ;
  
  
  
  /*	Note: This is hardcoded so it can be run from Squeak.
  	The module name is used for validating a module *after*
  	it is loaded to check if it does really contain the module
  	we're thinking it contains. This is important! */
  
  	/* InterpreterPlugin>>#getModuleName */
  EXPORT(const char*)
  getModuleName(void)
  {
  	return moduleName;
  }
  
  
  /*	Answer if the indices byteIndex to byteIndex + length - 1 are valid
  	zero-relative indices into the rcvr.
  	Beware! There be dragons here. The form below (byteIndex <= (dataSize abs
  	- length)) is used
  	because byteIndex + length could overflow, whereas (dataSize abs - length)
  	can't. We *don't* use the
  	obvious optimization
  	^dataSize = 0 or: [byteIndex asUnsignedInteger <= (dataSize abs - length)]
  	because with C's Usual Arithmetic Conversions
  	5. Otherwise, both operands are converted to the unsigned integer type
  	corresponding to the type of the operand with signed integer type.
  	means that the comparison will be unsigned, and if length > dataSize abs
  	then dataSize abs - length is large and positive. */
  
  	/* IA32ABIPlugin>>#index:length:inRange: */
  static sqInt
  indexlengthinRange(sqInt byteIndex, sqInt length, sqInt rcvr)
  {
      sqInt dataSize;
  
  	dataSize = longAt(rcvr + BaseHeaderSize);
  	return (dataSize == 0)
  	 || ((byteIndex >= 0)
  	 && (byteIndex <= ((SQABS(dataSize)) - length)));
  }
  
  	/* IA32ABIPlugin>>#isAlien: */
  EXPORT(sqInt)
  isAlien(sqInt anOop)
  {
  	return includesBehaviorThatOf(fetchClassOf(anOop), classAlien());
  }
  
  
  /*	Answer the unsigned 32-bit (or 64-bit) integer comprising the address
  	field (the second 32-bit or 64-bit field).
   */
  /*	<Alien> primAddressField ^<Integer>
  	<primitive: 'primAddressField' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primAddressField */
  EXPORT(sqInt)
  primAddressField(void)
  {
      sqInt rcvr;
      sqInt value;
      sqInt valueOop;
  
  	rcvr = stackValue(0);
  	value = longAt((rcvr + BaseHeaderSize) + BytesPerOop);
  	/* begin positiveMachineIntegerFor: */
  	valueOop = (BytesPerWord == 8
  		? positive64BitIntegerFor(value)
  		: positive32BitIntegerFor(value));
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Store an unsigned integer into the size field (the second 32/64 bit field;
  	little endian).
   */
  /*	<Alien> addressFieldPut: value <Integer> ^<Integer>
  	<primitive: 'primAddressFieldPut' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primAddressFieldPut */
  EXPORT(sqInt)
  primAddressFieldPut(void)
  {
      sqInt rcvr;
      sqInt value;
      sqInt valueOop;
  
  	valueOop = stackValue(0);
  	rcvr = stackValue(1);
  	value = positiveMachineIntegerValueOf(valueOop);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (isOopImmutable(rcvr)) {
  		return primitiveFailFor(PrimErrNoModification);
  	}
  	longAtput((rcvr + BaseHeaderSize) + BytesPerOop, value);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Copy some number of bytes from some source object starting at the index
  	into the receiver destination object from startIndex to stopIndex. The
  	source and destination may be Aliens or byte-indexable objects. The
  	primitive wll have
  	either of the following signatures:
  	<Alien | indexableByteSubclass | indexableWordSubclass>
  	primReplaceFrom: start <Integer>
  	to: stop <Integer>
  	with: replacement <Alien | indexableByteSubclass | indexableWordSubclass |
  	Integer> startingAt: repStart <Integer> ^<self>
  	<primitive: 'primitiveAlienReplace' error: errorCode module: 'IA32ABI'>
  	<Anywhere>
  	primReplaceIn: dest <Alien | indexableByteSubclass |
  	indexableWordSubclass> from: start <Integer>
  	to: stop <Integer>
  	with: replacement <Alien | indexableByteSubclass | indexableWordSubclass |
  	Integer> startingAt: repStart <Integer> ^<self>
  	<primitive: 'primitiveAlienReplace' error: errorCode module: 'IA32ABI'>
  	 */
  
  	/* IA32ABIPlugin>>#primAlienReplace */
  EXPORT(sqInt)
  primAlienReplace(void)
  {
      sqInt array;
      sqInt count;
      sqInt dest;
      sqInt repl;
      sqInt replStart;
      sqInt src;
      sqInt start;
      sqInt stop;
      sqInt totalLength;
  
  	array = stackValue(4);
  	start = stackIntegerValue(3);
  	stop = stackIntegerValue(2);
  	repl = stackValue(1);
  	replStart = stackIntegerValue(0);
  	if ((failed())
  	 || (!(isWordsOrBytes(array)))) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (includesBehaviorThatOf(fetchClassOf(array), classAlien())) {
  		totalLength = longAt(array + BaseHeaderSize);
  		dest = (((totalLength > 0
  	? (array + BaseHeaderSize) + BytesPerOop
  	: longAt((array + BaseHeaderSize) + BytesPerOop))) + start) - 1;
  		if (totalLength == 0) {
  
  			/* no bounds checks for zero-sized (pointer) Aliens */
  			totalLength = stop;
  		}
  		else {
  			totalLength = SQABS(totalLength);
  		}
  	}
  	else {
  		totalLength = byteSizeOf(array);
  		dest = ((array + BaseHeaderSize) + start) - 1;
  	}
  	if (!((start >= 1)
  		 && (((start - 1) <= stop)
  		 && (stop <= totalLength)))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (isKindOfInteger(repl)) {
  		src = ((positiveMachineIntegerValueOf(repl)) + replStart) - 1;
  		if (failed()) {
  			return primitiveFailFor(PrimErrBadArgument);
  		}
  	}
  	else {
  		if (includesBehaviorThatOf(fetchClassOf(repl), classAlien())) {
  			totalLength = longAt(repl + BaseHeaderSize);
  			src = (((totalLength > 0
  	? (repl + BaseHeaderSize) + BytesPerOop
  	: longAt((repl + BaseHeaderSize) + BytesPerOop))) + replStart) - 1;
  			if (totalLength == 0) {
  
  				/* no bounds checks for zero-sized (pointer) Aliens */
  				totalLength = (stop - start) + replStart;
  			}
  			else {
  				totalLength = SQABS(totalLength);
  			}
  		}
  		else {
  			if (!(isWordsOrBytes(repl))) {
  				return primitiveFailFor(PrimErrBadArgument);
  			}
  			totalLength = byteSizeOf(repl);
  			src = ((repl + BaseHeaderSize) + replStart) - 1;
  		}
  		if (!((replStart >= 1)
  			 && (((stop - start) + replStart) <= totalLength))) {
  			return primitiveFailFor(PrimErrBadIndex);
  		}
  	}
  	if (isOopImmutable(array)) {
  		return primitiveFailFor(PrimErrNoModification);
  	}
  	count = (stop - start) + 1;
  	memmove(((void *)dest), ((void *)src), count);
  	pop(methodArgumentCount());
  	return 0;
  }
  
  
  /*	Answer an Alien for an executable page; for thunks */
  /*	primAllocateExecutablePage ^<Alien>
  	<primitive: 'primAllocateExecutablePage' error: errorCode module:
  	'IA32ABI'> 
   */
  
  	/* IA32ABIPlugin>>#primAllocateExecutablePage */
  EXPORT(sqInt)
  primAllocateExecutablePage(void)
  {
      sqInt alien;
      sqIntptr_t byteSize;
      void *mem;
      sqIntptr_t *ptr;
  
  	mem = allocateExecutablePage(&byteSize);
  	if (mem == 0) {
  		return primitiveFailFor(PrimErrNoCMemory);
  	}
  	alien = instantiateClassindexableSize(classAlien(), 2 * BytesPerOop);
  	if (failed()) {
  		return primitiveFailFor(PrimErrNoMemory);
  	}
  	ptr = firstIndexableField(alien);
  	ptr[0] = (0 - byteSize);
  	ptr[1] = (((sqIntptr_t) mem));
  	methodReturnValue(alien);
  	return 0;
  }
  
  
  /*	Free the memory referenced by the receiver, an Alien. */
  /*	proxy <Alien> primFree ^<Alien>
  	<primitive: 'primBoxedFree' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primBoxedFree */
  EXPORT(sqInt)
  primBoxedFree(void)
  {
      sqIntptr_t addr;
      sqIntptr_t *ptr;
      sqInt rcvr;
      sqIntptr_t sizeField;
  
  	rcvr = stackValue(0);
  	if (!((byteSizeOf(rcvr)) >= (2 * BytesPerOop))) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	ptr = firstIndexableField(rcvr);
  	sizeField = ptr[0];
  
  	/* Don't you dare to free Squeak's memory! */
  	addr = ptr[1];
  	if ((sizeField >= 0)
  	 || ((addr == 0)
  	 || (isInMemory(addr)))) {
  		return primitiveFailFor(PrimErrInappropriate);
  	}
  	free((void *)addr);
  	ptr[0] = 0;
  	ptr[1] = 0;
  	return 0;
  }
  
  
  /*	Call a foreign function that answers a double-precision floating-point
  	result in %f0
  	according to IA32-ish ABI rules. The primitive will have a signature of
  	the form
  	functionAddress <Alien> primFFICallResult: result <Alien|Object> with:
  	firstArg <Alien | Integer> ... with: lastArg <Alien | Integer> ^<Alien>
  	<primitive: 'primCallOutDoubleReturn' error: errorCode module: 'IA32ABI'>.
  	Answer result. If result is an Alien the value answered by the call will
  	be assigned to result.
   */
  
  	/* IA32ABIPlugin>>#primCallOutDoubleReturn */
  EXPORT(sqInt)
  primCallOutDoubleReturn(void)
  {
      sqInt errCode;
      sqInt mac;
      sqInt result;
  
  	mac = methodArgumentCount();
  	
  #  if STACKVM
  
  	/* In the STACKVM stacks grow down */
  
  	/* ptr to 0th arg */
  	/* nargs negated to imply stack direction */
  	/* funcOffset */
  	/* resultOffset */
  	errCode = callIA32DoubleReturn(((getStackPointer()) + mac) - 2, 1 - mac, mac, mac - 1);
  #  else /* STACKVM */
  
  	/* ptr to 0th arg */
  	/* nargs */
  	/* funcOffset */
  	/* resultOffset */
  	errCode = callIA32DoubleReturn(((getStackPointer()) - mac) + 2, mac - 1, mac, mac - 1);
  #  endif /* STACKVM */
  	if (errCode != 0) {
  		return primitiveFailFor(errCode);
  	}
  	result = stackValue(mac - 1);
  	popthenPush(mac + 1, result);
  	return 0;
  }
  
  
  /*	Call a foreign function that answers a single-precision floating-point
  	result in %f0
  	according to IA32-ish ABI rules. The primitive will have a signature of
  	the form
  	functionAddress <Alien> primFFICallResult: result <Alien|Object> with:
  	firstArg <Alien | Integer> ... with: lastArg <Alien | Integer> ^<Alien>
  	<primitive: 'primCallOutFloatReturn' error: errorCode module: 'IA32ABI'>.
  	Answer result. If result is an Alien the value answered by the call will
  	be assigned to result.
   */
  
  	/* IA32ABIPlugin>>#primCallOutFloatReturn */
  EXPORT(sqInt)
  primCallOutFloatReturn(void)
  {
      sqInt errCode;
      sqInt mac;
      sqInt result;
  
  	mac = methodArgumentCount();
  	
  #  if STACKVM
  
  	/* In the STACKVM stacks grow down */
  
  	/* ptr to 0th arg */
  	/* nargs negated to imply stack direction */
  	/* funcOffset */
  	/* resultOffset */
  	errCode = callIA32FloatReturn(((getStackPointer()) + mac) - 2, 1 - mac, mac, mac - 1);
  #  else /* STACKVM */
  
  	/* ptr to 0th arg */
  	/* nargs */
  	/* funcOffset */
  	/* resultOffset */
  	errCode = callIA32FloatReturn(((getStackPointer()) - mac) + 2, mac - 1, mac, mac - 1);
  #  endif /* STACKVM */
  	if (errCode != 0) {
  		return primitiveFailFor(errCode);
  	}
  	result = stackValue(mac - 1);
  	popthenPush(mac + 1, result);
  	return 0;
  }
  
  
  /*	Call a foreign function that answers an integral result in %eax (and
  	possibly %edx)
  	according to IA32-ish ABI rules. The primitive will have a signature of
  	the form
  	functionAddress <Alien> primFFICallResult: result <Alien|Object> with:
  	firstArg <Alien | Integer> ... with: lastArg <Alien | Integer> ^<Alien>
  	<primitive: 'primCallOutIntegralReturn' error: errorCode module:
  	'IA32ABI'>. Answer result. If result is an Alien the value answered by the
  	call will be assigned to result.
   */
  
  	/* IA32ABIPlugin>>#primCallOutIntegralReturn */
  EXPORT(sqInt)
  primCallOutIntegralReturn(void)
  {
      sqInt errCode;
      sqInt mac;
      sqInt result;
  
  	mac = methodArgumentCount();
  	
  #  if STACKVM
  
  	/* In the STACKVM stacks grow down */
  
  	/* ptr to 0th arg */
  	/* nargs negated to imply stack direction */
  	/* funcOffset */
  	/* resultOffset */
  	errCode = callIA32IntegralReturn(((getStackPointer()) + mac) - 2, 1 - mac, mac, mac - 1);
  #  else /* STACKVM */
  
  	/* ptr to 0th arg */
  	/* nargs */
  	/* funcOffset */
  	/* resultOffset */
  	errCode = callIA32IntegralReturn(((getStackPointer()) - mac) + 2, mac - 1, mac, mac - 1);
  #  endif /* STACKVM */
  	if (errCode != 0) {
  		return primitiveFailFor(errCode);
  	}
  	result = stackValue(mac - 1);
  	popthenPush(mac + 1, result);
  	return 0;
  }
  
  
  /*	calloc (malloc + zero-fill) arg bytes. */
  /*	primCalloc: byteSize <Integer> ^<Integer>
  	<primitive: 'primCalloc' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primCalloc */
  EXPORT(sqInt)
  primCalloc(void)
  {
      usqInt addr;
      sqInt byteSize;
  
  	byteSize = stackIntegerValue(0);
  	if ((failed())
  	 || (byteSize <= 0)) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	addr = ((usqInt)(calloc(1, byteSize)));
  	if (addr == 0) {
  		return primitiveFailFor(PrimErrNoCMemory);
  	}
  	methodReturnValue((BytesPerWord == 8
  		? positive64BitIntegerFor(addr)
  		: positive32BitIntegerFor(addr)));
  	return 0;
  }
  
  
  /*	Answer the 64-bit double starting at the given byte offset (little
  	endian). 
   */
  /*	<Alien> doubleAt: index <Integer> ^<Float>
  	<primitive: 'primDoubleAt' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primDoubleAt */
  EXPORT(sqInt)
  primDoubleAt(void)
  {
      sqInt addr;
      sqInt byteOffset;
      double floatValue;
      sqInt rcvr;
      sqInt startAddr;
  
  	byteOffset = (stackPositiveMachineIntegerValue(0)) - 1;
  	rcvr = stackObjectValue(1);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 8, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	memcpy((&floatValue), addr, sizeof(floatValue));
  	pop(2);
  	return pushFloat(floatValue);
  }
  
  
  /*	Store a double into 64 bits starting at the given byte offset (little
  	endian). 
   */
  /*	<Alien> doubleAt: index <Integer> put: value <Float | Integer> ^<Float |
  	Integer> <primitive: 'primDoubleAtPut' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primDoubleAtPut */
  EXPORT(sqInt)
  primDoubleAtPut(void)
  {
      sqInt addr;
      sqInt byteOffset;
      double floatValue;
      sqInt rcvr;
      sqInt startAddr;
      sqInt valueOop;
  
  	valueOop = stackValue(0);
  	if (isIntegerObject(valueOop)) {
  		floatValue = ((double) (integerValueOf(valueOop)));
  	}
  	else {
  		floatValue = ((double) (floatValueOf(valueOop)));
  	}
  	byteOffset = (stackPositiveMachineIntegerValue(1)) - 1;
  	rcvr = stackObjectValue(2);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 8, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (isOopImmutable(rcvr)) {
  		return primitiveFailFor(PrimErrNoModification);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	memcpy(addr, (&floatValue), sizeof(floatValue));
  	methodReturnValue(valueOop);
  	return 0;
  }
  
  	/* IA32ABIPlugin>>#primDrainOSEventQueue */
  EXPORT(sqInt)
  primDrainOSEventQueue(void)
  {
  	
  #  if NewspeakVM
  	ioDrainEventQueue();
  #  endif /* NewspeakVM */
  	return 0;
  }
  
  
  /*	Answer the 32-bit float starting at the given byte offset (little endian). */
  /*	<Alien> floatAt: index <Integer> ^<Float>
  	<primitive: 'primFloatAt' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primFloatAt */
  EXPORT(sqInt)
  primFloatAt(void)
  {
      sqInt addr;
      sqInt byteOffset;
      float floatValue;
      sqInt rcvr;
      sqInt startAddr;
  
  	byteOffset = (stackPositiveMachineIntegerValue(0)) - 1;
  	rcvr = stackObjectValue(1);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 4, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	memcpy((&floatValue), addr, sizeof(floatValue));
  	pop(2);
  	return pushFloat(floatValue);
  }
  
  
  /*	Store a float into 32 bits starting at the given byte offset (little
  	endian). 
   */
  /*	<Alien> floatAt: index <Integer> put: value <Float | Integer> ^<Float |
  	Integer> <primitive: 'primFloatAtPut' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primFloatAtPut */
  EXPORT(sqInt)
  primFloatAtPut(void)
  {
      sqInt addr;
      sqInt byteOffset;
      float floatValue;
      sqInt rcvr;
      sqInt startAddr;
      sqInt valueOop;
  
  	valueOop = stackValue(0);
  	if (isIntegerObject(valueOop)) {
  		floatValue = ((double) (integerValueOf(valueOop)));
  	}
  	else {
  		floatValue = ((double) (floatValueOf(valueOop)));
  	}
  	byteOffset = (stackPositiveMachineIntegerValue(1)) - 1;
  	rcvr = stackObjectValue(2);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 4, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (isOopImmutable(rcvr)) {
  		return primitiveFailFor(PrimErrNoModification);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	memcpy(addr, (&floatValue), sizeof(floatValue));
  	methodReturnValue(valueOop);
  	return 0;
  }
  
  
  /*	Free the memory referenced by the argument, an integer. */
  /*	<Anywhere> primFree: address <Integer>
  	<primitive: 'primFree' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primFree */
  EXPORT(sqInt)
  primFree(void)
  {
      sqInt addr;
  
  	addr = stackPositiveMachineIntegerValue(0);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if ((addr == 0)
  	 || (isInMemory(addr))) {
  		return primitiveFailFor(PrimErrInappropriate);
  	}
  	free((void *)addr);
  	pop(1);
  	return 0;
  }
  
  
  /*	Answer the address of the int inIOProcessEvents flag. This can be used to
  	disable invocation of ioProcessEvents and is for backward-compatibility.
  	Please use the core VM primitiveEventProcessingControl in new code. */
  
  	/* IA32ABIPlugin>>#primInIOProcessEventsFlagAddress */
  EXPORT(sqInt)
  primInIOProcessEventsFlagAddress(void)
  {
      extern int inIOProcessEvents;
  
  	methodReturnValue((BytesPerWord == 8
  		? positive64BitIntegerFor(((usqInt)((&inIOProcessEvents))))
  		: positive32BitIntegerFor(((usqInt)((&inIOProcessEvents))))));
  	return 0;
  }
  
  
  /*	Attempt to find the address of a symbol in a loaded library.
  	The primitive can have a signature either of the form:
  	<Anywhere> primInLibrary: libraryHandle <Alien> findSymbol: symbolName
  	<String> ^<Integer>
  	<primitive: 'primInLibraryFindSymbol' error: errorCode module: 'IA32ABI'>
  	or:
  	libraryHandle <Alien> primFindSymbol: symbolName <String> ^<Integer>
  	<primitive: 'primInLibraryFindSymbol' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primInLibraryFindSymbol */
  EXPORT(sqInt)
  primInLibraryFindSymbol(void)
  {
      void *address;
      sqInt functionName;
      sqInt libraryProxy;
  
  	functionName = stackValue(0);
  	libraryProxy = stackValue(1);
  	if (!((includesBehaviorThatOf(fetchClassOf(libraryProxy), classAlien()))
  		 && (((byteSizeOf(libraryProxy)) >= (2 * BytesPerOop))
  		 && (isBytes(functionName))))) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	address = ioLoadSymbolOfLengthFromModule(((sqInt) (firstIndexableField(functionName))), byteSizeOf(functionName), longAt((libraryProxy + BaseHeaderSize) + BytesPerOop));
  	if ((failed())
  	 || (address == 0)) {
  		return primitiveFailFor(PrimErrNotFound);
  	}
  	methodReturnValue((BytesPerWord == 8
  		? positive64BitIntegerFor(((usqInt)address))
  		: positive32BitIntegerFor(((usqInt)address))));
  	return 0;
  }
  
  
  /*	Attempt to load a library of the given name. The primitive will have a
  	signature of the form:
  	<Anywhere> primLoadLibrary: libraryName <String> ^<Integer>
  	<primitive: 'primLoadLibrary' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primLoadLibrary */
  EXPORT(sqInt)
  primLoadLibrary(void)
  {
      void *libraryHandle;
      sqInt libraryName;
  
  	libraryName = stackValue(0);
  	if (!(isBytes(libraryName))) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	libraryHandle = ioLoadModuleOfLength(((sqInt) (firstIndexableField(libraryName))), byteSizeOf(libraryName));
  	if (libraryHandle == 0) {
  		return primitiveFailFor(PrimErrNotFound);
  	}
  	methodReturnValue((BytesPerWord == 8
  		? positive64BitIntegerFor(((usqInt)libraryHandle))
  		: positive32BitIntegerFor(((usqInt)libraryHandle))));
  	return 0;
  }
  
  
  /*	Malloc arg bytes. */
  /*	primMalloc: byteSize <Integer> <^Integer>
  	<primitive: 'primMalloc' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primMalloc */
  EXPORT(sqInt)
  primMalloc(void)
  {
      usqInt addr;
      sqInt byteSize;
  
  	byteSize = stackIntegerValue(0);
  	if ((failed())
  	 || (byteSize <= 0)) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	addr = ((usqInt)(malloc(byteSize)));
  	if (addr == 0) {
  		return primitiveFailFor(PrimErrNoCMemory);
  	}
  	methodReturnValue((BytesPerWord == 8
  		? positive64BitIntegerFor(addr)
  		: positive32BitIntegerFor(addr)));
  	return 0;
  }
  
  
  /*	Return a result from a callback to the callback's callee. The primitive
  	has a signature of either of the forms:
  	result <VMCallbackContext32/64>
  	primReturnAs: returnTypeCode <Integer>
  	FromContext: callbackContext <Context>
  	result <VMCallbackContext32/64>
  	primSignal: aSemaphore <Semaphore>
  	andReturnAs: returnTypeCode <Integer>
  	FromContext: callbackContext <Context>
  	<primitive: 'primReturnAsFromContextThrough' error: errorCode module:
  	'IA32ABI'>. If of the second form answer false if this is not the most
  	recent callback, and signal aSemaphore
  	if it is, so as to implement LIFO ordering of callbacks. */
  
  	/* IA32ABIPlugin>>#primReturnAsFromContextThrough */
  EXPORT(sqInt)
  primReturnAsFromContextThrough(void)
  {
      int isMostRecent;
      VMCallbackContext *vmCallbackContext;
  
  	if ((methodArgumentCount()) == 3) {
  		assert(isNonImmediate(stackValue(3)));
  		assert((fetchClassOf(stackValue(2))) == (classSemaphore()));
  		assert(isIntegerObject(stackValue(1)));
  		assert(isNonImmediate(stackValue(0)));
  		vmCallbackContext = ((VMCallbackContext *) (startOfData(stackValue(3))));
  		isMostRecent = vmCallbackContext == (getMostRecentCallbackContext());
  		if (!isMostRecent) {
  			return methodReturnValue(falseObject());
  		}
  		if (!((fetchClassOf(stackValue(2))) == (classSemaphore()))) {
  			return primitiveFailFor(PrimErrBadArgument);
  		}
  		while (!(signalNoResume(stackValue(2)))) {
  		}
  	}
  	else {
  		assert((methodArgumentCount()) == 2);
  		assert(isNonImmediate(stackValue(2)));
  		assert(isIntegerObject(stackValue(1)));
  		assert(isNonImmediate(stackValue(0)));
  		vmCallbackContext = ((VMCallbackContext *) (startOfData(stackValue(2))));
  	}
  	if (!(returnAsThroughCallbackContext(stackValue(1), vmCallbackContext, stackValue(0)))) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	return 0;
  }
  
  
  /*	Return a result from a callback to the callback's callee. The primitive
  	has a signature of either of the forms:
  	result <FFICallbackResult> primReturnFromContext: callbackContext
  	<MethodContext> through: jmpBuf <Integer>
  	result <FFICallbackResult> primSignal: aSemaphore <Semaphore>
  	andReturnFromContext: callbackContext <MethodContext> through: jmpBuf
  	<Integer> <primitive: 'primReturnFromContextThrough' error: errorCode
  	module: 'IA32ABI'>.
  	If of the second form answer true if this is not the most recent callback,
  	and signal aSemaphore
  	if it is, so as to implement LIFO ordering of callbacks. */
  
  	/* IA32ABIPlugin>>#primReturnFromContextThrough */
  EXPORT(sqInt)
  primReturnFromContextThrough(void)
  {
      int isMostRecent;
      sqInt mac;
      VMCallbackContext *vmCallbackContext;
      VMCallbackReturnValue *vmCallbackReturnValue;
  
  	vmCallbackContext = ((VMCallbackContext *) (positiveMachineIntegerValueOf(stackValue(0))));
  	if ((failed())
  	 || (vmCallbackContext == 0)) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (((mac = methodArgumentCount())) == 3) {
  		isMostRecent = vmCallbackContext == (getMostRecentCallbackContext());
  		if (!isMostRecent) {
  			methodReturnValue(trueObject());
  			return null;
  		}
  		if (!((fetchClassOf(stackValue(2))) == (classSemaphore()))) {
  			return primitiveFailFor(PrimErrBadArgument);
  		}
  		while (!(signalNoResume(stackValue(2)))) {
  		}
  	}
  	vmCallbackReturnValue = ((VMCallbackReturnValue *) (startOfData(stackValue(mac))));
  	memcpy((&((vmCallbackContext->rvs))), (&((vmCallbackReturnValue->crvrvs))), sizeof((vmCallbackContext->rvs)));
  	if (!(returnAsThroughCallbackContext(integerObjectOf(((vmCallbackReturnValue->type)) + 1), vmCallbackContext, stackValue(1)))) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	return 0;
  }
  
  
  /*	Answer the signed 8-bit integer starting at the given byte offset (little
  	endian). 
   */
  /*	<Alien> unsignedByteAt: index <Integer> ^<Integer>
  	<primitive: 'primSignedByteAt' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primSignedByteAt */
  EXPORT(sqInt)
  primSignedByteAt(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      signed char  value;
      sqInt valueOop;
  
  	byteOffset = (stackPositiveMachineIntegerValue(0)) - 1;
  	rcvr = stackObjectValue(1);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 1, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	value = byteAt(addr);
  	valueOop = signed32BitIntegerFor(value);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Store a signed integer into 8 bits starting at the given byte offset
  	(little endian).
   */
  /*	<Alien> signedByteAt: index <Integer> put: value <Integer> ^<Integer>
  	<primitive: 'primSignedByteAtPut' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primSignedByteAtPut */
  EXPORT(sqInt)
  primSignedByteAtPut(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      sqInt value;
      sqInt valueOop;
  
  	valueOop = stackValue(0);
  	byteOffset = (stackPositiveMachineIntegerValue(1)) - 1;
  	rcvr = stackObjectValue(2);
  	value = signed32BitValueOf(valueOop);
  	if ((failed())
  	 || ((value < -128)
  	 || (value > 0x7F))) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 1, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (isOopImmutable(rcvr)) {
  		return primitiveFailFor(PrimErrNoModification);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	byteAtput(addr, value);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Answer the signed 32-bit integer starting at the given byte offset (little
  	endian). 
   */
  /*	<Alien> signedLongAt: index <Integer> ^<Integer>
  	<primitive: 'primSignedLongAt' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primSignedLongAt */
  EXPORT(sqInt)
  primSignedLongAt(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      int value;
      sqInt valueOop;
  
  	byteOffset = (stackPositiveMachineIntegerValue(0)) - 1;
  	rcvr = stackObjectValue(1);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 4, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	value = long32At(addr);
  	valueOop = signed32BitIntegerFor(value);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Store a signed integer into 32 bits starting at the given byte offset
  	(little endian).
   */
  /*	<Alien> signedLongAt: index <Integer> put: value <Integer> ^<Integer>
  	<primitive: 'primSignedLongAtPut' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primSignedLongAtPut */
  EXPORT(sqInt)
  primSignedLongAtPut(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      sqInt value;
      sqInt valueOop;
  
  	valueOop = stackValue(0);
  	byteOffset = (stackPositiveMachineIntegerValue(1)) - 1;
  	rcvr = stackObjectValue(2);
  	value = signed32BitValueOf(valueOop);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 4, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (isOopImmutable(rcvr)) {
  		return primitiveFailFor(PrimErrNoModification);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	long32Atput(addr, value);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Answer the signed 64-bit integer starting at the given byte offset (little
  	endian). 
   */
  /*	<Alien> signedLongLongAt: index <Integer> ^<Integer>
  	<primitive: 'primSignedLongLongAt' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primSignedLongLongAt */
  EXPORT(sqInt)
  primSignedLongLongAt(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      long long signedlonglongvalue;
      long long *signedlonglongvaluePtr;
      sqInt startAddr;
      sqInt valueOop;
  
  	signedlonglongvaluePtr = 0;
  	byteOffset = (stackPositiveMachineIntegerValue(0)) - 1;
  	rcvr = stackObjectValue(1);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 8, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	signedlonglongvaluePtr = ((long long*) addr);
  	signedlonglongvalue = *signedlonglongvaluePtr;
  	valueOop = signed64BitIntegerFor(signedlonglongvalue);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Store a signed integer into 64 bits starting at the given byte offset
  	(little endian).
   */
  /*	<Alien> signedLongLongAt: index <Integer> put: value <Integer> ^<Integer>
  	<primitive: 'primSignedLongLongAtPut' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primSignedLongLongAtPut */
  EXPORT(sqInt)
  primSignedLongLongAtPut(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      long long signedlonglongvalue;
      long long *signedlonglongvaluePtr;
      sqInt startAddr;
      sqInt valueOop;
  
  	signedlonglongvaluePtr = 0;
  	valueOop = stackValue(0);
  	byteOffset = (stackPositiveMachineIntegerValue(1)) - 1;
  	rcvr = stackObjectValue(2);
  	signedlonglongvalue = signed64BitValueOf(valueOop);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 8, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (isOopImmutable(rcvr)) {
  		return primitiveFailFor(PrimErrNoModification);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	signedlonglongvaluePtr = ((long long*) addr);
  	*signedlonglongvaluePtr = signedlonglongvalue;
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Answer the signed 32-bit integer starting at the given byte offset (little
  	endian). 
   */
  /*	<Alien> signedShortAt: index <Integer> ^<Integer>
  	<primitive: 'primSignedShortAt' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primSignedShortAt */
  EXPORT(sqInt)
  primSignedShortAt(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      short  value;
      sqInt valueOop;
  
  	byteOffset = (stackPositiveMachineIntegerValue(0)) - 1;
  	rcvr = stackObjectValue(1);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 2, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	value = shortAt(addr);
  	valueOop = signed32BitIntegerFor(value);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Store a signed integer into 16 bits starting at the given byte offset
  	(little endian).
   */
  /*	<Alien> signedShortAt: index <Integer> put: value <Integer> ^<Integer>
  	<primitive: 'primSignedShortAtPut' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primSignedShortAtPut */
  EXPORT(sqInt)
  primSignedShortAtPut(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      sqInt value;
      sqInt valueOop;
  
  	valueOop = stackValue(0);
  	byteOffset = (stackPositiveMachineIntegerValue(1)) - 1;
  	rcvr = stackObjectValue(2);
  	value = signed32BitValueOf(valueOop);
  	if ((failed())
  	 || ((value < -32768)
  	 || (value > 0x7FFF))) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 2, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (isOopImmutable(rcvr)) {
  		return primitiveFailFor(PrimErrNoModification);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	shortAtput(addr, value);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Answer the signed word starting at the given byte offset (little endian). */
  /*	<Alien> signedWordAt: index <Integer> ^<Integer>
  	<primitive: 'primSignedWordAt' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primSignedWordAt */
  EXPORT(sqInt)
  primSignedWordAt(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      sqInt value;
      sqInt valueOop;
  
  	byteOffset = (stackPositiveMachineIntegerValue(0)) - 1;
  	rcvr = stackObjectValue(1);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, BytesPerOop, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	value = longAt(addr);
  	valueOop = signedMachineIntegerValueOf(value);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Store a signed integer into the word starting at the given byte offset
  	(little endian).
   */
  /*	<Alien> signedWordAt: index <Integer> put: value <Integer> ^<Integer>
  	<primitive: 'primSignedWordAtPut' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primSignedWordAtPut */
  EXPORT(sqInt)
  primSignedWordAtPut(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      sqInt value;
      sqInt valueOop;
  
  	valueOop = stackValue(0);
  	byteOffset = (stackPositiveMachineIntegerValue(1)) - 1;
  	rcvr = stackObjectValue(2);
  	value = signedMachineIntegerValueOf(valueOop);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, BytesPerOop, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (isOopImmutable(rcvr)) {
  		return primitiveFailFor(PrimErrNoModification);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	longAtput(addr, value);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Answer the signed 32- or 64-bit integer comprising the size field (the
  	first 32- or 64-bit field).
   */
  /*	<Alien> primSizeField ^<Integer>
  	<primitive: 'primSizeField' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primSizeField */
  EXPORT(sqInt)
  primSizeField(void)
  {
      sqInt rcvr;
      sqInt value;
      sqInt valueOop;
  
  	rcvr = stackValue(0);
  	value = 
  #  if BytesPerOop == 8
  		((sqLong) (longAt(rcvr + BaseHeaderSize)))
  #  else /* BytesPerOop == 8 */
  		((int) (longAt(rcvr + BaseHeaderSize)))
  #  endif /* BytesPerOop == 8 */
  		;
  	valueOop = (BytesPerWord == 8
  		? signed64BitIntegerFor(value)
  		: signed32BitIntegerFor(value));
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Store a signed integer into the size field (the first 32 bit field; little
  	endian). 
   */
  /*	<Alien> sizeFieldPut: value <Integer> ^<Integer>
  	<primitive: 'primSizeFieldPut' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primSizeFieldPut */
  EXPORT(sqInt)
  primSizeFieldPut(void)
  {
      sqInt rcvr;
      sqInt value;
      sqInt valueOop;
  
  	valueOop = stackValue(0);
  	rcvr = stackValue(1);
  	value = signedMachineIntegerValueOf(valueOop);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	
  #  if BytesPerOop == 8
  	longAtput(rcvr + BaseHeaderSize, ((usqInt) value));
  #  else /* BytesPerOop == 8 */
  	longAtput(rcvr + BaseHeaderSize, ((usqInt) value));
  #  endif /* BytesPerOop == 8 */
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Answer the number of non-null bytes starting at index. If
  	there isn't a null byte before the end of the object then the
  	result will be the number of bytes from index to the end of
  	the object, i.e. the result will be within the bounds of the object. */
  /*	<Alien> primStrlenFrom: index <Integer> ^<Integer>
  	<primitive: 'primStrlenFromStartIndex' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primStrlenFromStartIndex */
  EXPORT(sqInt)
  primStrlenFromStartIndex(void)
  {
      sqInt byteOffset;
      sqInt index;
      sqInt limit;
      char *ptr;
      sqInt rcvr;
  
  	byteOffset = (stackPositiveMachineIntegerValue(0)) - 1;
  	rcvr = stackObjectValue(1);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 1, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	limit = longAt(rcvr + BaseHeaderSize);
  	ptr = ((char *) (((limit > 0
  	? (rcvr + BaseHeaderSize) + BytesPerOop
  	: longAt((rcvr + BaseHeaderSize) + BytesPerOop))) + byteOffset));
  	if (limit == 0) {
  		index = strlen(ptr);
  	}
  	else {
  		limit = SQABS(limit);
  		index = 0;
  		while ((index < limit)
  		 && ((ptr[index]) != 0)) {
  			index += 1;
  		}
  	}
  	return methodReturnValue(positive32BitIntegerFor(index));
  }
  
  
  /*	Answer the number of non-null bytes starting at the byte addressed by
  	the 4-byte pointer at index. */
  /*	<Alien> strlenThroughPointerAt: index <Integer> ^<Integer>
  	<primitive: 'primStrlenThroughPointerAtIndex' error: errorCode module:
  	'IA32ABI'> 
   */
  
  	/* IA32ABIPlugin>>#primStrlenThroughPointerAtIndex */
  EXPORT(sqInt)
  primStrlenThroughPointerAtIndex(void)
  {
      sqInt addr;
      sqInt byteOffset;
      char *ptr;
      sqInt rcvr;
  
  	byteOffset = (stackPositiveMachineIntegerValue(0)) - 1;
  	rcvr = stackObjectValue(1);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, BytesPerOop, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	addr = (((longAt(rcvr + BaseHeaderSize)) > 0
  	? (rcvr + BaseHeaderSize) + BytesPerOop
  	: longAt((rcvr + BaseHeaderSize) + BytesPerOop))) + byteOffset;
  	ptr = ((char *) (longAt(addr)));
  	return methodReturnValue(positive32BitIntegerFor(strlen(ptr)));
  }
  
  
  /*	Answer the address of the entry-point for thunk callbacks:
  	long thunkEntry(void *thunkp, long *stackp);
  	This could be derived via loadModule: findSymbol: etc but that would
  	preclude making the plugin internal. */
  
  	/* IA32ABIPlugin>>#primThunkEntryAddress */
  EXPORT(sqInt)
  primThunkEntryAddress(void)
  {
      sqIntptr_t address;
  
  	address = ((sqIntptr_t)thunkEntry);
  	methodReturnValue((BytesPerWord == 8
  		? positive64BitIntegerFor(address)
  		: positive32BitIntegerFor(address)));
  	return 0;
  }
  
  
  /*	Answer the unsigned 8-bit integer starting at the given byte offset
  	(little endian).
   */
  /*	<Alien> unsignedByteAt: index <Integer> ^<Integer>
  	<primitive: 'primUnsignedByteAt' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primUnsignedByteAt */
  EXPORT(sqInt)
  primUnsignedByteAt(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      unsigned char  value;
      sqInt valueOop;
  
  	byteOffset = (stackPositiveMachineIntegerValue(0)) - 1;
  	rcvr = stackObjectValue(1);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 1, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	value = byteAt(addr);
  	valueOop = positive32BitIntegerFor(value);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Store an unsigned integer into 8 bits starting at the given byte offset
  	(little endian).
   */
  /*	<Alien> unsignedByteAt: index <Integer> put: value <Integer> ^<Integer>
  	<primitive: 'primUnsignedByteAtPut' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primUnsignedByteAtPut */
  EXPORT(sqInt)
  primUnsignedByteAtPut(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      sqInt value;
      sqInt valueOop;
  
  	valueOop = stackValue(0);
  	byteOffset = (stackPositiveMachineIntegerValue(1)) - 1;
  	rcvr = stackObjectValue(2);
  	value = positive32BitValueOf(valueOop);
  	if ((failed())
  	 || (value > 0xFF)) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 1, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (isOopImmutable(rcvr)) {
  		return primitiveFailFor(PrimErrNoModification);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	byteAtput(addr, value);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Answer the unsigned 32-bit integer starting at the given byte offset
  	(little endian).
   */
  /*	<Alien> unsignedLongAt: index <Integer> ^<Integer>
  	<primitive: 'primUnsignedLongAt' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primUnsignedLongAt */
  EXPORT(sqInt)
  primUnsignedLongAt(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      int value;
      sqInt valueOop;
  
  	byteOffset = (stackPositiveMachineIntegerValue(0)) - 1;
  	rcvr = stackObjectValue(1);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 4, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	value = long32At(addr);
  	valueOop = positive32BitIntegerFor(value);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Store an unsigned integer into 32 bits starting at the given byte offset
  	(little endian).
   */
  /*	<Alien> unsignedLongAt: index <Integer> put: value <Integer> ^<Integer>
  	<primitive: 'primUnsignedLongAtPut' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primUnsignedLongAtPut */
  EXPORT(sqInt)
  primUnsignedLongAtPut(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      sqInt value;
      sqInt valueOop;
  
  	valueOop = stackValue(0);
  	byteOffset = (stackPositiveMachineIntegerValue(1)) - 1;
  	rcvr = stackObjectValue(2);
  	value = positive32BitValueOf(valueOop);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 4, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (isOopImmutable(rcvr)) {
  		return primitiveFailFor(PrimErrNoModification);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	long32Atput(addr, value);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Answer the unsigned 64-bit integer starting at the given byte offset
  	(little endian).
   */
  /*	<Alien>unsignedLongLongAt: index <Integer> ^<Integer>
  	<primitive: 'primUnsignedLongLongAt' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primUnsignedLongLongAt */
  EXPORT(sqInt)
  primUnsignedLongLongAt(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      unsigned long long unsignedlonglongvalue;
      unsigned long long *unsignedlonglongvaluePtr;
      sqInt valueOop;
  
  	unsignedlonglongvaluePtr = 0;
  	byteOffset = (stackPositiveMachineIntegerValue(0)) - 1;
  	rcvr = stackObjectValue(1);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 8, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	unsignedlonglongvaluePtr = ((unsigned long long*) addr);
  	unsignedlonglongvalue = *unsignedlonglongvaluePtr;
  	valueOop = positive64BitIntegerFor(unsignedlonglongvalue);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Store a signed integer into 64 bits starting at the given byte offset
  	(little endian).
   */
  /*	<Alien> unsignedLongLongAt: index <Integer> put: value <Integer>
  	^<Integer> <primitive: 'primUnSignedLongLongAtPut' error: errorCode
  	module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primUnsignedLongLongAtPut */
  EXPORT(sqInt)
  primUnsignedLongLongAtPut(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      unsigned long long unsignedlonglongvalue;
      unsigned long long *unsignedlonglongvaluePtr;
      sqInt valueOop;
  
  	unsignedlonglongvaluePtr = 0;
  	valueOop = stackValue(0);
  	byteOffset = (stackPositiveMachineIntegerValue(1)) - 1;
  	rcvr = stackObjectValue(2);
  	unsignedlonglongvalue = positive64BitValueOf(valueOop);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 8, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (isOopImmutable(rcvr)) {
  		return primitiveFailFor(PrimErrNoModification);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	unsignedlonglongvaluePtr = ((unsigned long long*) addr);
  	*unsignedlonglongvaluePtr = unsignedlonglongvalue;
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Answer the unsigned 16-bit integer starting at the given byte offset
  	(little endian).
   */
  /*	<Alien> unsignedShortAt: index <Integer> ^<Integer>
  	<primitive: 'primUnsignedShortAt' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primUnsignedShortAt */
  EXPORT(sqInt)
  primUnsignedShortAt(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      unsigned short value;
      sqInt valueOop;
  
  	byteOffset = (stackPositiveMachineIntegerValue(0)) - 1;
  	rcvr = stackObjectValue(1);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 2, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	value = shortAt(addr);
  	valueOop = positive32BitIntegerFor(value);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Store an unsigned integer into 16 bits starting at the given byte offset
  	(little endian).
   */
  /*	<Alien> unsignedShortAt: index <Integer> put: value <Integer> ^<Integer>
  	<primitive: 'primUnsignedShortAtPut' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primUnsignedShortAtPut */
  EXPORT(sqInt)
  primUnsignedShortAtPut(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      sqInt value;
      sqInt valueOop;
  
  	valueOop = stackValue(0);
  	byteOffset = (stackPositiveMachineIntegerValue(1)) - 1;
  	rcvr = stackObjectValue(2);
  	value = positive32BitValueOf(valueOop);
  	if ((failed())
  	 || (value > 0xFFFF)) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, 2, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (isOopImmutable(rcvr)) {
  		return primitiveFailFor(PrimErrNoModification);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	shortAtput(addr, value);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Answer the unsigned word starting at the given byte offset (little
  	endian). 
   */
  /*	<Alien> unsignedWordAt: index <Integer> ^<Integer>
  	<primitive: 'primUnsignedWordAt' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primUnsignedWordAt */
  EXPORT(sqInt)
  primUnsignedWordAt(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      sqInt value;
      sqInt valueOop;
  
  	byteOffset = (stackPositiveMachineIntegerValue(0)) - 1;
  	rcvr = stackObjectValue(1);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, BytesPerOop, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	value = longAt(addr);
  	/* begin positiveMachineIntegerFor: */
  	valueOop = (BytesPerWord == 8
  		? positive64BitIntegerFor(value)
  		: positive32BitIntegerFor(value));
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Store an unsigned integer into 32 bits starting at the given byte offset
  	(little endian).
   */
  /*	<Alien> unsignedWordAt: index <Integer> put: value <Integer> ^<Integer>
  	<primitive: 'primUnsignedWordAtPut' error: errorCode module: 'IA32ABI'> */
  
  	/* IA32ABIPlugin>>#primUnsignedWordAtPut */
  EXPORT(sqInt)
  primUnsignedWordAtPut(void)
  {
      sqInt addr;
      sqInt byteOffset;
      sqInt rcvr;
      sqInt startAddr;
      sqInt value;
      sqInt valueOop;
  
  	valueOop = stackValue(0);
  	byteOffset = (stackPositiveMachineIntegerValue(1)) - 1;
  	rcvr = stackObjectValue(2);
  	value = positiveMachineIntegerValueOf(valueOop);
  	if (failed()) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	if (!(indexlengthinRange(byteOffset, BytesPerOop, rcvr))) {
  		return primitiveFailFor(PrimErrBadIndex);
  	}
  	if (isOopImmutable(rcvr)) {
  		return primitiveFailFor(PrimErrNoModification);
  	}
  	if (((startAddr = ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop)))) == 0) {
  		return primitiveFailFor(PrimErrBadReceiver);
  	}
  	addr = startAddr + byteOffset;
  	longAtput(addr, value);
  	return methodReturnValue(valueOop);
  }
  
  
  /*	Call a foreign function that answers a double-precision floating-point
  	result in %f0
  	according to IA32-ish ABI rules. The primitive will have a signature of
  	the form
  	functionAddress <Alien> primFFICallResult: result <Alien|Object>
  	withArguments: args <Array of: Alien | Integer> ^<Alien>
  	<primitive: 'primVarArgsCallOutDoubleReturn' error: errorCode module:
  	'IA32ABI'>. Answer result. If result is an Alien the value answered by the
  	call will be assigned to result.
   */
  
  	/* IA32ABIPlugin>>#primVarArgsCallOutDoubleReturn */
  EXPORT(sqInt)
  primVarArgsCallOutDoubleReturn(void)
  {
      sqInt array;
      sqInt errCode;
      sqInt mac;
      sqInt result;
  
  	array = stackValue(0);
  	if (!(isArray(array))) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	mac = methodArgumentCount();
  
  	/* ptr to 0th arg */
  	/* nargs */
  	/* func stackValue */
  	/* result stackValue */
  	errCode = callIA32DoubleReturn(firstIndexableField(array), stSizeOf(array), 2, 1);
  	if (errCode != 0) {
  		return primitiveFailFor(errCode);
  	}
  	result = stackValue(1);
  	popthenPush(mac + 1, result);
  	return 0;
  }
  
  
  /*	Call a foreign function that answers a single-precision floating-point
  	result in %f0
  	according to IA32-ish ABI rules. The primitive will have a signature of
  	the form
  	functionAddress <Alien> primFFICallResult: result <Alien|Object>
  	withArguments: args <Array of: Alien | Integer> ^<Alien>
  	<primitive: 'primVarArgsCallOutFloatReturn' error: errorCode module:
  	'IA32ABI'>. Answer result. If result is an Alien the value answered by the
  	call will be assigned to result.
   */
  
  	/* IA32ABIPlugin>>#primVarArgsCallOutFloatReturn */
  EXPORT(sqInt)
  primVarArgsCallOutFloatReturn(void)
  {
      sqInt array;
      sqInt errCode;
      sqInt mac;
      sqInt result;
  
  	array = stackValue(0);
  	if (!(isArray(array))) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	mac = methodArgumentCount();
  
  	/* ptr to 0th arg */
  	/* nargs */
  	/* func stackValue */
  	/* result stackValue */
  	errCode = callIA32FloatReturn(firstIndexableField(array), stSizeOf(array), 2, 1);
  	if (errCode != 0) {
  		return primitiveFailFor(errCode);
  	}
  	result = stackValue(1);
  	popthenPush(mac + 1, result);
  	return 0;
  }
  
  
  /*	Call a foreign function that answers an integral result in %eax (and
  	possibly %edx)
  	according to IA32-ish ABI rules. The primitive will have a signature of
  	the form
  	functionAddress <Alien> primFFICallResult: result <Alien|Object>
  	withArguments: args <Array of: Alien | Integer> ^<Alien>
  	<primitive: 'primVarArgsCallOutIntegralReturn' error: errorCode module:
  	'IA32ABI'>. Answer result. If result is an Alien the value answered by the
  	call will be assigned to result.
   */
  
  	/* IA32ABIPlugin>>#primVarArgsCallOutIntegralReturn */
  EXPORT(sqInt)
  primVarArgsCallOutIntegralReturn(void)
  {
      sqInt array;
      sqInt errCode;
      sqInt mac;
      sqInt result;
  
  	array = stackValue(0);
  	if (!(isArray(array))) {
  		return primitiveFailFor(PrimErrBadArgument);
  	}
  	mac = methodArgumentCount();
  
  	/* ptr to 0th arg */
  	/* nargs */
  	/* func stackValue */
  	/* result stackValue */
  	errCode = callIA32IntegralReturn(firstIndexableField(array), stSizeOf(array), 2, 1);
  	if (errCode != 0) {
  		return primitiveFailFor(errCode);
  	}
  	result = stackValue(1);
  	popthenPush(mac + 1, result);
  	return 0;
  }
  
  
  /*	Note: This is coded so that is can be run from Squeak. */
  
  	/* IA32ABIPlugin>>#setInterpreter: */
  EXPORT(sqInt)
  setInterpreter(struct VirtualMachine*anInterpreter)
  {
      sqInt ok;
  
  	interpreterProxy = anInterpreter;
  
  	/* There was no version 0 */
  	ok = ((interpreterProxy->majorVersion()) > 1)
  	 || ((interpreterProxy->minorVersion()) >= 12);
  	if (ok) {
  		
  #if !defined(SQUEAK_BUILTIN_PLUGIN)
  		byteSizeOf = interpreterProxy->byteSizeOf;
  		classAlien = interpreterProxy->classAlien;
  		classLargeNegativeInteger = interpreterProxy->classLargeNegativeInteger;
  		classLargePositiveInteger = interpreterProxy->classLargePositiveInteger;
  		classSemaphore = interpreterProxy->classSemaphore;
  		failed = interpreterProxy->failed;
  		falseObject = interpreterProxy->falseObject;
  		fetchClassOf = interpreterProxy->fetchClassOf;
  		firstIndexableField = interpreterProxy->firstIndexableField;
  		floatValueOf = interpreterProxy->floatValueOf;
  		getStackPointer = interpreterProxy->getStackPointer;
  		includesBehaviorThatOf = interpreterProxy->includesBehaviorThatOf;
  		instantiateClassindexableSize = interpreterProxy->instantiateClassindexableSize;
  		integerObjectOf = interpreterProxy->integerObjectOf;
  		integerValueOf = interpreterProxy->integerValueOf;
  		ioLoadModuleOfLength = interpreterProxy->ioLoadModuleOfLength;
  		ioLoadSymbolOfLengthFromModule = interpreterProxy->ioLoadSymbolOfLengthFromModule;
  		isArray = interpreterProxy->isArray;
  		isBytes = interpreterProxy->isBytes;
  		isInMemory = interpreterProxy->isInMemory;
  		isIntegerObject = interpreterProxy->isIntegerObject;
  		isNonImmediate = interpreterProxy->isNonImmediate;
  #if IMMUTABILITY
  		isOopImmutable = interpreterProxy->isOopImmutable;
  #else
  #if !defined(isOopImmutable)
  		isOopImmutable = 0;
  #endif
  #endif
  		isWordsOrBytes = interpreterProxy->isWordsOrBytes;
  		methodArgumentCount = interpreterProxy->methodArgumentCount;
  		methodReturnValue = interpreterProxy->methodReturnValue;
  		pop = interpreterProxy->pop;
  		popthenPush = interpreterProxy->popthenPush;
  		positive32BitIntegerFor = interpreterProxy->positive32BitIntegerFor;
  		positive32BitValueOf = interpreterProxy->positive32BitValueOf;
  		positive64BitIntegerFor = interpreterProxy->positive64BitIntegerFor;
  		positive64BitValueOf = interpreterProxy->positive64BitValueOf;
  		positiveMachineIntegerValueOf = interpreterProxy->positiveMachineIntegerValueOf;
  		primitiveFailFor = interpreterProxy->primitiveFailFor;
  		pushFloat = interpreterProxy->pushFloat;
  		returnAsThroughCallbackContext = interpreterProxy->returnAsThroughCallbackContext;
  		signalNoResume = interpreterProxy->signalNoResume;
  		signed32BitIntegerFor = interpreterProxy->signed32BitIntegerFor;
  		signed32BitValueOf = interpreterProxy->signed32BitValueOf;
  		signed64BitIntegerFor = interpreterProxy->signed64BitIntegerFor;
  		signed64BitValueOf = interpreterProxy->signed64BitValueOf;
  		signedMachineIntegerValueOf = interpreterProxy->signedMachineIntegerValueOf;
  		stSizeOf = interpreterProxy->stSizeOf;
  		stackIntegerValue = interpreterProxy->stackIntegerValue;
  		stackObjectValue = interpreterProxy->stackObjectValue;
  		stackPositiveMachineIntegerValue = interpreterProxy->stackPositiveMachineIntegerValue;
  		stackValue = interpreterProxy->stackValue;
  		trueObject = interpreterProxy->trueObject;
  #endif /* !defined(SQUEAK_BUILTIN_PLUGIN) */
  	}
  	return ok;
  }
  
  
  /*	Answer the first field of rcvr which is assumed to be an Alien of at least
  	8 bytes
   */
  
  	/* IA32ABIPlugin>>#sizeField: */
  static sqInt
  sizeField(sqInt rcvr)
  {
  	return longAt(rcvr + BaseHeaderSize);
  }
  
  
  /*	<byte indexable oop> ^<Integer> */
  /*	Answer the start of rcvr's data, given that it is not an alien. */
  
  	/* IA32ABIPlugin>>#startOfByteData: */
  static sqInt
  startOfByteData(sqInt rcvr)
  {
  	return rcvr + BaseHeaderSize;
  }
  
  
  /*	<Alien oop> ^<Integer> */
  /*	Answer the start of rcvr's data. For direct aliens this is the address of
  	the second field. For indirect and pointer aliens it is what the second
  	field points to. */
  
  	/* IA32ABIPlugin>>#startOfData: */
  static sqInt
  startOfData(sqInt rcvr)
  {
  	return ((longAt(rcvr + BaseHeaderSize)) > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop));
  }
  
  
  /*	<Alien oop> */
  /*	<Integer> ^<Integer> */
  /*	Answer the start of rcvr's data. For direct aliens this is the address of
  	the second field. For indirect and pointer aliens it is what the second
  	field points to. */
  
  	/* IA32ABIPlugin>>#startOfData:withSize: */
  static sqInt
  startOfDatawithSize(sqInt rcvr, sqInt sizeField)
  {
  	return (sizeField > 0
  		? (rcvr + BaseHeaderSize) + BytesPerOop
  		: longAt((rcvr + BaseHeaderSize) + BytesPerOop));
  }
  
  
  #ifdef SQUEAK_BUILTIN_PLUGIN
  
  static char _m[] = "IA32ABI";
  void* IA32ABI_exports[][3] = {
  	{(void*)_m, "getModuleName", (void*)getModuleName},
  	{(void*)_m, "isAlien", (void*)isAlien},
  	{(void*)_m, "primAddressField\000\000", (void*)primAddressField},
  	{(void*)_m, "primAddressFieldPut\000\000", (void*)primAddressFieldPut},
  	{(void*)_m, "primAlienReplace\000\000", (void*)primAlienReplace},
  	{(void*)_m, "primAllocateExecutablePage\000\377", (void*)primAllocateExecutablePage},
  	{(void*)_m, "primBoxedFree\000\001", (void*)primBoxedFree},
  	{(void*)_m, "primCallOutDoubleReturn\000\000", (void*)primCallOutDoubleReturn},
  	{(void*)_m, "primCallOutFloatReturn\000\000", (void*)primCallOutFloatReturn},
  	{(void*)_m, "primCallOutIntegralReturn\000\000", (void*)primCallOutIntegralReturn},
  	{(void*)_m, "primCalloc\000\000", (void*)primCalloc},
  	{(void*)_m, "primDoubleAt\000\000", (void*)primDoubleAt},
  	{(void*)_m, "primDoubleAtPut\000\000", (void*)primDoubleAtPut},
  	{(void*)_m, "primDrainOSEventQueue\000\377", (void*)primDrainOSEventQueue},
  	{(void*)_m, "primFloatAt\000\000", (void*)primFloatAt},
  	{(void*)_m, "primFloatAtPut\000\000", (void*)primFloatAtPut},
  	{(void*)_m, "primFree\000\000", (void*)primFree},
  	{(void*)_m, "primInIOProcessEventsFlagAddress\000\377", (void*)primInIOProcessEventsFlagAddress},
  	{(void*)_m, "primInLibraryFindSymbol\000\000", (void*)primInLibraryFindSymbol},
  	{(void*)_m, "primLoadLibrary\000\000", (void*)primLoadLibrary},
  	{(void*)_m, "primMalloc\000\000", (void*)primMalloc},
  	{(void*)_m, "primReturnAsFromContextThrough\000\000", (void*)primReturnAsFromContextThrough},
  	{(void*)_m, "primReturnFromContextThrough\000\000", (void*)primReturnFromContextThrough},
  	{(void*)_m, "primSignedByteAt\000\000", (void*)primSignedByteAt},
  	{(void*)_m, "primSignedByteAtPut\000\000", (void*)primSignedByteAtPut},
  	{(void*)_m, "primSignedLongAt\000\000", (void*)primSignedLongAt},
  	{(void*)_m, "primSignedLongAtPut\000\000", (void*)primSignedLongAtPut},
  	{(void*)_m, "primSignedLongLongAt\000\000", (void*)primSignedLongLongAt},
  	{(void*)_m, "primSignedLongLongAtPut\000\000", (void*)primSignedLongLongAtPut},
  	{(void*)_m, "primSignedShortAt\000\000", (void*)primSignedShortAt},
  	{(void*)_m, "primSignedShortAtPut\000\000", (void*)primSignedShortAtPut},
  	{(void*)_m, "primSignedWordAt\000\000", (void*)primSignedWordAt},
  	{(void*)_m, "primSignedWordAtPut\000\000", (void*)primSignedWordAtPut},
  	{(void*)_m, "primSizeField\000\000", (void*)primSizeField},
  	{(void*)_m, "primSizeFieldPut\000\000", (void*)primSizeFieldPut},
  	{(void*)_m, "primStrlenFromStartIndex\000\000", (void*)primStrlenFromStartIndex},
  	{(void*)_m, "primStrlenThroughPointerAtIndex\000\000", (void*)primStrlenThroughPointerAtIndex},
  	{(void*)_m, "primThunkEntryAddress\000\377", (void*)primThunkEntryAddress},
  	{(void*)_m, "primUnsignedByteAt\000\000", (void*)primUnsignedByteAt},
  	{(void*)_m, "primUnsignedByteAtPut\000\000", (void*)primUnsignedByteAtPut},
  	{(void*)_m, "primUnsignedLongAt\000\000", (void*)primUnsignedLongAt},
  	{(void*)_m, "primUnsignedLongAtPut\000\000", (void*)primUnsignedLongAtPut},
  	{(void*)_m, "primUnsignedLongLongAt\000\000", (void*)primUnsignedLongLongAt},
  	{(void*)_m, "primUnsignedLongLongAtPut\000\000", (void*)primUnsignedLongLongAtPut},
  	{(void*)_m, "primUnsignedShortAt\000\000", (void*)primUnsignedShortAt},
  	{(void*)_m, "primUnsignedShortAtPut\000\000", (void*)primUnsignedShortAtPut},
  	{(void*)_m, "primUnsignedWordAt\000\000", (void*)primUnsignedWordAt},
  	{(void*)_m, "primUnsignedWordAtPut\000\000", (void*)primUnsignedWordAtPut},
  	{(void*)_m, "primVarArgsCallOutDoubleReturn\000\000", (void*)primVarArgsCallOutDoubleReturn},
  	{(void*)_m, "primVarArgsCallOutFloatReturn\000\000", (void*)primVarArgsCallOutFloatReturn},
  	{(void*)_m, "primVarArgsCallOutIntegralReturn\000\000", (void*)primVarArgsCallOutIntegralReturn},
  	{(void*)_m, "setInterpreter", (void*)setInterpreter},
  	{NULL, NULL, NULL}
  };
  
  #else /* ifdef SQ_BUILTIN_PLUGIN */
  
  signed char primAddressFieldAccessorDepth = 0;
  signed char primAddressFieldPutAccessorDepth = 0;
  signed char primAlienReplaceAccessorDepth = 0;
  signed char primBoxedFreeAccessorDepth = 1;
  signed char primCallOutDoubleReturnAccessorDepth = 0;
  signed char primCallOutFloatReturnAccessorDepth = 0;
  signed char primCallOutIntegralReturnAccessorDepth = 0;
  signed char primCallocAccessorDepth = 0;
  signed char primDoubleAtAccessorDepth = 0;
  signed char primDoubleAtPutAccessorDepth = 0;
  signed char primFloatAtAccessorDepth = 0;
  signed char primFloatAtPutAccessorDepth = 0;
  signed char primFreeAccessorDepth = 0;
  signed char primInLibraryFindSymbolAccessorDepth = 0;
  signed char primLoadLibraryAccessorDepth = 0;
  signed char primMallocAccessorDepth = 0;
  signed char primReturnAsFromContextThroughAccessorDepth = 0;
  signed char primReturnFromContextThroughAccessorDepth = 0;
  signed char primSignedByteAtAccessorDepth = 0;
  signed char primSignedByteAtPutAccessorDepth = 0;
  signed char primSignedLongAtAccessorDepth = 0;
  signed char primSignedLongAtPutAccessorDepth = 0;
  signed char primSignedLongLongAtAccessorDepth = 0;
  signed char primSignedLongLongAtPutAccessorDepth = 0;
  signed char primSignedShortAtAccessorDepth = 0;
  signed char primSignedShortAtPutAccessorDepth = 0;
  signed char primSignedWordAtAccessorDepth = 0;
  signed char primSignedWordAtPutAccessorDepth = 0;
  signed char primSizeFieldAccessorDepth = 0;
  signed char primSizeFieldPutAccessorDepth = 0;
  signed char primStrlenFromStartIndexAccessorDepth = 0;
  signed char primStrlenThroughPointerAtIndexAccessorDepth = 0;
  signed char primUnsignedByteAtAccessorDepth = 0;
  signed char primUnsignedByteAtPutAccessorDepth = 0;
  signed char primUnsignedLongAtAccessorDepth = 0;
  signed char primUnsignedLongAtPutAccessorDepth = 0;
  signed char primUnsignedLongLongAtAccessorDepth = 0;
  signed char primUnsignedLongLongAtPutAccessorDepth = 0;
  signed char primUnsignedShortAtAccessorDepth = 0;
  signed char primUnsignedShortAtPutAccessorDepth = 0;
  signed char primUnsignedWordAtAccessorDepth = 0;
  signed char primUnsignedWordAtPutAccessorDepth = 0;
  signed char primVarArgsCallOutDoubleReturnAccessorDepth = 0;
  signed char primVarArgsCallOutFloatReturnAccessorDepth = 0;
  signed char primVarArgsCallOutIntegralReturnAccessorDepth = 0;
  
  #endif /* ifdef SQ_BUILTIN_PLUGIN */
  