text: #include "cinterface"
  static struct {
      TLint4	dummy;
      char	dummy2[1360];
  } TLFTAB =
      { 23,
      {'/', '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', '.', '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', '/', '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', '/', '.', '.', '/', '.', '.', '/', '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'
      }};
  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	__x2025[256];
  struct	ErrMsgDef {
      struct ErrMsgDef	*next;
      struct SrcPosition	srcPos;
      __x2025	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	__x2026[20];
  
  extern void Language_EnterPreprocSymbols ();
  
  extern void Language_CompileUnit ();
  
  extern void Language_CompileProgram ();
  
  extern void Language_WriteObjectFile ();
  typedef	TLstring	__x2029[21];
  typedef	TLstring	__x2033[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___x2037[22];
  typedef	Language___x2037	Language___x2036[255];
  extern Language___x2036	Language_OpcodeName;
  struct	Language_CodeHeader {
      TLaddressint	bodyCode;
  };
  struct	Language___x2039 {
      TLint4	lower, range;
  };
  typedef	struct Language___x2039	Language___x2038[255];
  struct	Language_ArrayDescriptor {
      TLnat4	sizeArray;
      TLnat4	sizeElement;
      TLnat4	elementCount;
      TLnat4	numDimensions;
      Language___x2038	dim;
  };
  struct	Language_ForDescriptor {
      TLint4	counter;
      TLint4	right;
      TLint4	step;
      TLaddressint	savedSP;
  };
  typedef	Language_Offset	Language___x2040[1001];
  struct	Language_CaseDescriptor {
      TLint4	lower, upper;
      Language_Offset	otherwise;
      Language___x2040	caseVector;
  };
  struct	Language_PointerDescriptor {
      TLaddressint	dataPtr;
      TLint4	timestamp;
  };
  typedef	TLnat2	Language___x2041[301];
  struct	Language_UnionMapDescriptor {
      TLint4	lower, upper;
      Language___x2041	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	__x2044[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 ();
  
  
  
  
  
  
  typedef	TLnat1	Language_Compile_Tok;
  typedef	TLchar	Language_Compile___x2049[16];
  struct	Language_Compile___x2048 {
      Language_Compile___x2049	Name;
      TLnat2	Precedence;
  };
  typedef	struct Language_Compile___x2048	Language_Compile___x2047[159];
  extern Language_Compile___x2047	Language_Compile_TokData;
  typedef	TLint1	Language_Compile_PPTok;
  typedef	TLchar	Language_Compile___x2051[8];
  typedef	Language_Compile___x2051	Language_Compile___x2050[16];
  extern Language_Compile___x2050	Language_Compile_PPTokName;
  typedef	TLint1	Language_Compile_TypeKind;
  typedef	TLchar	Language_Compile___x2053[16];
  typedef	Language_Compile___x2053	Language_Compile___x2052[33];
  extern Language_Compile___x2052	Language_Compile_TypeKindName;
  typedef	TLchar	Language_Compile___x2055[16];
  typedef	Language_Compile___x2055	Language_Compile___x2054[33];
  extern Language_Compile___x2054	Language_Compile_TypeKindKeyword;
  typedef	TLint1	Language_Compile_TyModes;
  typedef	TLchar	Language_Compile___x2057[12];
  typedef	Language_Compile___x2057	Language_Compile___x2056[10];
  extern Language_Compile___x2056	Language_Compile_TyModeName;
  typedef	TLnat2	Language_Compile_TyModesSet;
  typedef	TLint2	Language_Compile_PredType;
  typedef	Language_Compile_TypeKind	Language_Compile___x2058[27];
  extern Language_Compile___x2058	Language_Compile_PredTypeKind;
  typedef	Language_Compile_TyModesSet	Language_Compile___x2059[27];
  extern Language_Compile___x2059	Language_Compile_PredTypeMode;
  typedef	TLint2	Language_Compile_FormalType;
  typedef	TLint2	Language_Compile_Predef;
  typedef	TLchar	Language_Compile___x2062[20];
  struct	Language_Compile___x2061 {
      Language_Compile___x2062	Name;
      Language_Compile_FormalType	FormalList;
      Language_Compile_PredType	ResultType;
  };
  typedef	struct Language_Compile___x2061	Language_Compile___x2060[25];
  extern Language_Compile___x2060	Language_Compile_PredefData;
  typedef	TLchar	Language_Compile___x2063[256];
  struct	Language_Compile_CharDef {
      TLint4	len;
      Language_Compile___x2063	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___x2065[14];
  typedef	Language_Compile___x2065	Language_Compile___x2064[10];
  extern Language_Compile___x2064	Language_Compile_SymbolKindName;
  typedef	TLint1	Language_Compile_Access;
  typedef	TLchar	Language_Compile___x2067[6];
  typedef	Language_Compile___x2067	Language_Compile___x2066[3];
  extern Language_Compile___x2066	Language_Compile_AccessName;
  typedef	TLint1	Language_Compile_SyAttributes;
  typedef	TLchar	Language_Compile___x2069[16];
  typedef	Language_Compile___x2069	Language_Compile___x2068[20];
  extern Language_Compile___x2068	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___x2071[16];
  typedef	Language_Compile___x2071	Language_Compile___x2070[4];
  extern Language_Compile___x2070	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___x2073[10];
  typedef	Language_Compile___x2073	Language_Compile___x2072[16];
  extern Language_Compile___x2072	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___x2075[12];
  typedef	Language_Compile___x2075	Language_Compile___x2074[10];
  extern Language_Compile___x2074	Language_Compile_BaseName;
  typedef	TLint1	Language_Compile_Indirection;
  typedef	TLchar	Language_Compile___x2077[10];
  typedef	Language_Compile___x2077	Language_Compile___x2076[3];
  extern Language_Compile___x2076	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___x2078 {
      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___x2078	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___x2079 {
      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___x2079	u;
  };
  typedef	TLint1	Language_Compile_ValueKind;
  typedef	TLchar	Language_Compile___x2081[16];
  typedef	Language_Compile___x2081	Language_Compile___x2080[9];
  extern Language_Compile___x2080	Language_Compile_ValueKindName;
  typedef	TLnat4	Language_Compile_ValueSetType;
  struct	Language_Compile___x2082 {
      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___x2082	u;
  };
  struct	Language_Compile___x2083 {
      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___x2083	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___x2104[118];
  extern Language_Compile___x2104	Language_Compile_keywordIdent;
  struct	Language_Compile___x2105 {
      struct Language_Compile_IdentDef	*anyclass;
      struct Language_Compile_IdentDef	*main;
      struct Language_Compile_IdentDef	*unit;
  };
  extern struct Language_Compile___x2105	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	__x2106[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 ();
  
  void Language_Compile_PreScan_VerifyConfiguration ();
  
  void Language_Compile_PreScan_VerifyPredefList ();
  
  static void Language_Compile_PreScan_ScanPredefList () {
      TLSTKCHKSLF(100018);
      TLSETF();
      TLSETL(100018);
      Language_Compile_predefUnit = Language_Compile_compilingUnit;
      TLSETL(100021);
      Language_UnitManager_SetPredef(Language_Compile_compilingUnit);
      TLINCL();
      for(;;) {
  	struct Language_Compile_TokRecord	identTok;
  	void	*unitPtr;
  	TLSETL(100022);
  	if ((Language_Compile_newTok.u.tok) == 149) {
  	    break;
  	};
  	TLSETL(100024);
  	TLSTRCTASS(identTok, Language_Compile_newTok, struct Language_Compile_TokRecord);
  	TLSETL(100027);
  	Language_Compile_GetUnitFile(&(unitPtr));
  	if (unitPtr == Language_Compile_compilingUnit) {
  	    TLSETL(100032);
  	    {
  		TLstring	__x2115;
  		FileManager_FileName((FileManager_FileNoType) Language_UnitManager_FileNo(unitPtr), __x2115);
  		Language_Compile_CompileError_Add((TLint2) 10206, &(identTok.srcPos), __x2115, "", (Language_ErrorSeverity) 3);
  	    };
  	};
  	TLSETL(100034);
  	Language_UnitManager_SetPredef(unitPtr);
  	TLINCL();
  	Language_UnitManager_AddDepend(Language_Compile_compilingUnit, &(unitPtr));
  	if (unitPtr == ((void *) 0)) {
  	    TLSETL(100039);
  	    Language_Compile_CompileError_Add((TLint2) 10317, &(identTok.srcPos), "", "", (Language_ErrorSeverity) 3);
  	};
      };
      TLRESTORELF();
  }
  
  static void Language_Compile_PreScan_ScanConfiguration () {
      TLSTKCHKSLF(100047);
      TLSETF();
      TLSETL(100047);
      Language_UnitManager_SetKind(Language_Compile_compilingUnit, (Language_UnitManager_UnitKind) 3);
      TLINCL();
      Language_Compile_Scanner_Scan();
      if ((Language_Compile_newTok.u.tok) == 4) {
  	void	*mainUnitPtr;
  	struct Language_Compile_TokRecord	identTok;
  	TLSETL(100050);
  	TLSTRCTASS(identTok, Language_Compile_newTok, struct Language_Compile_TokRecord);
  	TLSETL(100052);
  	Language_Compile_GetUnitFile(&(mainUnitPtr));
  	if (mainUnitPtr == Language_Compile_compilingUnit) {
  	    TLSETL(100057);
  	    {
  		TLstring	__x2116;
  		FileManager_FileName((FileManager_FileNoType) Language_UnitManager_FileNo(mainUnitPtr), __x2116);
  		Language_Compile_CompileError_Add((TLint2) 10206, &(identTok.srcPos), __x2116, "", (Language_ErrorSeverity) 3);
  	    };
  	};
  	TLSETL(100059);
  	Language_UnitManager_AddDepend(Language_Compile_compilingUnit, &(mainUnitPtr));
  	if (mainUnitPtr == ((void *) 0)) {
  	    TLSETL(100063);
  	    Language_Compile_CompileError_Add((TLint2) 10317, &(identTok.srcPos), "", "", (Language_ErrorSeverity) 3);
  	};
      } else {
  	TLSETL(100067);
  	Language_Compile_DemandToken((Language_Compile_Tok) 4);
      };
      TLSETL(100070);
      for(;;) {
  	struct Language_Compile_TokRecord	identTok;
  	void	*stubUnit;
  	void	*bodyUnit;
  	void	*currentBody;
  	TLSETL(100070);
  	if ((Language_Compile_newTok.u.tok) != 74) {
  	    break;
  	};
  	TLSETL(100073);
  	Language_Compile_Scanner_Scan();
  	TLSETL(100076);
  	TLSTRCTASS(identTok, Language_Compile_newTok, struct Language_Compile_TokRecord);
  	TLSETL(100078);
  	Language_Compile_GetUnitFile(&(stubUnit));
  	if (stubUnit == Language_Compile_compilingUnit) {
  	    TLSETL(100083);
  	    {
  		TLstring	__x2117;
  		FileManager_FileName((FileManager_FileNoType) Language_UnitManager_FileNo(stubUnit), __x2117);
  		Language_Compile_CompileError_Add((TLint2) 10206, &(identTok.srcPos), __x2117, "", (Language_ErrorSeverity) 3);
  	    };
  	};
  	TLSETL(100085);
  	Language_UnitManager_AddDepend(Language_Compile_compilingUnit, &(stubUnit));
  	if (stubUnit == ((void *) 0)) {
  	    TLSETL(100089);
  	    Language_Compile_CompileError_Add((TLint2) 10317, &(identTok.srcPos), "", "", (Language_ErrorSeverity) 3);
  	};
  	TLSETL(100093);
  	Language_Compile_ExpectToken((Language_Compile_Tok) 42);
  	TLINCL();
  	TLSTRCTASS(identTok, Language_Compile_newTok, struct Language_Compile_TokRecord);
  	TLSETL(100096);
  	Language_Compile_GetUnitFile(&(bodyUnit));
  	if (bodyUnit == Language_Compile_compilingUnit) {
  	    TLSETL(100101);
  	    {
  		TLstring	__x2118;
  		FileManager_FileName((FileManager_FileNoType) Language_UnitManager_FileNo(bodyUnit), __x2118);
  		Language_Compile_CompileError_Add((TLint2) 10206, &(identTok.srcPos), __x2118, "", (Language_ErrorSeverity) 3);
  	    };
  	};
  	TLSETL(100103);
  	Language_UnitManager_AddDepend(Language_Compile_compilingUnit, &(bodyUnit));
  	if (bodyUnit == ((void *) 0)) {
  	    TLSETL(100107);
  	    Language_Compile_CompileError_Add((TLint2) 10317, &(identTok.srcPos), "", "", (Language_ErrorSeverity) 3);
  	};
  	TLSETL(100109);
  	currentBody = Language_UnitManager_OverrideBody(stubUnit);
  	TLSETL(100111);
  	if (currentBody == ((void *) 0)) {
  	    TLSETL(100113);
  	    Language_UnitManager_SetOverrideBody(stubUnit, bodyUnit);
  	} else {
  	    TLSETL(100113);
  	    if (currentBody == bodyUnit) {
  		TLSETL(100118);
  		{
  		    TLstring	__x2120;
  		    FileManager_FileName((FileManager_FileNoType) Language_UnitManager_FileNo(currentBody), __x2120);
  		    {
  			TLstring	__x2119;
  			FileManager_FileName((FileManager_FileNoType) Language_UnitManager_FileNo(stubUnit), __x2119);
  			Language_Compile_CompileError_Add((TLint2) 10061, &(identTok.srcPos), __x2119, __x2120, (Language_ErrorSeverity) 1);
  		    };
  		};
  	    } else {
  		TLSETL(100123);
  		{
  		    TLstring	__x2122;
  		    FileManager_FileName((FileManager_FileNoType) Language_UnitManager_FileNo(currentBody), __x2122);
  		    {
  			TLstring	__x2121;
  			FileManager_FileName((FileManager_FileNoType) Language_UnitManager_FileNo(stubUnit), __x2121);
  			Language_Compile_CompileError_Add((TLint2) 10061, &(identTok.srcPos), __x2121, __x2122, (Language_ErrorSeverity) 2);
  		    };
  		};
  	    };
  	};
      };
      TLSETL(100126);
      if ((Language_Compile_newTok.u.tok) != 149) {
  	TLSETL(100129);
  	Language_Compile_CompileError_Add((TLint2) 10079, &(Language_Compile_newTok.srcPos), "", "", (Language_ErrorSeverity) 2);
      };
      TLRESTORELF();
  }
  
  static void Language_Compile_PreScan_VerifyUnit (uncompiledError)
  TLint2	uncompiledError;
  {
      void	*unitPtr;
      struct Language_Compile_TokRecord	identTok;
      TLSTKCHKSLF(100135);
      TLSETF();
      TLSETL(100135);
      TLSTRCTASS(identTok, Language_Compile_newTok, struct Language_Compile_TokRecord);
      TLSETL(100137);
      Language_Compile_GetUnitFile(&(unitPtr));
      if (Language_UnitManager_Kind(unitPtr) != 4) {
  	TLSETL(100141);
  	{
  	    TLstring	__x2123;
  	    FileManager_FileName((FileManager_FileNoType) Language_UnitManager_FileNo(unitPtr), __x2123);
  	    Language_Compile_CompileError_Add((TLint2) 10206, &(identTok.srcPos), __x2123, "", (Language_ErrorSeverity) 2);
  	};
      } else {
  	TLSETL(100141);
  	if (Language_UnitManager_IsCompiled(unitPtr)) {
  	    struct Language_Compile_SymbolDef	*unitSy;
  	    TLSETL(100143);
  	    * (TLnat4 *) &unitSy = Language_UnitManager_SymbolTable(unitPtr);
  	    TLINCL();
  	    TLASSERT (unitSy != ((struct Language_Compile_SymbolDef *) 0));
  	    TLINCL();
  	    if (((identTok.u.tok) == 0) && ((unitSy->identPtr) != (identTok.identPtr))) {
  		TLSETL(100150);
  		{
  		    TLstring	__x2125;
  		    Language_Compile_TokenToName(&(identTok), __x2125);
  		    {
  			TLstring	__x2124;
  			Language_Compile_SymbolToName(unitSy, __x2124);
  			Language_Compile_CompileError_Add((TLint2) 10175, &(identTok.srcPos), __x2124, __x2125, (Language_ErrorSeverity) 1);
  		    };
  		};
  	    };
  	    TLSETL(100151);
  	    if ((uncompiledError == 10077) && (Language_UnitManager_BodyUnit(unitPtr) == ((void *) 0))) {
  		TLSETL(100155);
  		{
  		    TLstring	__x2126;
  		    Language_Compile_SymbolToName(unitSy, __x2126);
  		    Language_Compile_CompileError_Add((TLint2) 10193, &(identTok.srcPos), __x2126, "", (Language_ErrorSeverity) 2);
  		};
  	    };
  	} else {
  	    TLSETL(100156);
  	    if (uncompiledError != 0) {
  		TLSETL(100159);
  		{
  		    TLstring	__x2127;
  		    Language_Compile_TokenToName(&(identTok), __x2127);
  		    Language_Compile_CompileError_Add((TLint2) uncompiledError, &(identTok.srcPos), __x2127, "", (Language_ErrorSeverity) 1);
  		};
  	    };
  	};
      };
      TLRESTORELF();
  }
  
  void Language_Compile_PreScan_VerifyConfiguration () {
      void	*unitPtr;
      struct Language_Compile_TokRecord	identTok;
      TLSTKCHKSLF(100166);
      TLSETF();
      TLSETL(100166);
      Language_Compile_Scanner_Scan();
      TLINCL();
      TLSTRCTASS(identTok, Language_Compile_newTok, struct Language_Compile_TokRecord);
      TLSETL(100169);
      Language_Compile_GetUnitFile(&(unitPtr));
      if (Language_UnitManager_Kind(unitPtr) != 5) {
  	TLSETL(100172);
  	{
  	    TLstring	__x2128;
  	    Language_Compile_TokenToName(&(identTok), __x2128);
  	    Language_Compile_CompileError_Add((TLint2) 10200, &(identTok.srcPos), __x2128, "", (Language_ErrorSeverity) 2);
  	};
      };
      TLSETL(100174);
      for(;;) {
  	TLSETL(100174);
  	if ((Language_Compile_newTok.u.tok) != 74) {
  	    break;
  	};
  	TLSETL(100176);
  	Language_Compile_Scanner_Scan();
  	TLINCL();
  	Language_Compile_PreScan_VerifyUnit((TLint2) 10077);
  	TLINCL();
  	Language_Compile_ExpectToken((Language_Compile_Tok) 42);
  	TLINCL();
  	Language_Compile_PreScan_VerifyUnit((TLint2) 0);
      };
      TLRESTORELF();
  }
  
  void Language_Compile_PreScan_VerifyPredefList () {
      TLSTKCHKSLF(100185);
      TLSETF();
      TLSETL(100185);
      for(;;) {
  	TLSETL(100185);
  	if ((Language_Compile_newTok.u.tok) == 149) {
  	    break;
  	};
  	TLSETL(100187);
  	Language_Compile_PreScan_VerifyUnit((TLint2) 0);
      };
      TLRESTORELF();
  }
  
  static void Language_Compile_PreScan_UnitExpandClause () {
      Language_Compile_Tok	expandTok;
      TLboolean	paren;
      struct Language_Compile_TokRecord	identTok;
      void	*expandUnit;
      TLSTKCHKSLF(100192);
      TLSETF();
      TLSETL(100192);
      TLPRE (((Language_Compile_oldTok.u.tok) == 78) || ((Language_Compile_oldTok.u.tok) == 74));
      TLINCL();
      expandTok = Language_Compile_oldTok.u.tok;
      TLSETL(100195);
      paren = 0;
      TLINCL();
      if ((Language_Compile_newTok.u.tok) == 20) {
  	TLSETL(100198);
  	Language_Compile_Scanner_Scan();
  	paren = 1;
      };
      TLSETL(100201);
      TLSTRCTASS(identTok, Language_Compile_newTok, struct Language_Compile_TokRecord);
      TLSETL(100204);
      Language_Compile_GetUnitFile(&(expandUnit));
      if (expandUnit == Language_Compile_compilingUnit) {
  	TLSETL(100207);
  	Language_Compile_CompileError_Add((TLint2) 10070, &(identTok.srcPos), Language_Compile_TokData[TLINRANGELOW(expandTok, 0, 158, 1)].Name, "", (Language_ErrorSeverity) 2);
      } else {
  	TLSETL(100208);
  	if (expandTok == 74) {
  	    TLSETL(100210);
  	    Language_UnitManager_SetStub(Language_Compile_compilingUnit, expandUnit);
  	};
  	TLSETL(100212);
  	Language_UnitManager_AddDepend(Language_Compile_compilingUnit, &(expandUnit));
  	if (expandUnit == ((void *) 0)) {
  	    TLSETL(100216);
  	    Language_Compile_CompileError_Add((TLint2) 10317, &(identTok.srcPos), "", "", (Language_ErrorSeverity) 3);
  	};
      };
      TLSETL(100219);
      if (paren) {
  	TLSETL(100221);
  	Language_Compile_ExpectToken((Language_Compile_Tok) 25);
      };
      TLRESTORELF();
  }
  
  static void Language_Compile_PreScan_UnitImplementByClause () {
      TLboolean	paren;
      struct Language_Compile_TokRecord	identTok;
      void	*bodyUnit;
      TLSTKCHKSLF(100226);
      TLSETF();
      TLSETL(100226);
      TLPRE ((Language_Compile_oldTok.u.tok) == 42);
      TLSETL(100228);
      paren = 0;
      TLINCL();
      if ((Language_Compile_newTok.u.tok) == 20) {
  	TLSETL(100231);
  	Language_Compile_Scanner_Scan();
  	paren = 1;
      };
      TLSETL(100234);
      TLSTRCTASS(identTok, Language_Compile_newTok, struct Language_Compile_TokRecord);
      TLSETL(100237);
      Language_Compile_GetUnitFile(&(bodyUnit));
      if (bodyUnit == Language_Compile_compilingUnit) {
  	TLSETL(100241);
  	{
  	    TLstring	__x2130;
  	    TL_TLS_TLSCAT(Language_Compile_TokData[74].Name, " ", __x2130);
  	    {
  		TLstring	__x2129;
  		TL_TLS_TLSCAT(__x2130, Language_Compile_TokData[42].Name, __x2129);
  		Language_Compile_CompileError_Add((TLint2) 10070, &(identTok.srcPos), __x2129, "", (Language_ErrorSeverity) 2);
  	    };
  	};
      } else {
  	TLSETL(100243);
  	Language_UnitManager_SetDefaultBody(Language_Compile_compilingUnit, bodyUnit);
  	if (bodyUnit == ((void *) 0)) {
  	    TLSETL(100247);
  	    Language_Compile_CompileError_Add((TLint2) 10317, &(identTok.srcPos), "", "", (Language_ErrorSeverity) 3);
  	};
      };
      TLSETL(100250);
      if (paren) {
  	TLSETL(100252);
  	Language_Compile_ExpectToken((Language_Compile_Tok) 25);
      };
      TLRESTORELF();
  }
  
  static void Language_Compile_PreScan_UnitImportList () {
      TLboolean	paren;
      TLSTKCHKSLF(100257);
      TLSETF();
      TLSETL(100257);
      paren = 0;
      TLSETL(100259);
      if ((Language_Compile_newTok.u.tok) == 20) {
  	TLSETL(100261);
  	Language_Compile_Scanner_Scan();
  	if ((Language_Compile_newTok.u.tok) == 25) {
  	    TLSETL(100263);
  	    Language_Compile_Scanner_Scan();
  	    TLINCL();
  	    TLRESTORELF();
  	    return;
  	};
  	TLSETL(100265);
  	paren = 1;
      };
      TLSETL(100268);
      for(;;) {
  	struct Language_Compile_TokRecord	identTok;
  	void	*unitPtr;
  	TLSETL(100268);
  	if (((Language_Compile_newTok.u.tok) == 140) || ((Language_Compile_newTok.u.tok) == 51)) {
  	    TLSETL(100270);
  	    Language_Compile_Scanner_Scan();
  	};
  	TLSETL(100274);
  	TLSTRCTASS(identTok, Language_Compile_newTok, struct Language_Compile_TokRecord);
  	TLSETL(100277);
  	Language_Compile_GetUnitFile(&(unitPtr));
  	if (unitPtr != Language_Compile_compilingUnit) {
  	    TLSETL(100279);
  	    Language_UnitManager_AddDepend(Language_Compile_compilingUnit, &(unitPtr));
  	    if (unitPtr == ((void *) 0)) {
  		TLSETL(100283);
  		Language_Compile_CompileError_Add((TLint2) 10317, &(identTok.srcPos), "", "", (Language_ErrorSeverity) 3);
  	    };
  	};
  	TLSETL(100286);
  	if ((Language_Compile_newTok.u.tok) != 11) {
  	    break;
  	};
  	TLSETL(100288);
  	Language_Compile_Scanner_Scan();
      };
      TLSETL(100289);
      if (paren) {
  	TLSETL(100291);
  	Language_Compile_ExpectToken((Language_Compile_Tok) 25);
      };
      TLRESTORELF();
  }
  
  static void Language_Compile_PreScan_AddPredefDepends () {
      TLSTKCHKSLF(100296);
      TLSETF();
      TLSETL(100296);
      if (!Language_UnitManager_IsPredef(Language_Compile_compilingUnit)) {
  	void	*predefDepend;
  	TLSETL(100300);
  	predefDepend = Language_Compile_predefUnit;
  	TLSETL(100302);
  	Language_UnitManager_AddDepend(Language_Compile_compilingUnit, &(predefDepend));
  	if (predefDepend == ((void *) 0)) {
  	    TLSETL(100306);
  	    Language_Compile_CompileError_Add((TLint2) 10317, &(Language_Compile_oldTok.srcPos), "", "", (Language_ErrorSeverity) 3);
  	};
      };
      TLSETL(100314);
      Language_UnitManager_RewindDependList(Language_Compile_predefUnit);
      TLINCL();
      for(;;) {
  	void	*predefDepend;
  	TLSETL(100317);
  	Language_UnitManager_GetNextDepend(Language_Compile_predefUnit, &(predefDepend));
  	if ((predefDepend == ((void *) 0)) || (predefDepend == Language_Compile_compilingUnit)) {
  	    break;
  	};
  	TLSETL(100320);
  	Language_UnitManager_AddDepend(Language_Compile_compilingUnit, &(predefDepend));
  	if (predefDepend == ((void *) 0)) {
  	    TLSETL(100324);
  	    Language_Compile_CompileError_Add((TLint2) 10317, &(Language_Compile_oldTok.srcPos), "", "", (Language_ErrorSeverity) 3);
  	};
      };
      TLRESTORELF();
  }
  
  static void Language_Compile_PreScan_ScanUnitHeader () {
      TLboolean	isClass;
      TLSTKCHKSLF(100332);
      TLSETF();
      TLSETL(100332);
      Language_UnitManager_SetKind(Language_Compile_compilingUnit, (Language_UnitManager_UnitKind) 4);
      if (((Language_Compile_newTok.u.tok) == 0) && ((Language_Compile_newTok.identPtr) == (Language_Compile_specialIdent.unit))) {
  	TLSETL(100334);
  	Language_Compile_Scanner_Scan();
      } else {
  	TLSETL(100338);
  	{
  	    TLstring	__x2132;
  	    Language_Compile_IdentToName(Language_Compile_specialIdent.unit, __x2132);
  	    {
  		TLstring	__x2131;
  		Language_Compile_TokenToName(&(Language_Compile_newTok), __x2131);
  		Language_Compile_CompileError_Add((TLint2) 10263, &(Language_Compile_newTok.srcPos), __x2131, __x2132, (Language_ErrorSeverity) 2);
  	    };
  	};
      };
      TLSETL(100340);
      isClass = 0;
      TLINCL();
      switch (Language_Compile_newTok.u.tok) {
  	case 47:
  	    {
  		TLSETL(100344);
  		Language_Compile_Scanner_Scan();
  		isClass = 1;
  	    }
  	    break;
  	case 88:
  	    {
  		TLSETL(100347);
  		Language_Compile_Scanner_Scan();
  	    }
  	    break;
  	case 89:
  	    {
  		TLSETL(100349);
  		Language_Compile_Scanner_Scan();
  		if ((Language_Compile_newTok.u.tok) == 47) {
  		    TLSETL(100351);
  		    Language_Compile_Scanner_Scan();
  		    isClass = 1;
  		};
  	    }
  	    break;
  	default :
  	    {
  		TLSETL(100357);
  		{
  		    TLstring	__x2133;
  		    Language_Compile_TokenToName(&(Language_Compile_newTok), __x2133);
  		    Language_Compile_CompileError_Add((TLint2) 10122, &(Language_Compile_newTok.srcPos), __x2133, "", (Language_ErrorSeverity) 3);
  		};
  	    }
  	    break;
      };
      TLINCL();
      if (((Language_Compile_newTok.u.tok) == 28) || ((Language_Compile_newTok.u.tok) == 103)) {
  	TLSETL(100360);
  	Language_Compile_Scanner_Scan();
      };
      TLSETL(100363);
      Language_Compile_ExpectToken((Language_Compile_Tok) 0);
      TLSETL(100365);
      Language_Compile_PreScan_AddPredefDepends();
      if (isClass && ((Language_Compile_newTok.u.tok) == 78)) {
  	TLSETL(100367);
  	Language_Compile_Scanner_Scan();
  	TLINCL();
  	Language_Compile_PreScan_UnitExpandClause();
  	if ((Language_Compile_newTok.u.tok) == 74) {
  	    TLSETL(100370);
  	    Language_Compile_Scanner_Scan();
  	};
      } else {
  	TLSETL(100371);
  	if ((Language_Compile_newTok.u.tok) == 74) {
  	    TLSETL(100373);
  	    Language_Compile_Scanner_Scan();
  	    if ((Language_Compile_newTok.u.tok) != 42) {
  		TLSETL(100375);
  		Language_Compile_PreScan_UnitExpandClause();
  		if ((Language_Compile_newTok.u.tok) == 74) {
  		    TLSETL(100377);
  		    Language_Compile_Scanner_Scan();
  		};
  	    };
  	};
      };
      TLSETL(100380);
      if ((Language_Compile_oldTok.u.tok) == 74) {
  	TLSETL(100382);
  	Language_Compile_ExpectToken((Language_Compile_Tok) 42);
  	TLINCL();
  	Language_Compile_PreScan_UnitImplementByClause();
      };
      TLSETL(100385);
      if ((Language_Compile_newTok.u.tok) == 75) {
  	TLSETL(100387);
  	Language_Compile_Scanner_Scan();
  	TLINCL();
  	Language_Compile_PreScan_UnitImportList();
      };
      TLSETL(100391);
      FileManager_CloseAllText();
      TLRESTORELF();
  }
  
  static void Language_Compile_PreScan_ScanMainHeader () {
      TLSTKCHKSLF(100397);
      TLSETF();
      TLSETL(100397);
      Language_UnitManager_SetKind(Language_Compile_compilingUnit, (Language_UnitManager_UnitKind) 5);
      TLSETL(100399);
      Language_Compile_PreScan_AddPredefDepends();
      if ((Language_Compile_newTok.u.tok) == 75) {
  	TLSETL(100401);
  	Language_Compile_Scanner_Scan();
  	TLINCL();
  	Language_Compile_PreScan_UnitImportList();
      };
      TLSETL(100405);
      FileManager_CloseAllText();
      TLRESTORELF();
  }
  
  void Language_Compile_ScanUnit (unitPtr, unitKind)
  void	*unitPtr;
  Language_UnitManager_UnitKind	unitKind;
  {
      TLSTKCHKSLF(100410);
      TLSETF();
      TLSETL(100410);
      TLPRE (unitPtr != ((void *) 0));
      TLSETL(100412);
      Language_Compile_compilingUnit = unitPtr;
      TLSETL(100414);
      if (unitKind == 1) {
  	TLSETL(100416);
  	Language_UnitManager_SetKind(Language_Compile_compilingUnit, (Language_UnitManager_UnitKind) 1);
  	TLINCL();
  	TLRESTORELF();
  	return;
      };
      TLSETL(100420);
      Language_Compile_InitializeScan((TLboolean) 1);
      switch (unitKind) {
  	case 0:
  	    {
  		TLSETL(100422);
  		if ((Language_Compile_newTok.u.tok) == 0) {
  		    TLSETL(100423);
  		    if ((Language_Compile_newTok.identPtr) == (Language_Compile_specialIdent.main)) {
  			TLSETL(100425);
  			Language_Compile_PreScan_ScanConfiguration();
  		    } else {
  			TLSETL(100425);
  			if ((Language_Compile_newTok.identPtr) == (Language_Compile_specialIdent.unit)) {
  			    TLSETL(100427);
  			    Language_Compile_PreScan_ScanUnitHeader();
  			} else {
  			    TLSETL(100429);
  			    Language_Compile_PreScan_ScanMainHeader();
  			};
  		    };
  		} else {
  		    TLSETL(100432);
  		    Language_Compile_PreScan_ScanMainHeader();
  		};
  	    }
  	    break;
  	case 2:
  	    {
  		TLSETL(100436);
  		Language_UnitManager_SetKind(Language_Compile_compilingUnit, (Language_UnitManager_UnitKind) 2);
  		TLINCL();
  		Language_Compile_PreScan_ScanPredefList();
  	    }
  	    break;
  	case 3:
  	    {
  		TLSETL(100438);
  		if ((Language_Compile_newTok.u.tok) == 0) {
  		    TLSETL(100439);
  		    if ((Language_Compile_newTok.identPtr) == (Language_Compile_specialIdent.main)) {
  			TLSETL(100441);
  			Language_Compile_PreScan_ScanConfiguration();
  		    } else {
  			TLSETL(100441);
  			if ((Language_Compile_newTok.identPtr) == (Language_Compile_specialIdent.unit)) {
  			    TLSETL(100444);
  			    Language_Compile_CompileError_Add((TLint2) 10294, &(Language_Compile_newTok.srcPos), "", "", (Language_ErrorSeverity) 2);
  			    TLINCL();
  			    Language_Compile_PreScan_ScanUnitHeader();
  			} else {
  			    TLSETL(100447);
  			    Language_Compile_PreScan_ScanMainHeader();
  			};
  		    };
  		} else {
  		    TLSETL(100450);
  		    Language_Compile_PreScan_ScanMainHeader();
  		};
  	    }
  	    break;
  	case 4:
  	    {
  		TLSETL(100453);
  		Language_Compile_PreScan_ScanUnitHeader();
  	    }
  	    break;
  	case 5:
  	    {
  		TLSETL(100454);
  		if (((Language_Compile_newTok.u.tok) == 0) && ((Language_Compile_newTok.identPtr) == (Language_Compile_specialIdent.unit))) {
  		    TLSETL(100458);
  		    Language_Compile_CompileError_Add((TLint2) 10294, &(Language_Compile_newTok.srcPos), "", "", (Language_ErrorSeverity) 2);
  		    TLINCL();
  		    Language_Compile_PreScan_ScanUnitHeader();
  		} else {
  		    TLSETL(100461);
  		    Language_Compile_PreScan_ScanMainHeader();
  		};
  	    }
  	    break;
  	default:
  	    TLCASEABORT;
      };
      TLRESTORELF();
  }
  
  void Language_Compile_PreScan () {
      TLSAVELF();
      TLSETF();
      TLRESTORELF();
  }
  