text: #include "cinterface"
  static struct {
      TLint4	dummy;
      char	dummy2[1468];
  } TLFTAB =
      { 25,
      {'/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', 'v', 'a', 'l', 'u', 'e', '.', 'b', 'd', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', 'v', 'a', 'l', 'u', 'e', '.', 's', 't', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', '.', '.', '/', '.', '.', '/', 'f', 'i', 'l', 'e', 'm', 'a', 'n', '/', 'f', 'i', 'l', 'e', 'm', 'a', 'n', '.', 's', 't', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', '.', '.', '/', 'd', 'u', 'm', 'm', 'y', '.', 't', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', '.', '.', '/', 'e', 'n', 'v', 'i', 'r', 'o', 'n', '.', 's', 't', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', '.', '.', '/', 'm', 's', 'g', 's', '.', 'd', 'e', 'f', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', '.', '.', '/', 'd', 'e', 'b', 'u', 'g', '.', 'd', 'e', 'f', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', '.', '.', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '.', 's', 't', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', '.', '.', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '.', 'b', 'd', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', '.', '.', '/', 'u', 'n', 'i', 't', 'm', 'a', 'n', '/', 'u', 'n', 'i', 't', 'm', 'a', 'n', '.', 's', 't', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', '.', '.', '/', 'e', 'r', 'r', 'o', 'r', '.', 's', 't', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', '.', '.', '/', 'e', 'x', 'e', 'c', 'u', 't', 'o', 'r', '/', 'p', 's', 'e', 'u', 'd', 'o', '.', 'd', 'e', 'f', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', '.', '.', '/', 'e', 'x', 'e', 'c', 'u', 't', 'o', 'r', '/', 'o', 'p', 'c', 'o', 'd', 'e', '.', 'i', 'n', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', '.', '.', '/', 'd', 'e', 'b', 'u', 'g', '.', 's', 't', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', '.', 's', 't', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', '.', 'b', 'd', '\0',
      '/', 'l', 'o', 'c', 'a', 'l', '/', 'i', 'n', 'c', 'l', 'u', 'd', 'e', '/', 't', 'p', 'l', 'u', 's', '/', 'D', 'O', 'S', '3', '2', '/', 'm', 'e', 'm', 'o', 'r', 'y', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', 'g', 'l', 'o', 'b', 'a', 'l', '.', 'i', 'n', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', 'c', 'o', 'm', 'p', 'e', 'r', 'r', '.', 'd', 'e', 'f', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', 'c', 'o', 'm', 'p', 'e', 'r', 'r', '.', 'd', 'f', '2', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', 'c', 'o', 'm', 'p', 'e', 'r', 'r', '.', 's', 't', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', 'm', 'e', 'm', 'o', 'r', 'y', '.', 's', 't', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', 's', 'c', 'a', 'n', 'n', 'e', 'r', '/', 's', 'c', 'a', 'n', 'n', 'e', 'r', '.', 's', 't', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', 'p', 'r', 'e', 's', 'c', 'a', 'n', '.', 's', 't', '\0',
      '/', 'e', 'x', 'p', 'o', 'r', 't', '/', 'h', 'o', 'm', 'e', '/', 't', 'u', 'r', 'i', 'n', 'g', '/', 'o', 'o', 't', '/', 's', 'r', 'c', '/', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '/', 'c', 'o', 'm', 'p', 'i', 'l', 'e', 'r', '/', 's', 'c', 'o', 'p', 'e', '.', 's', 't', '\0'
      }};
  typedef	TLnat2	FileManager_FileNoType;
  typedef	TLnat4	FileManager_FileTimeStamp;
  typedef	TLint2	FileManager_ResultCode;
  
  extern void FileManager_OpenNamedHandle ();
  
  extern void FileManager_OpenUnnamedHandle ();
  
  extern void FileManager_OpenFileHandle ();
  
  extern void FileManager_SetModified ();
  
  extern void FileManager_WriteFile ();
  
  extern void FileManager_WriteBackup ();
  
  extern void FileManager_WriteTemp ();
  
  extern void FileManager_RmTemp ();
  
  extern void FileManager_CloseFileHandle ();
  
  extern void FileManager_OpenNamedText ();
  
  extern void FileManager_OpenFileText ();
  
  extern void FileManager_CloseFileText ();
  
  extern void FileManager_CloseAllText ();
  
  extern void FileManager_ChangeDirectory ();
  
  extern void FileManager_GetDirectory ();
  
  extern void FileManager_ChangeExecDirectory ();
  
  extern void FileManager_GetExecDirectory ();
  
  extern void FileManager_ShortName ();
  
  extern void FileManager_RelativeName ();
  
  extern void FileManager_PathName ();
  
  extern void FileManager_ExecPathName ();
  
  extern void FileManager_ExtendName ();
  
  extern void FileManager_FileName ();
  
  extern TLboolean FileManager_IsUnnamed ();
  
  extern TLboolean FileManager_IsOnDisk ();
  
  extern TLboolean FileManager_IsSameFile ();
  
  extern TLboolean FileManager_IsReadOK ();
  
  extern TLboolean FileManager_IsWriteOK ();
  
  extern TLboolean FileManager_IsOlder ();
  
  extern TLboolean FileManager_FileExists ();
  
  extern void FileManager_AddReference ();
  
  extern void FileManager_DeleteReference ();
  
  extern void FileManager_ReadTimeStamp ();
  
  extern void FileManager_FlushUnreferencedFiles ();
  
  extern void FileManager_CheckReferencedFiles ();
  
  extern void FileManager_RmFile ();
  
  extern void FileManager_SetDefaultInclude ();
  
  extern void FileManager_AssertTextClosed ();
  
  extern void FileManager_Dump ();
  
  extern TLboolean AbortCheck ();
  
  extern void FeedBack ();
  struct	SrcPosition {
      TLnat2	lineNo;
      FileManager_FileNoType	fileNo;
      TLnat2	linePos;
      TLnat2	tokLen;
  };
  typedef	TLchar	__x2199[256];
  struct	ErrMsgDef {
      struct ErrMsgDef	*next;
      struct SrcPosition	srcPos;
      __x2199	text;
  };
  typedef	TLint4	CookieKind;
  struct	Cookie {
      CookieKind	kind;
      TLaddressint	item;
      TLaddressint	fp;
      TLaddressint	data;
  };
  struct	CallDef {
      struct CallDef	*next;
      TLstring	routineName;
      struct SrcPosition	srcPos;
      struct Cookie	cookie;
  };
  struct	ThreadDef {
      struct ThreadDef	*next;
      TLaddressint	threadId;
      TLaddressint	threadName;
      struct CallDef	*traceback;
  };
  struct	ThreadQueueDef {
      struct ThreadQueueDef	*next;
      TLaddressint	queueId;
      TLstring	queueName;
      struct ThreadDef	*threadList;
  };
  struct	DumpIndexDef {
      struct DumpIndexDef	*next;
      TLint4	lowerBound;
      TLint4	upperBound;
  };
  struct	DumpSymbolDef {
      struct DumpSymbolDef	*next;
      TLaddressint	symbolName;
      TLaddressint	typeName;
      struct SrcPosition	srcPos;
      TLstring	value;
      struct Cookie	cookie;
      TLboolean	isPredef;
  };
  struct	DumpScopeDef {
      struct DumpSymbolDef	symbolInfo;
      struct Cookie	expandCookie;
      struct DumpSymbolDef	*parameters;
      struct DumpSymbolDef	*declarations;
  };
  
  extern void Language_Debugging ();
  
  extern void Language_Paragraph ();
  
  extern void Language_Reset ();
  
  extern void Language_SetMaxErrorCount ();
  typedef	TLstring	__x2200[20];
  
  extern void Language_EnterPreprocSymbols ();
  
  extern void Language_CompileUnit ();
  
  extern void Language_CompileProgram ();
  
  extern void Language_WriteObjectFile ();
  typedef	TLstring	__x2203[21];
  typedef	TLstring	__x2207[21];
  
  extern void Language_SetupExecution ();
  typedef	TLint1	Language_Step;
  
  extern void Language_SetStep ();
  typedef	TLint1	Language_ReturnState;
  struct	Language_RunStatus {
      Language_ReturnState	state;
      struct SrcPosition	srcPos;
      TLaddressint	threadId;
  };
  
  extern void Language_ExecuteProgram ();
  
  extern void Language_EndExecution ();
  
  extern void Language_StopExecution ();
  
  extern void Language_DumpThreadList ();
  
  extern void Language_DumpUnitList ();
  
  extern void Language_DumpScopeInfo ();
  
  extern void Language_DumpSymbolInfo ();
  
  extern void Language_DumpArrayBounds ();
  
  extern void Language_DumpArrayValues ();
  extern TLboolean	Language_debug;
  extern struct SrcPosition	Language_nullSrcPosition;
  extern struct Cookie	Language_nullCookie;
  extern struct DumpSymbolDef	Language_nullSymbolDef;
  extern struct DumpScopeDef	Language_nullScopeDef;
  typedef	TLint1	Language_UnitManager_UnitKind;
  typedef	TLint1	Language_UnitManager_UnitStatus;
  
  extern void Language_UnitManager_AddDepend ();
  
  extern void Language_UnitManager_AddIncludeFile ();
  
  extern void Language_UnitManager_AllocateCompileChunk ();
  
  extern void * Language_UnitManager_BodyUnit ();
  
  extern void Language_UnitManager_ClearAllMarks ();
  
  extern void Language_UnitManager_ClearConfiguration ();
  
  extern TLaddressint Language_UnitManager_CodeTable ();
  
  extern FileManager_FileNoType Language_UnitManager_FileNo ();
  
  extern void Language_UnitManager_FlushOldUnits ();
  
  extern void Language_UnitManager_GetNextDepend ();
  
  extern void Language_UnitManager_GetNextUnit ();
  
  extern void Language_UnitManager_GetUnitPtr ();
  
  extern TLaddressint Language_UnitManager_GlobalArea ();
  
  extern TLint4 Language_UnitManager_GlobalSize ();
  
  extern TLboolean Language_UnitManager_IsCompiled ();
  
  extern TLboolean Language_UnitManager_IsMarked ();
  
  extern TLboolean Language_UnitManager_IsPredef ();
  
  extern Language_UnitManager_UnitKind Language_UnitManager_Kind ();
  
  extern TLaddressint Language_UnitManager_ManifestTable ();
  
  extern void * Language_UnitManager_OverrideBody ();
  
  extern void Language_UnitManager_PrepareForCompile ();
  
  extern void Language_UnitManager_PrepareForDepends ();
  
  extern void Language_UnitManager_PrepareForScan ();
  
  extern void Language_UnitManager_Reset ();
  
  extern void Language_UnitManager_RewindDependList ();
  
  extern void Language_UnitManager_RewindUnitList ();
  
  extern void Language_UnitManager_SetCodeTable ();
  
  extern void Language_UnitManager_SetDefaultBody ();
  
  extern void Language_UnitManager_SetGlobalArea ();
  
  extern void Language_UnitManager_SetKind ();
  
  extern void Language_UnitManager_SetManifestTable ();
  
  extern void Language_UnitManager_SetMark ();
  
  extern void Language_UnitManager_SetOverrideBody ();
  
  extern void Language_UnitManager_SetPredef ();
  
  extern void Language_UnitManager_SetStub ();
  
  extern void Language_UnitManager_SetSymbolTable ();
  
  extern void Language_UnitManager_StartNewProgram ();
  
  extern void * Language_UnitManager_StubUnit ();
  
  extern void Language_UnitManager_SuccessfulCompile ();
  
  extern TLaddressint Language_UnitManager_SymbolTable ();
  typedef	TLint1	Language_ErrorModule_Severity;
  
  extern void Language_ErrorModule_Initialize ();
  
  extern void Language_ErrorModule_SetMaxErrors ();
  
  extern void Language_ErrorModule_Message ();
  
  extern void Language_ErrorModule_AbortIfErrors ();
  
  extern void Language_ErrorModule_ReturnErrors ();
  typedef	Language_ErrorModule_Severity	Language_ErrorSeverity;
  typedef	TLstring	Language_StringDef;
  typedef	TLnat4	Language_Offset;
  extern TLint4	Language_codeOprSize;
  extern TLint4	Language_codeInt1Size;
  extern TLint4	Language_codeInt2Size;
  extern TLint4	Language_codeIntSize;
  extern TLint4	Language_codeRealSize;
  extern TLint4	Language_codeAddrSize;
  extern TLint4	Language_codeOffsetSize;
  typedef	TLchar	Language_string1[2];
  typedef	TLnat1	Language_set8;
  typedef	TLnat2	Language_set16;
  typedef	TLnat4	Language_set32;
  typedef	TLint2	Language_Opcode;
  typedef	TLchar	Language___x2211[22];
  typedef	Language___x2211	Language___x2210[255];
  extern Language___x2210	Language_OpcodeName;
  struct	Language_CodeHeader {
      TLaddressint	bodyCode;
  };
  struct	Language___x2213 {
      TLint4	lower, range;
  };
  typedef	struct Language___x2213	Language___x2212[255];
  struct	Language_ArrayDescriptor {
      TLnat4	sizeArray;
      TLnat4	sizeElement;
      TLnat4	elementCount;
      TLnat4	numDimensions;
      Language___x2212	dim;
  };
  struct	Language_ForDescriptor {
      TLint4	counter;
      TLint4	right;
      TLint4	step;
      TLaddressint	savedSP;
  };
  typedef	Language_Offset	Language___x2214[1001];
  struct	Language_CaseDescriptor {
      TLint4	lower, upper;
      Language_Offset	otherwise;
      Language___x2214	caseVector;
  };
  struct	Language_PointerDescriptor {
      TLaddressint	dataPtr;
      TLint4	timestamp;
  };
  typedef	TLnat2	Language___x2215[301];
  struct	Language_UnionMapDescriptor {
      TLint4	lower, upper;
      Language___x2215	map;
  };
  typedef	TLnat4	Language_ClassAttr;
  struct	Language_ClassDescriptor {
      TLaddressint	baseClass;
      TLaddressint	expandClass;
      Language_ClassAttr	attributes;
      TLnat4	objSize;
      TLaddressint	classId;
      TLaddressint	initRoutine;
      TLnat4	numOperations;
  };
  typedef	TLint1	Language_OpenKind;
  typedef	TLint1	Language_PutKind;
  typedef	TLint1	Language_GetKind;
  typedef	TLint1	Language_SetStreamKind;
  typedef	TLnat1	Language_StreamModeSet;
  typedef	TLint1	Language_SubstringKind;
  typedef	TLint1	Language_RangeCheckKind;
  typedef	TLint1	Language_ConditionKind;
  
  extern void Language_DebugModule_Initialize ();
  
  extern void Language_DebugModule_NewQueue ();
  
  extern void Language_DebugModule_NewThread ();
  
  extern void Language_DebugModule_NewCall ();
  
  extern void Language_DebugModule_ReturnThreadDump ();
  
  extern void Language_DebugModule_NewSymbolList ();
  
  extern void Language_DebugModule_NewSymbol ();
  
  extern void Language_DebugModule_ReturnSymbolDump ();
  
  extern void Language_DebugModule_NewIndexList ();
  
  extern void Language_DebugModule_NewIndex ();
  
  extern void Language_DebugModule_ReturnIndexDump ();
  
  extern void Language_Compile_Reset ();
  
  extern void Language_Compile_Initialize ();
  typedef	TLstring	__x2218[20];
  
  extern void Language_Compile_EnterPreprocSymbols ();
  
  extern void Language_Compile_ScanUnit ();
  
  extern void Language_Compile_CompileUnit ();
  
  extern void Language_Compile_InstallUnit ();
  
  extern void Language_Compile_CallInfo ();
  
  extern void Language_Compile_DumpUnitList ();
  
  extern void Language_Compile_DumpScopeInfo ();
  
  extern void Language_Compile_DumpSymbolInfo ();
  
  extern void Language_Compile_DumpArrayBounds ();
  
  extern void Language_Compile_DumpArrayValues ();
  
  extern void Language_Compile_SetObjectFileStream ();
  
  extern TLaddressint malloc ();
  
  extern TLaddressint realloc ();
  
  extern void free ();
  typedef	TLnat1	Language_Compile_Tok;
  typedef	TLchar	Language_Compile___x2223[16];
  struct	Language_Compile___x2222 {
      Language_Compile___x2223	Name;
      TLnat2	Precedence;
  };
  typedef	struct Language_Compile___x2222	Language_Compile___x2221[159];
  extern Language_Compile___x2221	Language_Compile_TokData;
  typedef	TLint1	Language_Compile_PPTok;
  typedef	TLchar	Language_Compile___x2225[8];
  typedef	Language_Compile___x2225	Language_Compile___x2224[16];
  extern Language_Compile___x2224	Language_Compile_PPTokName;
  typedef	TLint1	Language_Compile_TypeKind;
  typedef	TLchar	Language_Compile___x2227[16];
  typedef	Language_Compile___x2227	Language_Compile___x2226[33];
  extern Language_Compile___x2226	Language_Compile_TypeKindName;
  typedef	TLchar	Language_Compile___x2229[16];
  typedef	Language_Compile___x2229	Language_Compile___x2228[33];
  extern Language_Compile___x2228	Language_Compile_TypeKindKeyword;
  typedef	TLint1	Language_Compile_TyModes;
  typedef	TLchar	Language_Compile___x2231[12];
  typedef	Language_Compile___x2231	Language_Compile___x2230[10];
  extern Language_Compile___x2230	Language_Compile_TyModeName;
  typedef	TLnat2	Language_Compile_TyModesSet;
  typedef	TLint2	Language_Compile_PredType;
  typedef	Language_Compile_TypeKind	Language_Compile___x2232[27];
  extern Language_Compile___x2232	Language_Compile_PredTypeKind;
  typedef	Language_Compile_TyModesSet	Language_Compile___x2233[27];
  extern Language_Compile___x2233	Language_Compile_PredTypeMode;
  typedef	TLint2	Language_Compile_FormalType;
  typedef	TLint2	Language_Compile_Predef;
  typedef	TLchar	Language_Compile___x2236[20];
  struct	Language_Compile___x2235 {
      Language_Compile___x2236	Name;
      Language_Compile_FormalType	FormalList;
      Language_Compile_PredType	ResultType;
  };
  typedef	struct Language_Compile___x2235	Language_Compile___x2234[25];
  extern Language_Compile___x2234	Language_Compile_PredefData;
  typedef	TLchar	Language_Compile___x2237[256];
  struct	Language_Compile_CharDef {
      TLint4	len;
      Language_Compile___x2237	val;
  };
  struct	Language_Compile_IdentDef {
      struct Language_Compile_IdentDef	*nextIdent;
      Language_Compile_Tok	tok;
      Language_Compile_PPTok	ppTok;
      Language_StringDef	str;
  };
  typedef	TLint1	Language_Compile_SymbolKind;
  typedef	TLchar	Language_Compile___x2239[14];
  typedef	Language_Compile___x2239	Language_Compile___x2238[10];
  extern Language_Compile___x2238	Language_Compile_SymbolKindName;
  typedef	TLint1	Language_Compile_Access;
  typedef	TLchar	Language_Compile___x2241[6];
  typedef	Language_Compile___x2241	Language_Compile___x2240[3];
  extern Language_Compile___x2240	Language_Compile_AccessName;
  typedef	TLint1	Language_Compile_SyAttributes;
  typedef	TLchar	Language_Compile___x2243[16];
  typedef	Language_Compile___x2243	Language_Compile___x2242[20];
  extern Language_Compile___x2242	Language_Compile_SyAttribName;
  typedef	TLnat4	Language_Compile_SyAttributeSet;
  typedef	TLnat1	Language_Compile_ImportDepthType;
  struct	Language_Compile_IndexDef {
      struct Language_Compile_IndexDef	*next;
      struct Language_Compile_TypeDef	*ty;
  };
  typedef	TLint1	Language_Compile_ExportKind;
  typedef	TLchar	Language_Compile___x2245[16];
  typedef	Language_Compile___x2245	Language_Compile___x2244[4];
  extern Language_Compile___x2244	Language_Compile_ExportKindName;
  typedef	TLnat1	Language_Compile_ExportKindSet;
  struct	Language_Compile_ExportDef {
      struct Language_Compile_ExportDef	*next;
      struct Language_Compile_IdentDef	*identPtr;
      struct Language_Compile_SymbolDef	*symbolPtr;
      struct Language_Compile_TypeDef	*opaqueTypePtr;
      Language_Compile_ExportKindSet	kind;
  };
  struct	Language_Compile_ImportDef {
      struct Language_Compile_ImportDef	*next;
      struct Language_Compile_SymbolDef	*sy;
      Language_Compile_Access	newAccess;
      Language_Compile_Access	oldAccess;
      Language_Compile_ImportDepthType	oldImportDepth;
      TLboolean	overridesExpand;
  };
  struct	Language_Compile_DynamicDef {
      struct Language_Compile_DynamicDef	*next;
      struct Language_Compile_SymbolDef	*sy;
  };
  typedef	TLint1	Language_Compile_BlockKind;
  typedef	TLchar	Language_Compile___x2247[10];
  typedef	Language_Compile___x2247	Language_Compile___x2246[16];
  extern Language_Compile___x2246	Language_Compile_BlockKindName;
  struct	Language_Compile_BlockDef {
      struct Language_Compile_BlockDef	*parentBlock;
      struct Language_Compile_BlockDef	*siblingBlock;
      struct Language_Compile_BlockDef	*childBlock;
      struct Language_Compile_BlockDef	*expandBlock;
      struct Language_Compile_SymbolDef	*internalSymbols;
      struct Language_Compile_SymbolDef	*parentSymbols;
      struct Language_Compile_SymbolDef	*definingSymbol;
      Language_Offset	codeStartOffset;
      Language_Offset	codeEndOffset;
      struct Language_Compile_DynamicDef	*dynamics;
      Language_Compile_BlockKind	kind;
      TLboolean	reachable;
      TLboolean	resolvingNeeded;
  };
  typedef	TLint1	Language_Compile_Base;
  typedef	TLchar	Language_Compile___x2249[12];
  typedef	Language_Compile___x2249	Language_Compile___x2248[10];
  extern Language_Compile___x2248	Language_Compile_BaseName;
  typedef	TLint1	Language_Compile_Indirection;
  typedef	TLchar	Language_Compile___x2251[10];
  typedef	Language_Compile___x2251	Language_Compile___x2250[3];
  extern Language_Compile___x2250	Language_Compile_IndirName;
  struct	Language_Compile_Location {
      void	*unitPtr;
      Language_Compile_Base	base;
      Language_Compile_Indirection	indir;
      Language_Offset	offset;
  };
  extern struct Language_Compile_Location	Language_Compile_nullLocation;
  struct	Language_Compile_DeferredLocDef {
      struct Language_Compile_DeferredLocDef	*next;
      struct Language_Compile_SymbolDef	*sy;
      struct Language_Compile_Location	loc;
  };
  struct	Language_Compile___x2252 {
      Language_Compile_SymbolKind	syTag;
      union {
  	struct {
  	    struct Language_Compile_SymbolDef	*mExpandSy;
  	    struct Language_Compile_ImportDef	*mImportsOf;
  	    struct Language_Compile_ExportDef	*mExportsOf;
  	    Language_Compile_ExportKindSet	mExportAllKind;
  	    struct Language_Compile_SymbolDef	*mMonitorVar;
  	    struct Language_Compile_SymbolDef	*mClassTagSy;
  	    TLint4	mDeferredNum;
  	    struct Language_Compile_DeferredLocDef	*mDeferredLocs;
  	} __u2;
  	struct {
  	    struct Language_Compile_ValueDef	*cValue;
  	} __u3;
  	struct {
  	    struct Language_Compile_SymbolDef	*fFormalsOf;
  	    struct Language_Compile_ImportDef	*fImportsOf;
  	    struct Language_Compile_SymbolDef	*ResultsId;
  	    struct Language_Compile_TypeDef	*ResultType;
  	} __u4;
  	struct {
  	    struct Language_Compile_SymbolDef	*pFormalsOf;
  	    struct Language_Compile_ImportDef	*pImportsOf;
  	    struct Language_Compile_ValueDef	*pValue;
  	} __u5;
  	struct {
  	    TLint4	unionNumber;
  	} __u6;
      } __u1;
  } ;
  struct	Language_Compile_SymbolDef {
      struct Language_Compile_SymbolDef	*next;
      struct Language_Compile_IdentDef	*identPtr;
      struct Language_Compile_TypeDef	*tyPtr;
      Language_Compile_Access	access;
      Language_Compile_ImportDepthType	importDepth;
      Language_Compile_Predef	predefined;
      Language_Compile_SyAttributeSet	attributes;
      struct Language_Compile_SymbolDef	*definingSy;
      struct Language_Compile_BlockDef	*blockScope;
      struct Language_Compile_Location	loc;
      struct SrcPosition	srcPos;
      Language_Offset	definingOffset;
      struct Language_Compile___x2252	u;
  };
  struct	Language_Compile_IntListDef {
      struct Language_Compile_IntListDef	*next;
      TLint4	value;
  };
  struct	Language_Compile_UnionDef {
      struct Language_Compile_UnionDef	*next;
      struct Language_Compile_SymbolDef	*firstSym;
      TLint4	numSyms;
      struct Language_Compile_IntListDef	*values;
      TLint4	uloc;
  };
  struct	Language_Compile___x2253 {
      Language_Compile_TypeKind	tyTag;
      union {
  	struct {
  	    struct Language_Compile_IndexDef	*IndexOf;
  	    struct Language_Compile_TypeDef	*aElementOf;
  	    struct Language_Compile_Location	aDescriptor;
  	} __u8;
  	struct {
  	    struct Language_Compile_SymbolDef	*cNameOf;
  	    struct Language_Compile_TypeDef	*cPointerTy;
  	    struct Language_Compile_TypeDef	*cUPointerTy;
  	} __u9;
  	struct {
  	    struct Language_Compile_SymbolDef	*EnumIds;
  	    struct Language_Compile_Location	eDescriptor;
  	} __u10;
  	struct {
  	    struct Language_Compile_BlockDef	*blockLevel;
  	} __u11;
  	struct {
  	    struct Language_Compile_SymbolDef	*sNameOf;
  	} __u12;
  	struct {
  	    struct Language_Compile_SymbolDef	*oNameOf;
  	    struct Language_Compile_TypeDef	*tyOf;
  	} __u13;
  	struct {
  	    struct Language_Compile_SymbolDef	*pNameOf;
  	    struct Language_Compile_TypeDef	*pElementOf;
  	} __u14;
  	struct {
  	    struct Language_Compile_SymbolDef	*rFieldsOf;
  	} __u15;
  	struct {
  	    struct Language_Compile_TypeDef	*BaseOf;
  	    TLboolean	sIsScalar;
  	} __u16;
  	struct {
  	    TLint4	stringSize;
  	} __u17;
  	struct {
  	    struct Language_Compile_Location	sDescriptor;
  	} __u18;
  	struct {
  	    TLint4	low;
  	    TLint4	high;
  	    struct Language_Compile_TypeDef	*Root;
  	} __u19;
  	struct {
  	    struct Language_Compile_SymbolDef	*TagOf;
  	    struct Language_Compile_SymbolDef	*uFieldsOf;
  	    struct Language_Compile_UnionDef	*map;
  	    struct Language_Compile_Location	mapLocation;
  	    struct Language_Compile_Location	uninitMap;
  	} __u20;
  	struct {
  	    struct Language_Compile_TypeDef	*tyPtr;
  	} __u21;
      } __u7;
  } ;
  struct	Language_Compile_TypeDef {
      struct Language_Compile_SymbolDef	*typeName;
      Language_Compile_TyModesSet	mode;
      TLint1	alignment;
      struct Language_Compile_Location	uninitTableLoc;
      TLint4	tSize;
      struct Language_Compile___x2253	u;
  };
  typedef	TLint1	Language_Compile_ValueKind;
  typedef	TLchar	Language_Compile___x2255[16];
  typedef	Language_Compile___x2255	Language_Compile___x2254[9];
  extern Language_Compile___x2254	Language_Compile_ValueKindName;
  typedef	TLnat4	Language_Compile_ValueSetType;
  struct	Language_Compile___x2256 {
      Language_Compile_ValueKind	valTag;
      union {
  	struct {
  	    struct Language_Compile_ValueDef	*next;
  	} __u23;
  	struct {
  	    TLboolean	boolVal;
  	} __u24;
  	struct {
  	    TLchar	charVal;
  	} __u25;
  	struct {
  	    struct Language_Compile_CharDef	*cstrVal;
  	} __u26;
  	struct {
  	    TLboolean	negative;
  	    TLnat4	natVal;
  	} __u27;
  	struct {
  	    TLreal8	realVal;
  	} __u28;
  	struct {
  	    Language_Compile_ValueSetType	setVal;
  	} __u29;
  	struct {
  	    Language_StringDef	*stringVal;
  	} __u30;
      } __u22;
  } ;
  struct	Language_Compile_ValueDef {
      TLboolean	saved;
      struct Language_Compile___x2256	u;
  };
  struct	Language_Compile___x2257 {
      Language_Compile_Tok	tok;
      union {
  	struct {
  	    struct Language_Compile_CharDef	*cstrPtr;
  	} __u32;
  	struct {
  	    TLnat4	natVal;
  	} __u33;
  	struct {
  	    TLreal8	realVal;
  	} __u34;
  	struct {
  	    Language_StringDef	*strPtr;
  	} __u35;
      } __u31;
  } ;
  struct	Language_Compile_TokRecord {
      struct SrcPosition	srcPos;
      struct Language_Compile_IdentDef	*identPtr;
      struct Language_Compile___x2257	u;
  };
  extern struct Language_Compile_TokRecord	Language_Compile_newTok;
  extern struct Language_Compile_TokRecord	Language_Compile_oldTok;
  
  extern char *strcpy ();
  
  void Language_Compile_CleanChar ();
  
  void Language_Compile_CleanCString ();
  
  void Language_Compile_IdentToName ();
  
  void Language_Compile_TokenToName ();
  
  void Language_Compile_SymbolToName ();
  extern void	*Language_Compile_compilingUnit;
  extern void	*Language_Compile_predefUnit;
  
  extern void Language_Compile_CompileError_Add ();
  
  extern void Language_Compile_CompileError_Initialize ();
  
  extern TLnat4 Language_Compile_CompileError_Count ();
  
  extern void Language_Compile_Memory_Initialize ();
  
  extern void Language_Compile_Memory_Allocate ();
  
  extern void Language_Compile_Memory_Trim ();
  typedef	struct Language_Compile_IdentDef	*Language_Compile___x2278[118];
  extern Language_Compile___x2278	Language_Compile_keywordIdent;
  struct	Language_Compile___x2279 {
      struct Language_Compile_IdentDef	*anyclass;
      struct Language_Compile_IdentDef	*main;
      struct Language_Compile_IdentDef	*unit;
  };
  extern struct Language_Compile___x2279	Language_Compile_specialIdent;
  
  extern void Language_Compile_Scanner_Reset ();
  
  extern void Language_Compile_Scanner_EnterTok ();
  
  extern void Language_Compile_Scanner_Initialize ();
  
  extern void Language_Compile_Scanner_Scan ();
  
  extern void Language_Compile_Scanner_GetFileUnit ();
  typedef	TLstring	__x2280[20];
  
  extern void Language_Compile_Scanner_EnterPreprocSymbols ();
  
  void Language_Compile_DemandToken ();
  
  void Language_Compile_ExpectToken ();
  
  void Language_Compile_ExpectEnd ();
  
  void Language_Compile_EqWantColonEq ();
  
  void Language_Compile_GetUnitFile ();
  
  void Language_Compile_InitializeScan ();
  
  extern void Language_Compile_ScanUnit ();
  
  extern void Language_Compile_PreScan_VerifyConfiguration ();
  
  extern void Language_Compile_PreScan_VerifyPredefList ();
  extern struct Language_Compile_BlockDef	*Language_Compile_rootBlock;
  extern struct Language_Compile_BlockDef	*Language_Compile_blockStack;
  extern struct Language_Compile_SymbolDef	*Language_Compile_compilingSymbol;
  extern struct Language_Compile_SymbolDef	*Language_Compile_monitorSymbol;
  extern struct Language_Compile_SymbolDef	*Language_Compile_classSymbol;
  extern struct Language_Compile_SymbolDef	*Language_Compile_subprogramSymbol;
  extern Language_Compile_ImportDepthType	Language_Compile_currentImportDepth;
  extern struct Language_Compile_ValueDef	*Language_Compile_nonCompileTimeValue;
  extern struct Language_Compile_ValueDef	*Language_Compile_intValueOne;
  typedef	struct Language_Compile_TypeDef	*Language_Compile___x2289[27];
  extern Language_Compile___x2289	Language_Compile_predType;
  extern TLint4	Language_Compile_debugFile;
  extern void 	(*Language_Compile_DumpAll)();
  extern void 	(*Language_Compile_procDumpSym)();
  extern void 	(*Language_Compile_procDumpSymList)();
  extern void 	(*Language_Compile_procTargetType)();
  
  void Language_Compile_OutputIndent ();
  
  extern TLboolean Language_Compile_Scope_AncestorOf ();
  
  extern TLboolean Language_Compile_Scope_AtTopLevel ();
  
  extern TLboolean Language_Compile_Scope_ExpandScopeOk ();
  
  extern struct Language_Compile_ExportDef * Language_Compile_Scope_IdentInExportList ();
  
  extern struct Language_Compile_SymbolDef * Language_Compile_Scope_IdentInImmediateScope ();
  
  extern struct Language_Compile_SymbolDef * Language_Compile_Scope_IdentInImportList ();
  
  extern struct Language_Compile_SymbolDef * Language_Compile_Scope_IdentInList ();
  
  extern struct Language_Compile_SymbolDef * Language_Compile_Scope_IdentInScope ();
  
  extern TLboolean Language_Compile_Scope_InBlock ();
  
  extern void Language_Compile_Scope_DumpBlocks ();
  
  struct Language_Compile_CharDef * Language_Compile_Value_CharValue ();
  
  void Language_Compile_Value_Chr ();
  
  void Language_Compile_Value_ConvertToChar ();
  
  void Language_Compile_Value_ConvertToCharString ();
  
  void Language_Compile_Value_ConvertToReal ();
  
  void Language_Compile_Value_ConvertToString ();
  
  void Language_Compile_Value_EnterSetValue ();
  
  void Language_Compile_Value_Initialize ();
  
  TLint4 Language_Compile_Value_IntValue ();
  
  Language_Compile_ValueKind Language_Compile_Value_Kind ();
  
  void Language_Compile_Value_NonCompileTimeOperation ();
  
  void Language_Compile_Value_Ord ();
  
  void Language_Compile_Value_PerformOperation ();
  
  void Language_Compile_Value_PerformUnaryOperation ();
  
  void Language_Compile_Value_Pop ();
  
  void Language_Compile_Value_Push ();
  
  void Language_Compile_Value_PushCopy ();
  
  void Language_Compile_Value_PushInt ();
  
  void Language_Compile_Value_PushSet ();
  
  void Language_Compile_Value_PushToken ();
  
  TLreal8 Language_Compile_Value_RealValue ();
  
  void Language_Compile_Value_ReplaceLowHighWithEmptySet ();
  
  void Language_Compile_Value_ReplaceLowHighWithSetAll ();
  
  void Language_Compile_Value_ReplaceNonCompileTime ();
  
  void Language_Compile_Value_Save ();
  
  struct Language_Compile_ValueDef * Language_Compile_Value_Second ();
  
  Language_StringDef * Language_Compile_Value_StringValue ();
  
  void Language_Compile_Value_Swap ();
  
  struct Language_Compile_ValueDef * Language_Compile_Value_Top ();
  
  Language_Compile_ValueKind Language_Compile_Value_ValKind ();
  
  struct Language_Compile_TypeDef * Language_Compile_Value_ValueType ();
  
  void Language_Compile_Value_AssertStackEmpty ();
  
  void Language_Compile_Value_DumpValue ();
  
  void Language_Compile_Value_DumpValueStack ();
  static TLint2	Language_Compile_Value_valueTop;
  typedef	struct Language_Compile_ValueDef	*Language_Compile_Value___x2292[30];
  static Language_Compile_Value___x2292	Language_Compile_Value_valueStack;
  static struct Language_Compile_ValueDef	*Language_Compile_Value_freeValueChain;
  
  static void Language_Compile_Value_FreeVal (val)
  register struct Language_Compile_ValueDef	*val;
  {
      TLSTKCHKSLF(100048);
      TLSETF();
      TLSETL(100048);
      if (!(val->saved)) {
  	TLSETL(100049);
  	val->u.valTag = 0;
  	TLINCL();
  	val->u.__u22.__u23.next = Language_Compile_Value_freeValueChain;
  	TLINCL();
  	Language_Compile_Value_freeValueChain = val;
      };
      TLRESTORELF();
  }
  
  void Language_Compile_Value_Save (offset)
  TLint2	offset;
  {
      TLSTKCHKSLF(100057);
      TLSETF();
      TLSETL(100057);
      Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop - offset, 1, 30, 1)]->saved = 1;
      TLRESTORELF();
  }
  
  void Language_Compile_Value_Pop () {
      TLSTKCHKSLF(100063);
      TLSETF();
      TLSETL(100063);
      Language_Compile_Value_FreeVal(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]);
      Language_Compile_Value_valueTop -= 1;
      TLRESTORELF();
  }
  
  static void Language_Compile_Value_PushNew () {
      TLBIND((*newVal), struct Language_Compile_ValueDef *);
      TLSTKCHKSLF(100068);
      TLSETF();
      TLSETL(100068);
      if (Language_Compile_Value_valueTop == 30) {
  	TLSETL(100071);
  	Language_Compile_CompileError_Add((TLint2) 10283, &(Language_Compile_oldTok.srcPos), "", "", (Language_ErrorSeverity) 3);
      };
      TLSETL(100072);
      Language_Compile_Value_valueTop += 1;
      TLSETL(100074);
      newVal = &(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]);
      TLSETL(100076);
      if (Language_Compile_Value_freeValueChain == ((struct Language_Compile_ValueDef *) 0)) {
  	TLSETL(100078);
  	Language_Compile_Memory_Allocate(&((*newVal)), (TLint2) sizeof(struct Language_Compile_ValueDef));
  	(*newVal)->saved = 0;
      } else {
  	TLSETL(100080);
  	(*newVal) = Language_Compile_Value_freeValueChain;
  	TLINCL();
  	Language_Compile_Value_freeValueChain = (*newVal)->u.__u22.__u23.next;
      };
      TLRESTORELF();
  }
  
  void Language_Compile_Value_Push (val)
  struct Language_Compile_ValueDef	*val;
  {
      TLSTKCHKSLF(100087);
      TLSETF();
      TLSETL(100087);
      TLPRE (val != ((struct Language_Compile_ValueDef *) 0));
      TLINCL();
      if (val == Language_Compile_nonCompileTimeValue) {
  	TLSETL(100089);
  	if (Language_Compile_Value_valueTop == 30) {
  	    TLSETL(100092);
  	    Language_Compile_CompileError_Add((TLint2) 10283, &(Language_Compile_oldTok.srcPos), "", "", (Language_ErrorSeverity) 3);
  	};
  	TLSETL(100093);
  	Language_Compile_Value_valueTop += 1;
  	TLINCL();
  	Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)] = Language_Compile_nonCompileTimeValue;
      } else {
  	TLSETL(100097);
  	Language_Compile_Value_PushNew();
  	TLSTRCTASS(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]->u, val->u, struct Language_Compile___x2256);
      };
      TLRESTORELF();
  }
  
  void Language_Compile_Value_PushCopy () {
      TLSTKCHKSLF(100104);
      TLSETF();
      TLSETL(100104);
      Language_Compile_Value_Push(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]);
      TLRESTORELF();
  }
  
  void Language_Compile_Value_PushToken () {
      TLBINDREG((*v), struct Language_Compile___x2256);
      TLSTKCHKSLF(100110);
      TLSETF();
      TLSETL(100110);
      Language_Compile_Value_PushNew();
      v = &(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]->u);
      TLSETL(100112);
      switch (Language_Compile_oldTok.u.tok) {
  	case 1:
  	    {
  		TLSETL(100114);
  		if ((Language_Compile_oldTok.u.__u31.__u32.cstrPtr->len) == 1) {
  		    TLSETL(100115);
  		    (*v).valTag = 3;
  		    TLINCL();
  		    (*v).__u22.__u25.charVal = Language_Compile_oldTok.u.__u31.__u32.cstrPtr->val[(0)];
  		} else {
  		    TLSETL(100118);
  		    (*v).valTag = 4;
  		    TLINCL();
  		    (*v).__u22.__u26.cstrVal = Language_Compile_oldTok.u.__u31.__u32.cstrPtr;
  		};
  	    }
  	    break;
  	case 2:
  	    {
  		TLSETL(100123);
  		(*v).valTag = 5;
  		TLINCL();
  		(*v).__u22.__u27.negative = 0;
  		TLINCL();
  		(*v).__u22.__u27.natVal = Language_Compile_oldTok.u.__u31.__u33.natVal;
  	    }
  	    break;
  	case 3:
  	    {
  		TLSETL(100128);
  		(*v).valTag = 6;
  		TLINCL();
  		(*v).__u22.__u28.realVal = Language_Compile_oldTok.u.__u31.__u34.realVal;
  	    }
  	    break;
  	case 4:
  	    {
  		TLSETL(100132);
  		(*v).valTag = 8;
  		TLINCL();
  		(*v).__u22.__u30.stringVal = Language_Compile_oldTok.u.__u31.__u35.strPtr;
  	    }
  	    break;
  	case 135:
  	    {
  		TLSETL(100136);
  		(*v).valTag = 2;
  		TLINCL();
  		(*v).__u22.__u24.boolVal = 1;
  	    }
  	    break;
  	case 63:
  	    {
  		TLSETL(100140);
  		(*v).valTag = 2;
  		TLINCL();
  		(*v).__u22.__u24.boolVal = 0;
  	    }
  	    break;
  	default:
  	    TLCASEABORT;
      };
      TLRESTORELF();
  }
  
  void Language_Compile_Value_PushInt (intVal)
  TLint4	intVal;
  {
      TLBINDREG((*v), struct Language_Compile___x2256);
      TLSTKCHKSLF(100149);
      TLSETF();
      TLSETL(100149);
      Language_Compile_Value_PushNew();
      v = &(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]->u);
      TLSETL(100151);
      (*v).valTag = 5;
      TLINCL();
      if (intVal < 0) {
  	TLSETL(100153);
  	(*v).__u22.__u27.negative = 1;
  	TLINCL();
  	(*v).__u22.__u27.natVal = - intVal;
      } else {
  	TLSETL(100156);
  	(*v).__u22.__u27.negative = 0;
  	TLINCL();
  	(*v).__u22.__u27.natVal = intVal;
      };
      TLRESTORELF();
  }
  
  void Language_Compile_Value_PushSet () {
      TLBINDREG((*v), struct Language_Compile___x2256);
      TLSTKCHKSLF(100165);
      TLSETF();
      TLSETL(100165);
      Language_Compile_Value_PushNew();
      v = &(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]->u);
      TLSETL(100167);
      (*v).valTag = 7;
      TLINCL();
      (*v).__u22.__u29.setVal = 0x0;
      TLRESTORELF();
  }
  
  void Language_Compile_Value_Swap (a, b)
  TLint2	a;
  TLint2	b;
  {
      register struct Language_Compile_ValueDef	*v;
      TLSTKCHKSLF(100173);
      TLSETF();
      TLSETL(100173);
      v = Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop - a, 1, 30, 1)];
      TLINCL();
      Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop - a, 1, 30, 1)] = Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop - b, 1, 30, 1)];
      TLINCL();
      Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop - b, 1, 30, 1)] = v;
      TLRESTORELF();
  }
  
  void Language_Compile_Value_ReplaceNonCompileTime () {
      TLSTKCHKSLF(100181);
      TLSETF();
      TLSETL(100181);
      Language_Compile_Value_FreeVal(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]);
      Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)] = Language_Compile_nonCompileTimeValue;
      TLRESTORELF();
  }
  
  TLint4 Language_Compile_Value_IntValue (val)
  struct Language_Compile_ValueDef	*val;
  {
      TLBINDREG((*v), struct Language_Compile___x2256);
      TLSTKCHKSLF(100186);
      TLSETF();
      TLSETL(100186);
      v = &(val->u);
      TLSETL(100188);
      switch ((*v).valTag) {
  	case 2:
  	    {
  		TLSETL(100190);
  		TLRESTORELF();
  		return (* (TLnat1 *) &(*v).__u22.__u24.boolVal);
  	    }
  	    break;
  	case 3:
  	    {
  		TLSETL(100192);
  		TLRESTORELF();
  		return (* (TLnat1 *) &(*v).__u22.__u25.charVal);
  	    }
  	    break;
  	case 5:
  	    {
  		TLSETL(100194);
  		if ((*v).__u22.__u27.negative) {
  		    TLSETL(100195);
  		    TLRESTORELF();
  		    return (- ((* (TLint4 *) &(*v).__u22.__u27.natVal)));
  		} else {
  		    TLSETL(100197);
  		    TLRESTORELF();
  		    return ((*v).__u22.__u27.natVal);
  		};
  	    }
  	    break;
  	case 7:
  	    {
  		TLSETL(100200);
  		TLRESTORELF();
  		return (* (TLnat4 *) &(*v).__u22.__u29.setVal);
  	    }
  	    break;
  	default :
  	    {
  		TLSETL(100202);
  		TLRESTORELF();
  		return (0);
  	    }
  	    break;
      };
      TLRESTORELF();
      /* NOTREACHED */
      TLFCNRESULTABORT;
  }
  
  TLreal8 Language_Compile_Value_RealValue (val)
  struct Language_Compile_ValueDef	*val;
  {
      TLBINDREG((*v), struct Language_Compile___x2256);
      TLSTKCHKSLF(100208);
      TLSETF();
      TLSETL(100208);
      v = &(val->u);
      TLSETL(100210);
      if (((*v).valTag) == 6) {
  	TLSETL(100211);
  	TLRESTORELF();
  	return ((*v).__u22.__u28.realVal);
      } else {
  	TLSETL(100213);
  	TLRESTORELF();
  	return (0);
      };
      TLRESTORELF();
      /* NOTREACHED */
      TLFCNRESULTABORT;
  }
  
  Language_StringDef * Language_Compile_Value_StringValue (val)
  struct Language_Compile_ValueDef	*val;
  {
      TLBINDREG((*v), struct Language_Compile___x2256);
      TLSTKCHKSLF(100219);
      TLSETF();
      TLSETL(100219);
      v = &(val->u);
      TLSETL(100221);
      if (((*v).valTag) == 8) {
  	TLSETL(100222);
  	TLRESTORELF();
  	return ((*v).__u22.__u30.stringVal);
      } else {
  	TLSETL(100224);
  	TLRESTORELF();
  	return ((Language_StringDef *) 0);
      };
      TLRESTORELF();
      /* NOTREACHED */
      TLFCNRESULTABORT;
  }
  
  struct Language_Compile_CharDef * Language_Compile_Value_CharValue (val)
  struct Language_Compile_ValueDef	*val;
  {
      TLBINDREG((*v), struct Language_Compile___x2256);
      TLSTKCHKSLF(100230);
      TLSETF();
      TLSETL(100230);
      v = &(val->u);
      TLSETL(100232);
      if (((*v).valTag) == 4) {
  	TLSETL(100233);
  	TLRESTORELF();
  	return ((*v).__u22.__u26.cstrVal);
      } else {
  	TLSETL(100235);
  	TLRESTORELF();
  	return ((struct Language_Compile_CharDef *) 0);
      };
      TLRESTORELF();
      /* NOTREACHED */
      TLFCNRESULTABORT;
  }
  
  void Language_Compile_Value_ConvertToReal () {
      TLBINDREG((*v), struct Language_Compile___x2256);
      TLSTKCHKSLF(100241);
      TLSETF();
      TLSETL(100241);
      v = &(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]->u);
      TLINCL();
      if (((*v).valTag) == 5) {
  	TLnat4	natVal;
  	TLboolean	negative;
  	TLSETL(100243);
  	natVal = (*v).__u22.__u27.natVal;
  	TLINCL();
  	negative = (*v).__u22.__u27.negative;
  	TLSETL(100246);
  	(*v).valTag = 6;
  	TLINCL();
  	(*v).__u22.__u28.realVal = natVal;
  	TLINCL();
  	if (negative) {
  	    TLSETL(100249);
  	    (*v).__u22.__u28.realVal = - ((*v).__u22.__u28.realVal);
  	};
      };
      TLRESTORELF();
  }
  
  void Language_Compile_Value_ConvertToChar () {
      register struct Language_Compile_ValueDef	*v;
      TLSTKCHKSLF(100256);
      TLSETF();
      TLSETL(100256);
      v = Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)];
      TLSETL(100258);
      if (((v->u.valTag) == 8) && (TL_TLS_TLSLEN(((*(v->u.__u22.__u30.stringVal)))) == 1)) {
  	TLchar	t;
  	TLSETL(100260);
  	{
  	    TLchar	__x2294[2];
  	    TL_TLS_TLSBX(__x2294, (TLint4) 1, ((*(v->u.__u22.__u30.stringVal))));
  	    t = TLCVTTOCHR(__x2294);
  	};
  	TLINCL();
  	v->u.valTag = 3;
  	TLINCL();
  	v->u.__u22.__u25.charVal = t;
      } else {
  	TLSETL(100263);
  	if (((v->u.valTag) == 4) && ((v->u.__u22.__u26.cstrVal->len) == 1)) {
  	    TLchar	t;
  	    TLSETL(100265);
  	    t = v->u.__u22.__u26.cstrVal->val[(0)];
  	    TLINCL();
  	    v->u.valTag = 3;
  	    TLINCL();
  	    v->u.__u22.__u25.charVal = t;
  	} else {
  	    TLSETL(100268);
  	    if ((v->u.valTag) != 3) {
  		TLSETL(100270);
  		Language_Compile_Value_ReplaceNonCompileTime();
  	    };
  	};
      };
      TLRESTORELF();
  }
  
  static TLboolean Language_Compile_Value_ValidString (cstrVal)
  struct Language_Compile_CharDef	*cstrVal;
  {
      TLBINDREG((*cstr), struct Language_Compile_CharDef);
      TLSTKCHKSLF(100275);
      TLSETF();
      TLSETL(100275);
      cstr = &((*(cstrVal)));
      TLSETL(100277);
      {
  	register TLint4	i;
  	TLint4	__x2295;
  	__x2295 = (*cstr).len;
  	i = 1;
  	if (i <= __x2295) {
  	    for(;;) {
  		register TLchar	c;
  		TLSETL(100278);
  		c = (*cstr).val[(i - 1)];
  		TLINCL();
  		if ((c == '\0') || (c == (TLchar) '\200')) {
  		    TLSETL(100280);
  		    TLRESTORELF();
  		    return (0);
  		};
  		if (i == __x2295) break;
  		i++;
  	    }
  	};
      };
      TLSETL(100283);
      TLRESTORELF();
      return (1);
      TLRESTORELF();
      /* NOTREACHED */
      TLFCNRESULTABORT;
  }
  
  void Language_Compile_Value_ConvertToString (strSize)
  TLint4	strSize;
  {
      register struct Language_Compile_ValueDef	*v;
      TLSTKCHKSLF(100287);
      TLSETF();
      TLSETL(100287);
      v = Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)];
      TLSETL(100289);
      if ((v->u.valTag) == 3) {
  	TLchar	t;
  	Language_StringDef	*s;
  	TLSETL(100290);
  	t = v->u.__u22.__u25.charVal;
  	TLSETL(100294);
  	Language_Compile_Memory_Allocate(&(s), (TLint2) 2);
  	TLSETL(100296);
  	{
  	    TLchar	__x2296[2];
  	    TLCHRTOSTR(t, __x2296);
  	    strcpy((*(s)), __x2296);
  	};
  	v->u.valTag = 8;
  	TLINCL();
  	v->u.__u22.__u30.stringVal = s;
      } else {
  	TLSETL(100298);
  	if ((((v->u.valTag) == 4) && ((v->u.__u22.__u26.cstrVal->len) <= strSize)) && Language_Compile_Value_ValidString(v->u.__u22.__u26.cstrVal)) {
  	    TLint4	len;
  	    TLstring	t;
  	    Language_StringDef	*s;
  	    TLSETL(100301);
  	    len = v->u.__u22.__u26.cstrVal->len;
  	    TLINCL();
  	    {
  		TLstring	__x2297;
  		TL_TLS_TLSCXX((v->u.__u22.__u26.cstrVal->val), (TLint4) 256, (TLint4) 1, (TLint4) len, __x2297);
  		TLSTRASS(255, t, __x2297);
  	    };
  	    TLSETL(100306);
  	    Language_Compile_Memory_Allocate(&(s), (TLint2) (len + 1));
  	    TLSETL(100308);
  	    strcpy((*(s)), t);
  	    v->u.valTag = 8;
  	    TLINCL();
  	    v->u.__u22.__u30.stringVal = s;
  	} else {
  	    TLSETL(100310);
  	    if ((v->u.valTag) != 8) {
  		TLSETL(100312);
  		Language_Compile_Value_ReplaceNonCompileTime();
  	    };
  	};
      };
      TLRESTORELF();
  }
  
  void Language_Compile_Value_ConvertToCharString (strSize)
  TLint4	strSize;
  {
      register struct Language_Compile_ValueDef	*v;
      TLSTKCHKSLF(100317);
      TLSETF();
      TLSETL(100317);
      v = Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)];
      TLSETL(100319);
      if (((v->u.valTag) == 3) && (strSize == 1)) {
  	TLchar	t;
  	struct Language_Compile_CharDef	*s;
  	TLSETL(100320);
  	t = v->u.__u22.__u25.charVal;
  	TLSETL(100324);
  	Language_Compile_Memory_Allocate(&(s), (TLint2) ((sizeof(struct Language_Compile_CharDef) - 256) + 1));
  	s->len = 1;
  	TLINCL();
  	s->val[(0)] = t;
  	TLSETL(100327);
  	v->u.valTag = 4;
  	TLINCL();
  	v->u.__u22.__u26.cstrVal = s;
      } else {
  	TLSETL(100329);
  	if ((v->u.valTag) == 8) {
  	    TLstring	t;
  	    TLint4	len;
  	    TLSETL(100330);
  	    TLSTRASS(255, t, (*(v->u.__u22.__u30.stringVal)));
  	    TLINCL();
  	    len = TL_TLS_TLSLEN(t);
  	    TLSETL(100333);
  	    if (len == strSize) {
  		struct Language_Compile_CharDef	*s;
  		TLSETL(100337);
  		Language_Compile_Memory_Allocate(&(s), (TLint2) ((sizeof(struct Language_Compile_CharDef) - 256) + len));
  		s->len = len;
  		TLINCL();
  		{
  		    register TLint4	i;
  		    TLint4	__x2298;
  		    __x2298 = len;
  		    i = 1;
  		    if (i <= __x2298) {
  			for(;;) {
  			    typedef	TLchar	__x2299[1000];
  			    TLSETL(100339);
  			    s->val[(i - 1)] = (* (__x2299 *) t)[(i - 1)];
  			    if (i == __x2298) break;
  			    i++;
  			}
  		    };
  		};
  		TLSETL(100342);
  		v->u.valTag = 4;
  		TLINCL();
  		v->u.__u22.__u26.cstrVal = s;
  	    } else {
  		TLSETL(100346);
  		Language_Compile_Value_ReplaceNonCompileTime();
  	    };
  	} else {
  	    TLSETL(100347);
  	    if ((v->u.valTag) != 4) {
  		TLSETL(100349);
  		Language_Compile_Value_ReplaceNonCompileTime();
  	    };
  	};
      };
      TLRESTORELF();
  }
  
  void Language_Compile_Value_EnterSetValue () {
      register TLint4	low;
      register TLint4	high;
      TLBINDREG((*vSet), struct Language_Compile_ValueDef *);
      TLBINDREG((*val), struct Language_Compile_ValueDef *);
      TLint4	setVal;
      TLSTKCHKSLF(100354);
      TLSETF();
      TLSETL(100354);
      low = Language_Compile_Value_IntValue(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop - 2, 1, 30, 1)]);
      TLINCL();
      high = Language_Compile_Value_IntValue(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop - 1, 1, 30, 1)]);
      TLSETL(100357);
      vSet = &(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop - 3, 1, 30, 1)]);
      val = &(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]);
      TLSETL(100360);
      setVal = Language_Compile_Value_IntValue((*val));
      TLSETL(100362);
      if (((*vSet)->u.valTag) == 1) {
      } else {
  	TLSETL(100364);
  	if (((high - low) > 31) || ((((*val)->u.valTag) != 5) && (((*val)->u.valTag) != 3))) {
  	    TLSETL(100367);
  	    Language_Compile_Value_FreeVal((*vSet));
  	    (*vSet) = Language_Compile_nonCompileTimeValue;
  	} else {
  	    TLSETL(100368);
  	    if ((setVal < low) || (setVal > high)) {
  		TLSETL(100371);
  		Language_Compile_CompileError_Add((TLint2) 10318, &(Language_Compile_oldTok.srcPos), "", "", (Language_ErrorSeverity) 2);
  	    } else {
  		TLSETL(100372);
  		(*vSet)->u.__u22.__u29.setVal |= (TLSMLSETCONST(TLINRANGELOW(setVal - low, 0, 31, 19)));
  	    };
  	};
      };
      TLRESTORELF();
  }
  
  void Language_Compile_Value_ReplaceLowHighWithSetAll () {
      register TLint4	low;
      register TLint4	high;
      TLSTKCHKSLF(100378);
      TLSETF();
      TLSETL(100378);
      low = Language_Compile_Value_IntValue(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop - 1, 1, 30, 1)]);
      TLINCL();
      high = Language_Compile_Value_IntValue(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]);
      TLSETL(100382);
      Language_Compile_Value_Pop();
      if ((high - low) < 32) {
  	TLBINDREG((*v), struct Language_Compile___x2256);
  	TLSETL(100383);
  	v = &(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]->u);
  	TLSETL(100385);
  	(*v).valTag = 7;
  	TLINCL();
  	(*v).__u22.__u29.setVal = 0x0;
  	TLSETL(100388);
  	{
  	    register TLint4	i;
  	    TLint4	__x2301;
  	    __x2301 = high - low;
  	    i = 0;
  	    if (i <= __x2301) {
  		for(;;) {
  		    TLSETL(100389);
  		    (*v).__u22.__u29.setVal |= (TLSMLSETCONST(TLINRANGELOW(i, 0, 31, 19)));
  		    if (i == __x2301) break;
  		    i++;
  		}
  	    };
  	};
      } else {
  	TLSETL(100393);
  	Language_Compile_Value_ReplaceNonCompileTime();
      };
      TLRESTORELF();
  }
  
  void Language_Compile_Value_ReplaceLowHighWithEmptySet () {
      register TLint4	low;
      register TLint4	high;
      TLSTKCHKSLF(100398);
      TLSETF();
      TLSETL(100398);
      low = Language_Compile_Value_IntValue(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop - 1, 1, 30, 1)]);
      TLINCL();
      high = Language_Compile_Value_IntValue(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]);
      TLSETL(100402);
      Language_Compile_Value_Pop();
      if ((high - low) < 32) {
  	TLBINDREG((*v), struct Language_Compile___x2256);
  	TLSETL(100403);
  	v = &(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]->u);
  	TLSETL(100405);
  	(*v).valTag = 7;
  	TLINCL();
  	(*v).__u22.__u29.setVal = 0x0;
      } else {
  	TLSETL(100409);
  	Language_Compile_Value_ReplaceNonCompileTime();
      };
      TLRESTORELF();
  }
  
  static void Language_Compile_Value_StringConcatanate (vl, vr)
  register struct Language_Compile_ValueDef	*vl;
  struct Language_Compile_ValueDef	*vr;
  {
      TLstring	left;
      TLstring	right;
      TLint4	lSize;
      TLint4	rSize;
      Language_StringDef	*t;
      TLSTKCHKSLF(100417);
      TLSETF();
      TLSETL(100417);
      if (((*vl).u.valTag) == 8) {
  	TLSETL(100418);
  	TLSTRASS(255, left, (*((*vl).u.__u22.__u30.stringVal)));
  	TLINCL();
  	lSize = TL_TLS_TLSLEN(left);
      } else {
  	TLSETL(100420);
  	if (((*vl).u.valTag) == 3) {
  	    TLSETL(100421);
  	    {
  		TLchar	__x2302[2];
  		TLCHRTOSTR((*vl).u.__u22.__u25.charVal, __x2302);
  		TLSTRASS(255, left, __x2302);
  	    };
  	    TLINCL();
  	    lSize = 1;
  	} else {
  	    TLSETL(100424);
  	    lSize = (*vl).u.__u22.__u26.cstrVal->len;
  	    TLINCL();
  	    {
  		TLstring	__x2303;
  		TL_TLS_TLSCXX(((*vl).u.__u22.__u26.cstrVal->val), (TLint4) 256, (TLint4) 1, (TLint4) lSize, __x2303);
  		TLSTRASS(255, left, __x2303);
  	    };
  	};
      };
      TLSETL(100428);
      if (((*vr).u.valTag) == 8) {
  	TLSETL(100429);
  	TLSTRASS(255, right, (*((*vr).u.__u22.__u30.stringVal)));
  	TLINCL();
  	rSize = TL_TLS_TLSLEN(right);
      } else {
  	TLSETL(100431);
  	if (((*vr).u.valTag) == 3) {
  	    TLSETL(100432);
  	    {
  		TLchar	__x2304[2];
  		TLCHRTOSTR((*vr).u.__u22.__u25.charVal, __x2304);
  		TLSTRASS(255, right, __x2304);
  	    };
  	    TLINCL();
  	    rSize = 1;
  	} else {
  	    TLSETL(100435);
  	    rSize = (*vr).u.__u22.__u26.cstrVal->len;
  	    TLINCL();
  	    {
  		TLstring	__x2305;
  		TL_TLS_TLSCXX(((*vr).u.__u22.__u26.cstrVal->val), (TLint4) 256, (TLint4) 1, (TLint4) rSize, __x2305);
  		TLSTRASS(255, right, __x2305);
  	    };
  	};
      };
      TLSETL(100440);
      if ((lSize + rSize) <= 255) {
  	TLSETL(100442);
  	Language_Compile_Memory_Allocate(&(t), (TLint2) ((lSize + rSize) + 1));
  	TLINCL();
  	{
  	    TLstring	__x2306;
  	    TL_TLS_TLSCAT(left, right, __x2306);
  	    strcpy((*(t)), __x2306);
  	};
      } else {
  	TLSETL(100446);
  	Language_Compile_CompileError_Add((TLint2) 10254, &(Language_Compile_oldTok.srcPos), "", "", (Language_ErrorSeverity) 1);
  	TLINCL();
  	Language_Compile_Value_Pop();
  	TLINCL();
  	Language_Compile_Value_ReplaceNonCompileTime();
  	TLINCL();
  	TLRESTORELF();
  	return;
      };
      TLSETL(100450);
      (*vl).u.valTag = 8;
      TLINCL();
      (*vl).u.__u22.__u30.stringVal = t;
      TLSETL(100453);
      Language_Compile_Value_Pop();
      TLRESTORELF();
  }
  
  static void Language_Compile_Value_NegateValue () {
      register struct Language_Compile_ValueDef	*v;
      TLSTKCHKSLF(100457);
      TLSETF();
      TLSETL(100457);
      v = Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)];
      TLSETL(100459);
      if ((v->u.valTag) == 5) {
  	TLSETL(100460);
  	if ((v->u.__u22.__u27.natVal) != 0) {
  	    TLSETL(100461);
  	    v->u.__u22.__u27.negative = !(v->u.__u22.__u27.negative);
  	};
      } else {
  	TLSETL(100463);
  	if ((v->u.valTag) == 6) {
  	    TLSETL(100464);
  	    v->u.__u22.__u28.realVal = - (v->u.__u22.__u28.realVal);
  	} else {
  	    TLSETL(100467);
  	    Language_Compile_Value_ReplaceNonCompileTime();
  	};
      };
      TLRESTORELF();
  }
  
  static void Language_Compile_Value_IntegerOverflow () {
      TLSTKCHKSLF(100474);
      TLSETF();
      TLSETL(100474);
      Language_Compile_CompileError_Add((TLint2) 10316, &(Language_Compile_oldTok.srcPos), "", "", (Language_ErrorSeverity) 1);
      TLINCL();
      Language_Compile_Value_Pop();
      TLINCL();
      Language_Compile_Value_ReplaceNonCompileTime();
      TLRESTORELF();
  }
  
  static void Language_Compile_Value_AddValues (vl, vr)
  register struct Language_Compile_ValueDef	*vl;
  struct Language_Compile_ValueDef	*vr;
  {
      register TLnat4	left;
      register TLnat4	right;
      TLSTKCHKSLF(100480);
      TLSETF();
      TLSETL(100480);
      left = vl->u.__u22.__u27.natVal;
      TLINCL();
      right = vr->u.__u22.__u27.natVal;
      TLSETL(100483);
      if ((vl->u.__u22.__u27.negative) == (vr->u.__u22.__u27.negative)) {
  	TLSETL(100485);
  	if ((0xFFFFFFFE - left) < right) {
  	    TLSETL(100487);
  	    Language_Compile_Value_IntegerOverflow();
  	    TLINCL();
  	    TLRESTORELF();
  	    return;
  	};
  	TLSETL(100489);
  	vl->u.__u22.__u27.natVal += right;
      } else {
  	TLSETL(100492);
  	if (vl->u.__u22.__u27.negative) {
  	    TLSETL(100494);
  	    if (left <= right) {
  		TLSETL(100496);
  		vl->u.__u22.__u27.negative = 0;
  		TLINCL();
  		vl->u.__u22.__u27.natVal = right - left;
  	    } else {
  		TLSETL(100499);
  		vl->u.__u22.__u27.natVal -= right;
  	    };
  	} else {
  	    TLSETL(100503);
  	    if (left < right) {
  		TLSETL(100505);
  		vl->u.__u22.__u27.negative = 1;
  		TLINCL();
  		vl->u.__u22.__u27.natVal = right - left;
  	    } else {
  		TLSETL(100508);
  		vl->u.__u22.__u27.natVal -= right;
  	    };
  	};
      };
      TLSETL(100512);
      if ((vl->u.__u22.__u27.negative) && ((vl->u.__u22.__u27.natVal) > 2147483647)) {
  	TLSETL(100514);
  	Language_Compile_Value_IntegerOverflow();
      } else {
  	TLSETL(100516);
  	Language_Compile_Value_Pop();
      };
      TLRESTORELF();
  }
  
  void Language_Compile_Value_PerformOperation (operation)
  Language_Compile_Tok	operation;
  {
      register struct Language_Compile_ValueDef	*vl;
      register struct Language_Compile_ValueDef	*vr;
      TLSTKCHKSLF(100521);
      TLSETF();
      TLSETL(100521);
      if (((Language_Compile_Value_valueStack[Language_Compile_Value_valueTop - 1]) == Language_Compile_nonCompileTimeValue) || ((Language_Compile_Value_valueStack[(Language_Compile_Value_valueTop - 1) - 1]) == Language_Compile_nonCompileTimeValue)) {
  	TLSETL(100524);
  	Language_Compile_Value_Pop();
  	TLINCL();
  	Language_Compile_Value_ReplaceNonCompileTime();
  	TLINCL();
  	TLRESTORELF();
  	return;
      };
      TLSETL(100528);
      vl = Language_Compile_Value_valueStack[(Language_Compile_Value_valueTop - 1) - 1];
      TLINCL();
      vr = Language_Compile_Value_valueStack[Language_Compile_Value_valueTop - 1];
      TLSETL(100533);
      if (operation == 24) {
  	TLSETL(100534);
  	if (((vl->u.valTag) == 5) && ((vr->u.valTag) == 5)) {
  	    TLSETL(100537);
  	    Language_Compile_Value_AddValues(vl, vr);
  	} else {
  	    TLSETL(100537);
  	    if (((((vl->u.valTag) == 3) || ((vl->u.valTag) == 4)) || ((vl->u.valTag) == 8)) && ((((vr->u.valTag) == 3) || ((vr->u.valTag) == 4)) || ((vr->u.valTag) == 8))) {
  		TLSETL(100544);
  		Language_Compile_Value_StringConcatanate(&((*(vl))), &((*(vr))));
  	    } else {
  		TLSETL(100546);
  		Language_Compile_Value_Pop();
  		TLINCL();
  		Language_Compile_Value_ReplaceNonCompileTime();
  	    };
  	};
      } else {
  	TLSETL(100548);
  	if (((vl->u.valTag) == 5) && ((vr->u.valTag) == 5)) {
  	    TLSETL(100550);
  	    switch (operation) {
  		case 5:
  		case 33:
  		    {
  			TLSETL(100552);
  			vl->u.__u22.__u27.natVal &= vr->u.__u22.__u27.natVal;
  			TLINCL();
  			vl->u.__u22.__u27.negative = 0;
  		    }
  		    break;
  		case 55:
  		    {
  			register TLnat4	right;
  			TLSETL(100556);
  			right = vr->u.__u22.__u27.natVal;
  			TLSETL(100558);
  			if (right == 0) {
  			    TLSETL(100561);
  			    Language_Compile_CompileError_Add((TLint2) 10057, &(Language_Compile_oldTok.srcPos), "", "", (Language_ErrorSeverity) 1);
  			    TLINCL();
  			    Language_Compile_Value_Pop();
  			    TLINCL();
  			    Language_Compile_Value_ReplaceNonCompileTime();
  			    TLINCL();
  			    TLRESTORELF();
  			    return;
  			} else {
  			    TLSETL(100565);
  			    if ((vl->u.__u22.__u27.negative) == (vr->u.__u22.__u27.negative)) {
  				TLSETL(100566);
  				vl->u.__u22.__u27.negative = 0;
  			    } else {
  				TLSETL(100568);
  				vl->u.__u22.__u27.negative = 1;
  			    };
  			    TLSETL(100571);
  			    vl->u.__u22.__u27.natVal /= right;
  			    TLINCL();
  			    if ((vl->u.__u22.__u27.natVal) == 0) {
  				TLSETL(100573);
  				vl->u.__u22.__u27.negative = 0;
  			    } else {
  				TLSETL(100574);
  				if ((vl->u.__u22.__u27.negative) && ((vl->u.__u22.__u27.natVal) > 2147483647)) {
  				    TLSETL(100577);
  				    Language_Compile_Value_IntegerOverflow();
  				    TLINCL();
  				    TLRESTORELF();
  				    return;
  				};
  			    };
  			};
  		    }
  		    break;
  		case 22:
  		    {
  			TLSETL(100583);
  			Language_Compile_Value_NegateValue();
  			TLINCL();
  			Language_Compile_Value_AddValues(vl, vr);
  			TLSETL(100586);
  			TLRESTORELF();
  			return;
  		    }
  		    break;
  		case 87:
  		    {
  			register TLnat4	right;
  			TLSETL(100587);
  			right = vr->u.__u22.__u27.natVal;
  			TLSETL(100589);
  			if (right == 0) {
  			    TLSETL(100592);
  			    Language_Compile_CompileError_Add((TLint2) 10057, &(Language_Compile_oldTok.srcPos), "", "", (Language_ErrorSeverity) 1);
  			    TLINCL();
  			    Language_Compile_Value_Pop();
  			    TLINCL();
  			    Language_Compile_Value_ReplaceNonCompileTime();
  			    TLINCL();
  			    TLRESTORELF();
  			    return;
  			};
  			TLSETL(100596);
  			vl->u.__u22.__u27.natVal %= right;
  			TLINCL();
  			if ((vl->u.__u22.__u27.natVal) == 0) {
  			    TLSETL(100598);
  			    vl->u.__u22.__u27.negative = 0;
  			} else {
  			    TLSETL(100600);
  			    if ((vl->u.__u22.__u27.negative) != (vr->u.__u22.__u27.negative)) {
  				TLSETL(100601);
  				vl->u.__u22.__u27.natVal = right - (vl->u.__u22.__u27.natVal);
  			    };
  			    TLSETL(100603);
  			    vl->u.__u22.__u27.negative = vr->u.__u22.__u27.negative;
  			    TLINCL();
  			    if ((vl->u.__u22.__u27.negative) && ((vl->u.__u22.__u27.natVal) > 2147483647)) {
  				TLSETL(100607);
  				Language_Compile_Value_IntegerOverflow();
  				TLINCL();
  				TLRESTORELF();
  				return;
  			    };
  			};
  		    }
  		    break;
  		case 100:
  		case 23:
  		    {
  			TLSETL(100612);
  			vl->u.__u22.__u27.natVal |= vr->u.__u22.__u27.natVal;
  			TLINCL();
  			vl->u.__u22.__u27.negative = 0;
  		    }
  		    break;
  		case 119:
  		    {
  			register TLnat4	right;
  			TLSETL(100616);
  			right = vr->u.__u22.__u27.natVal;
  			TLSETL(100618);
  			if (right == 0) {
  			    TLSETL(100621);
  			    Language_Compile_CompileError_Add((TLint2) 10057, &(Language_Compile_oldTok.srcPos), "", "", (Language_ErrorSeverity) 1);
  			    TLINCL();
  			    Language_Compile_Value_Pop();
  			    TLINCL();
  			    Language_Compile_Value_ReplaceNonCompileTime();
  			    TLINCL();
  			    TLRESTORELF();
  			    return;
  			};
  			TLSETL(100625);
  			vl->u.__u22.__u27.natVal %= right;
  			TLINCL();
  			if ((vl->u.__u22.__u27.natVal) == 0) {
  			    TLSETL(100627);
  			    vl->u.__u22.__u27.negative = 0;
  			} else {
  			    TLSETL(100628);
  			    if ((vl->u.__u22.__u27.negative) && ((vl->u.__u22.__u27.natVal) > 2147483647)) {
  				TLSETL(100631);
  				Language_Compile_Value_IntegerOverflow();
  				TLINCL();
  				TLRESTORELF();
  				return;
  			    };
  			};
  		    }
  		    break;
  		case 125:
  		    {
  			TLSETL(100635);
  			if (vr->u.__u22.__u27.negative) {
  			    TLSETL(100638);
  			    Language_Compile_CompileError_Add((TLint2) 10049, &(Language_Compile_oldTok.srcPos), "", "", (Language_ErrorSeverity) 2);
  			} else {
  			    TLSETL(100639);
  			    vl->u.__u22.__u27.natVal <<= vr->u.__u22.__u27.natVal;
  			    TLINCL();
  			    vl->u.__u22.__u27.negative = 0;
  			};
  		    }
  		    break;
  		case 126:
  		    {
  			TLSETL(100644);
  			if (vr->u.__u22.__u27.negative) {
  			    TLSETL(100647);
  			    Language_Compile_CompileError_Add((TLint2) 10049, &(Language_Compile_oldTok.srcPos), "", "", (Language_ErrorSeverity) 2);
  			} else {
  			    TLSETL(100648);
  			    vl->u.__u22.__u27.natVal >>= vr->u.__u22.__u27.natVal;
  			    TLINCL();
  			    vl->u.__u22.__u27.negative = 0;
  			};
  		    }
  		    break;
  		case 28:
  		    {
  			register TLnat4	left;
  			register TLnat4	right;
  			TLSETL(100653);
  			left = vl->u.__u22.__u27.natVal;
  			TLINCL();
  			right = vr->u.__u22.__u27.natVal;
  			TLSETL(100656);
  			if ((left == 0) || (right == 0)) {
  			    TLSETL(100657);
  			    vl->u.__u22.__u27.negative = 0;
  			    TLINCL();
  			    vl->u.__u22.__u27.natVal = 0;
  			} else {
  			    TLSETL(100660);
  			    if ((vl->u.__u22.__u27.negative) == (vr->u.__u22.__u27.negative)) {
  				TLSETL(100661);
  				vl->u.__u22.__u27.negative = 0;
  			    } else {
  				TLSETL(100663);
  				vl->u.__u22.__u27.negative = 1;
  			    };
  			    TLSETL(100666);
  			    if ((0xFFFFFFFE / left) < right) {
  				TLSETL(100668);
  				Language_Compile_Value_IntegerOverflow();
  				TLINCL();
  				TLRESTORELF();
  				return;
  			    } else {
  				TLSETL(100670);
  				vl->u.__u22.__u27.natVal *= right;
  			    };
  			    TLSETL(100672);
  			    if ((vl->u.__u22.__u27.negative) && ((vl->u.__u22.__u27.natVal) > 2147483647)) {
  				TLSETL(100675);
  				Language_Compile_Value_IntegerOverflow();
  				TLINCL();
  				TLRESTORELF();
  				return;
  			    };
  			};
  		    }
  		    break;
  		case 144:
  		    {
  			TLSETL(100680);
  			vl->u.__u22.__u27.natVal ^= vr->u.__u22.__u27.natVal;
  			TLINCL();
  			vl->u.__u22.__u27.negative = 0;
  		    }
  		    break;
  	    };
  	    TLSETL(100684);
  	    Language_Compile_Value_Pop();
  	} else {
  	    TLSETL(100686);
  	    Language_Compile_Value_Pop();
  	    TLINCL();
  	    Language_Compile_Value_ReplaceNonCompileTime();
  	};
      };
      TLRESTORELF();
  }
  
  void Language_Compile_Value_PerformUnaryOperation (operation)
  Language_Compile_Tok	operation;
  {
      TLSTKCHKSLF(100692);
      TLSETF();
      TLSETL(100692);
      if (operation == 155) {
  	TLSETL(100694);
  	TLRESTORELF();
  	return;
      } else {
  	TLSETL(100694);
  	if (operation == 154) {
  	    TLSETL(100696);
  	    Language_Compile_Value_NegateValue();
  	} else {
  	    TLSETL(100698);
  	    Language_Compile_Value_ReplaceNonCompileTime();
  	};
      };
      TLRESTORELF();
  }
  
  void Language_Compile_Value_Ord () {
      register struct Language_Compile_ValueDef	*v;
      TLSTKCHKSLF(100703);
      TLSETF();
      TLSETL(100703);
      v = Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)];
      TLSETL(100705);
      switch (v->u.valTag) {
  	case 2:
  	    {
  		TLint4	t;
  		TLSETL(100707);
  		t = * (TLnat1 *) &v->u.__u22.__u24.boolVal;
  		TLSETL(100709);
  		Language_Compile_Value_Pop();
  		TLINCL();
  		Language_Compile_Value_PushInt((TLint4) t);
  	    }
  	    break;
  	case 3:
  	    {
  		TLint4	t;
  		TLSETL(100711);
  		t = * (TLnat1 *) &v->u.__u22.__u25.charVal;
  		TLSETL(100713);
  		Language_Compile_Value_Pop();
  		TLINCL();
  		Language_Compile_Value_PushInt((TLint4) t);
  	    }
  	    break;
  	case 5:
  	    break;
  	case 8:
  	    {
  		TLSETL(100716);
  		if (TL_TLS_TLSLEN(((*(v->u.__u22.__u30.stringVal)))) == 1) {
  		    TLint4	t;
  		    TLSETL(100717);
  		    t = ((TLnat4) TLCVTTOCHR((*(v->u.__u22.__u30.stringVal))));
  		    TLSETL(100719);
  		    Language_Compile_Value_Pop();
  		    TLINCL();
  		    Language_Compile_Value_PushInt((TLint4) t);
  		} else {
  		    TLSETL(100722);
  		    Language_Compile_Value_ReplaceNonCompileTime();
  		};
  	    }
  	    break;
  	default :
  	    {
  		TLSETL(100725);
  		Language_Compile_Value_ReplaceNonCompileTime();
  	    }
  	    break;
      };
      TLRESTORELF();
  }
  
  void Language_Compile_Value_Chr () {
      register struct Language_Compile_ValueDef	*v;
      TLSTKCHKSLF(100730);
      TLSETF();
      TLSETL(100730);
      v = Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)];
      TLSETL(100732);
      if ((((v->u.valTag) == 5) && (!(v->u.__u22.__u27.negative))) && ((v->u.__u22.__u27.natVal) < 256)) {
  	TLchar	t;
  	TLSETL(100734);
  	t = ((TLchar) (v->u.__u22.__u27.natVal));
  	TLINCL();
  	v->u.valTag = 3;
  	TLINCL();
  	v->u.__u22.__u25.charVal = t;
      } else {
  	TLSETL(100739);
  	Language_Compile_Value_ReplaceNonCompileTime();
      };
      TLRESTORELF();
  }
  
  void Language_Compile_Value_NonCompileTimeOperation () {
      TLSTKCHKSLF(100745);
      TLSETF();
      TLSETL(100745);
      Language_Compile_Value_Pop();
      TLINCL();
      Language_Compile_Value_ReplaceNonCompileTime();
      TLRESTORELF();
  }
  
  Language_Compile_ValueKind Language_Compile_Value_ValKind (val)
  struct Language_Compile_ValueDef	*val;
  {
      TLSTKCHKSLF(100750);
      TLSETF();
      TLSETL(100750);
      TLRESTORELF();
      return (val->u.valTag);
      TLRESTORELF();
      /* NOTREACHED */
      TLFCNRESULTABORT;
  }
  
  Language_Compile_ValueKind Language_Compile_Value_Kind () {
      TLSTKCHKSLF(100755);
      TLSETF();
      TLSETL(100755);
      TLRESTORELF();
      return (Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]->u.valTag);
      TLRESTORELF();
      /* NOTREACHED */
      TLFCNRESULTABORT;
  }
  
  struct Language_Compile_TypeDef * Language_Compile_Value_ValueType () {
      TLBINDREG((*v), struct Language_Compile___x2256);
      TLSTKCHKSLF(100760);
      TLSETF();
      TLSETL(100760);
      TLPRE ((Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]->u.valTag) == 5);
      TLSETL(100762);
      v = &(Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]->u);
      TLSETL(100764);
      if ((*v).__u22.__u27.negative) {
  	TLSETL(100765);
  	TLRESTORELF();
  	return (Language_Compile_predType[2]);
      } else {
  	TLSETL(100766);
  	if (((*v).__u22.__u27.natVal) <= 2147483647) {
  	    TLSETL(100767);
  	    TLRESTORELF();
  	    return (Language_Compile_predType[18]);
  	} else {
  	    TLSETL(100769);
  	    TLRESTORELF();
  	    return (Language_Compile_predType[19]);
  	};
      };
      TLRESTORELF();
      /* NOTREACHED */
      TLFCNRESULTABORT;
  }
  
  struct Language_Compile_ValueDef * Language_Compile_Value_Top () {
      TLSTKCHKSLF(100775);
      TLSETF();
      TLSETL(100775);
      TLRESTORELF();
      return (Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop, 1, 30, 1)]);
      TLRESTORELF();
      /* NOTREACHED */
      TLFCNRESULTABORT;
  }
  
  struct Language_Compile_ValueDef * Language_Compile_Value_Second () {
      TLSTKCHKSLF(100780);
      TLSETF();
      TLSETL(100780);
      TLRESTORELF();
      return (Language_Compile_Value_valueStack[TLINRANGELOW(Language_Compile_Value_valueTop - 1, 1, 30, 1)]);
      TLRESTORELF();
      /* NOTREACHED */
      TLFCNRESULTABORT;
  }
  
  void Language_Compile_Value_DumpValue (val, file, indent)
  struct Language_Compile_ValueDef	*val;
  TLint4	file;
  TLnat4	indent;
  {
      TLBINDREG((*v), struct Language_Compile___x2256);
      TLSTKCHKSLF(100788);
      TLSETF();
      TLSETL(100788);
      Language_Compile_OutputIndent((TLint4) file, (TLnat4) indent);
      if (val == ((struct Language_Compile_ValueDef *) 0)) {
  	TLSETL(100789);
  	TL_TLI_TLISS ((TLint4) file, (TLint2) 2);
  	TL_TLI_TLIPS ((TLint4) 0, "(nil value)", (TLint2) file);
  	TL_TLI_TLIPK ((TLint2) file);
  	TLSETL(100791);
  	TLRESTORELF();
  	return;
      };
      TLSETL(100793);
      v = &(val->u);
      TLSETL(100795);
      TL_TLI_TLISS ((TLint4) file, (TLint2) 2);
      TL_TLI_TLIPS ((TLint4) 0, (Language_Compile_ValueKindName[TLINRANGELOW((*v).valTag, 0, 8, 1)]), (TLint2) file);
      TL_TLI_TLIPS ((TLint4) 0, "(", (TLint2) file);
      TLSETL(100797);
      switch ((*v).valTag) {
  	case 3:
  	    {
  		TLSETL(100799);
  		{
  		    TLstring	__x2307;
  		    Language_Compile_CleanChar((TLchar) ((*v).__u22.__u25.charVal), __x2307);
  		    TL_TLI_TLISS ((TLint4) file, (TLint2) 2);
  		    TL_TLI_TLIPS ((TLint4) 0, "\'", (TLint2) file);
  		    TL_TLI_TLIPS ((TLint4) 0, __x2307, (TLint2) file);
  		    TL_TLI_TLIPS ((TLint4) 0, "\'", (TLint2) file);
  		};
  	    }
  	    break;
  	case 4:
  	    {
  		TLSETL(100802);
  		{
  		    TLstring	__x2308;
  		    Language_Compile_CleanCString((*v).__u22.__u26.cstrVal, __x2308);
  		    TL_TLI_TLISS ((TLint4) file, (TLint2) 2);
  		    TL_TLI_TLIPS ((TLint4) 0, "\'", (TLint2) file);
  		    TL_TLI_TLIPS ((TLint4) 0, __x2308, (TLint2) file);
  		    TL_TLI_TLIPS ((TLint4) 0, "\'", (TLint2) file);
  		};
  	    }
  	    break;
  	case 5:
  	    {
  		TLSETL(100805);
  		if ((*v).__u22.__u27.negative) {
  		    TLSETL(100806);
  		    TL_TLI_TLISS ((TLint4) file, (TLint2) 2);
  		    TL_TLI_TLIPS ((TLint4) 0, "-", (TLint2) file);
  		    TL_TLI_TLIPN ((TLint4) 0, (TLnat4) ((*v).__u22.__u27.natVal), (TLint2) file);
  		} else {
  		    TLSETL(100808);
  		    TL_TLI_TLISS ((TLint4) file, (TLint2) 2);
  		    TL_TLI_TLIPN ((TLint4) 0, (TLnat4) ((*v).__u22.__u27.natVal), (TLint2) file);
  		};
  	    }
  	    break;
  	case 6:
  	    {
  		TLSETL(100812);
  		TL_TLI_TLISS ((TLint4) file, (TLint2) 2);
  		TL_TLI_TLIPR ((TLint4) 0, (TLreal8) ((*v).__u22.__u28.realVal), (TLint2) file);
  	    }
  	    break;
  	case 2:
  	    {
  		TLSETL(100815);
  		if ((*v).__u22.__u24.boolVal) {
  		    TLSETL(100816);
  		    TL_TLI_TLISS ((TLint4) file, (TLint2) 2);
  		    TL_TLI_TLIPS ((TLint4) 0, "true", (TLint2) file);
  		} else {
  		    TLSETL(100818);
  		    TL_TLI_TLISS ((TLint4) file, (TLint2) 2);
  		    TL_TLI_TLIPS ((TLint4) 0, "false", (TLint2) file);
  		};
  	    }
  	    break;
  	case 8:
  	    {
  		TLSETL(100822);
  		TL_TLI_TLISS ((TLint4) file, (TLint2) 2);
  		TL_TLI_TLIPS ((TLint4) 0, "\"", (TLint2) file);
  		TL_TLI_TLIPS ((TLint4) 0, ((*((*v).__u22.__u30.stringVal))), (TLint2) file);
  		TL_TLI_TLIPS ((TLint4) 0, "\"", (TLint2) file);
  	    }
  	    break;
  	case 7:
  	    {
  		TLSETL(100825);
  		{
  		    register TLint4	i;
  		    for (i = 31; i >= 0; i--) {
  			TLSETL(100826);
  			if ((TLSMLSETCONST(TLINRANGELOW(i, 0, 31, 19)) & ((*v).__u22.__u29.setVal)) != 0) {
  			    TLSETL(100827);
  			    TL_TLI_TLISS ((TLint4) file, (TLint2) 2);
  			    TL_TLI_TLIPS ((TLint4) 0, "1", (TLint2) file);
  			} else {
  			    TLSETL(100829);
  			    TL_TLI_TLISS ((TLint4) file, (TLint2) 2);
  			    TL_TLI_TLIPS ((TLint4) 0, "0", (TLint2) file);
  			};
  		    };
  		};
  	    }
  	    break;
  	default :
  	    break;
      };
      TLSETL(100836);
      TL_TLI_TLISS ((TLint4) file, (TLint2) 2);
      TL_TLI_TLIPS ((TLint4) 0, ")", (TLint2) file);
      TL_TLI_TLIPK ((TLint2) file);
      TLRESTORELF();
  }
  
  void Language_Compile_Value_DumpValueStack (file)
  TLint4	file;
  {
      TLSTKCHKSLF(100841);
      TLSETF();
      TLSETL(100841);
      TL_TLI_TLISS ((TLint4) file, (TLint2) 2);
      TL_TLI_TLIPS ((TLint4) 0, "Value Stack Dump", (TLint2) file);
      TL_TLI_TLIPK ((TLint2) file);
      TLINCL();
      {
  	register TLint4	i;
  	for (i = Language_Compile_Value_valueTop; i >= 1; i--) {
  	    TLSETL(100844);
  	    Language_Compile_Value_DumpValue(Language_Compile_Value_valueStack[TLINRANGELOW(i, 1, 30, 1)], (TLint4) file, (TLnat4) 0);
  	};
      };
      TLSETL(100845);
      TL_TLI_TLISS ((TLint4) file, (TLint2) 2);
      TL_TLI_TLIPS ((TLint4) 0, "", (TLint2) file);
      TL_TLI_TLIPK ((TLint2) file);
      TLRESTORELF();
  }
  
  void Language_Compile_Value_AssertStackEmpty () {
      TLSTKCHKSLF(100850);
      TLSETF();
      TLSETL(100850);
      TLASSERT (Language_Compile_Value_valueTop == 0);
      TLRESTORELF();
  }
  
  void Language_Compile_Value_Initialize () {
      TLSTKCHKSLF(100856);
      TLSETF();
      TLSETL(100856);
      Language_Compile_Value_valueTop = 0;
      TLINCL();
      Language_Compile_Value_freeValueChain = (struct Language_Compile_ValueDef *) 0;
      TLRESTORELF();
  }
  
  void Language_Compile_Value () {
      TLSAVELF();
      TLSETF();
      TLSETL(100015);
      Language_Compile_Value_valueTop = 0;
      TLSETL(100030);
      TL_TLB_TLBNWU(& Language_Compile_nonCompileTimeValue, (TLint4)  sizeof (    struct Language_Compile_ValueDef));
      TLINCL();
      Language_Compile_nonCompileTimeValue->saved = 1;
      TLINCL();
      Language_Compile_nonCompileTimeValue->u.valTag = 1;
      TLSETL(100034);
      TL_TLB_TLBNWU(& Language_Compile_intValueOne, (TLint4)  sizeof (    struct Language_Compile_ValueDef));
      TLINCL();
      Language_Compile_intValueOne->saved = 1;
      TLSETL(100037);
      {
  	TLBINDREG((*v), struct Language_Compile___x2256);
  	v = &(Language_Compile_intValueOne->u);
  	TLINCL();
  	(*v).valTag = 5;
  	TLINCL();
  	(*v).__u22.__u27.natVal = 1;
  	TLINCL();
  	(*v).__u22.__u27.negative = 0;
      };
      TLSETL(100044);
      Language_Compile_Value_freeValueChain = (struct Language_Compile_ValueDef *) 0;
      TLRESTORELF();
  }
  