2010-04-18 21:48:20 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  /* This file, ratoms.h, was generated automatically by "yap -L misc/buildatoms"
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								     please do not update, update misc/ATOMS instead */
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  Atom3Dots = AtomAdjust(Atom3Dots);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomAbol = AtomAdjust(AtomAbol);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomAccess = AtomAdjust(AtomAccess);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomAfInet = AtomAdjust(AtomAfInet);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomAfLocal = AtomAdjust(AtomAfLocal);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomAfUnix = AtomAdjust(AtomAfUnix);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomAlarm = AtomAdjust(AtomAlarm);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomAlias = AtomAdjust(AtomAlias);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomAltNot = AtomAdjust(AtomAltNot);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomAppend = AtomAdjust(AtomAppend);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomArg = AtomAdjust(AtomArg);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomArray = AtomAdjust(AtomArray);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomArrayAccess = AtomAdjust(AtomArrayAccess);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomArrayOverflow = AtomAdjust(AtomArrayOverflow);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomArrayType = AtomAdjust(AtomArrayType);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomArrow = AtomAdjust(AtomArrow);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomAssert = AtomAdjust(AtomAssert);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomAt = AtomAdjust(AtomAt);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomAtom = AtomAdjust(AtomAtom);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomAtomic = AtomAdjust(AtomAtomic);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomAtt = AtomAdjust(AtomAtt);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomAtt1 = AtomAdjust(AtomAtt1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomAttDo = AtomAdjust(AtomAttDo);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomAttributes = AtomAdjust(AtomAttributes);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomB = AtomAdjust(AtomB);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomBatched = AtomAdjust(AtomBatched);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomBetween = AtomAdjust(AtomBetween);
							 | 
						
					
						
							
								
									
										
										
										
											2009-04-24 19:03:00 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomHugeInt = AtomAdjust(AtomHugeInt);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomBinaryStream = AtomAdjust(AtomBinaryStream);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomBraces = AtomAdjust(AtomBraces);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomBreak = AtomAdjust(AtomBreak);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomByte = AtomAdjust(AtomByte);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomCArith = AtomAdjust(AtomCArith);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomCall = AtomAdjust(AtomCall);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomCallAndRetryCounter = AtomAdjust(AtomCallAndRetryCounter);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomCallCounter = AtomAdjust(AtomCallCounter);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomCallable = AtomAdjust(AtomCallable);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomCatch = AtomAdjust(AtomCatch);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomChangeModule = AtomAdjust(AtomChangeModule);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomChar = AtomAdjust(AtomChar);
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-17 09:42:56 -07:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomCharsio = AtomAdjust(AtomCharsio);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomCharacter = AtomAdjust(AtomCharacter);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomCharacterCode = AtomAdjust(AtomCharacterCode);
							 | 
						
					
						
							
								
									
										
										
										
											2009-06-05 18:45:41 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomCleanCall = AtomAdjust(AtomCleanCall);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomColomn = AtomAdjust(AtomColomn);
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-17 09:42:56 -07:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomCodeSpace = AtomAdjust(AtomCodeSpace);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomComma = AtomAdjust(AtomComma);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomCompound = AtomAdjust(AtomCompound);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomConsistencyError = AtomAdjust(AtomConsistencyError);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomConsultOnBoot = AtomAdjust(AtomConsultOnBoot);
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomContext = AtomAdjust(AtomContext);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomCputime = AtomAdjust(AtomCputime);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomCreate = AtomAdjust(AtomCreate);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomCreep = AtomAdjust(AtomCreep);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomCryptAtoms = AtomAdjust(AtomCryptAtoms);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomCsult = AtomAdjust(AtomCsult);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomCurrentModule = AtomAdjust(AtomCurrentModule);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomCut = AtomAdjust(AtomCut);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomCutBy = AtomAdjust(AtomCutBy);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDAbort = AtomAdjust(AtomDAbort);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDBREF = AtomAdjust(AtomDBREF);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDBReference = AtomAdjust(AtomDBReference);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDBTerm = AtomAdjust(AtomDBTerm);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDBref = AtomAdjust(AtomDBref);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDInteger = AtomAdjust(AtomDInteger);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDOUBLE = AtomAdjust(AtomDOUBLE);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDec10 = AtomAdjust(AtomDec10);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDefault = AtomAdjust(AtomDefault);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDevNull = AtomAdjust(AtomDevNull);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDiff = AtomAdjust(AtomDiff);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDoLogUpdClause = AtomAdjust(AtomDoLogUpdClause);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDoLogUpdClause0 = AtomAdjust(AtomDoLogUpdClause0);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDoLogUpdClauseErase = AtomAdjust(AtomDoLogUpdClauseErase);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDoStaticClause = AtomAdjust(AtomDoStaticClause);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDollarU = AtomAdjust(AtomDollarU);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDollarUndef = AtomAdjust(AtomDollarUndef);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomDomainError = AtomAdjust(AtomDomainError);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomE = AtomAdjust(AtomE);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomEOFBeforeEOT = AtomAdjust(AtomEOFBeforeEOT);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomEQ = AtomAdjust(AtomEQ);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomEmptyAtom = AtomAdjust(AtomEmptyAtom);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomEndOfStream = AtomAdjust(AtomEndOfStream);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomEof = AtomAdjust(AtomEof);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomEq = AtomAdjust(AtomEq);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomError = AtomAdjust(AtomError);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomEvaluable = AtomAdjust(AtomEvaluable);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomEvaluationError = AtomAdjust(AtomEvaluationError);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomExecAnswers = AtomAdjust(AtomExecAnswers);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomExecuteInMod = AtomAdjust(AtomExecuteInMod);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomExecuteWithin = AtomAdjust(AtomExecuteWithin);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomExecuteWoMod = AtomAdjust(AtomExecuteWoMod);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomExistenceError = AtomAdjust(AtomExistenceError);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomExpectedNumber = AtomAdjust(AtomExpectedNumber);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomExtendFileSearchPath = AtomAdjust(AtomExtendFileSearchPath);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomFB = AtomAdjust(AtomFB);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomFail = AtomAdjust(AtomFail);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomFalse = AtomAdjust(AtomFalse);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomFast = AtomAdjust(AtomFast);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomFileerrors = AtomAdjust(AtomFileerrors);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomFloat = AtomAdjust(AtomFloat);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomFloatFormat = AtomAdjust(AtomFloatFormat);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomFloatOverflow = AtomAdjust(AtomFloatOverflow);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomFloatUnderflow = AtomAdjust(AtomFloatUnderflow);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomFormat = AtomAdjust(AtomFormat);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomFormatAt = AtomAdjust(AtomFormatAt);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomFunctor = AtomAdjust(AtomFunctor);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomGT = AtomAdjust(AtomGT);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomGVar = AtomAdjust(AtomGVar);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomGc = AtomAdjust(AtomGc);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomGcMargin = AtomAdjust(AtomGcMargin);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomGcTrace = AtomAdjust(AtomGcTrace);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomGcVerbose = AtomAdjust(AtomGcVerbose);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomGcVeryVerbose = AtomAdjust(AtomGcVeryVerbose);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomGeneratePredInfo = AtomAdjust(AtomGeneratePredInfo);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomGetwork = AtomAdjust(AtomGetwork);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomGetworkSeq = AtomAdjust(AtomGetworkSeq);
							 | 
						
					
						
							
								
									
										
										
										
											2010-04-16 02:08:06 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomGlobalSp = AtomAdjust(AtomGlobalSp);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomGlobalTrie = AtomAdjust(AtomGlobalTrie);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomGoalExpansion = AtomAdjust(AtomGoalExpansion);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomHERE = AtomAdjust(AtomHERE);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomHandleThrow = AtomAdjust(AtomHandleThrow);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomHeap = AtomAdjust(AtomHeap);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomHeapUsed = AtomAdjust(AtomHeapUsed);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomIDB = AtomAdjust(AtomIDB);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomIOMode = AtomAdjust(AtomIOMode);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomId = AtomAdjust(AtomId);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomInf = AtomAdjust(AtomInf);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomInitGoal = AtomAdjust(AtomInitGoal);
							 | 
						
					
						
							
								
									
										
										
										
											2009-06-13 16:05:45 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomInStackExpansion = AtomAdjust(AtomInStackExpansion);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomInput = AtomAdjust(AtomInput);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomInstantiationError = AtomAdjust(AtomInstantiationError);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomInt = AtomAdjust(AtomInt);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomIntOverflow = AtomAdjust(AtomIntOverflow);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomInteger = AtomAdjust(AtomInteger);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomInternalCompilerError = AtomAdjust(AtomInternalCompilerError);
							 | 
						
					
						
							
								
									
										
										
										
											2009-02-09 21:56:40 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomIs = AtomAdjust(AtomIs);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomKey = AtomAdjust(AtomKey);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomLDLibraryPath = AtomAdjust(AtomLDLibraryPath);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomLONGINT = AtomAdjust(AtomLONGINT);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomLT = AtomAdjust(AtomLT);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomLastExecuteWithin = AtomAdjust(AtomLastExecuteWithin);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomLeash = AtomAdjust(AtomLeash);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomList = AtomAdjust(AtomList);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomLive = AtomAdjust(AtomLive);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomLoadAnswers = AtomAdjust(AtomLoadAnswers);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomLocal = AtomAdjust(AtomLocal);
							 | 
						
					
						
							
								
									
										
										
										
											2010-04-16 02:08:06 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomLocalSp = AtomAdjust(AtomLocalSp);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomLocalTrie = AtomAdjust(AtomLocalTrie);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomMaxArity = AtomAdjust(AtomMaxArity);
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomMaxFiles = AtomAdjust(AtomMaxFiles);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomMegaClause = AtomAdjust(AtomMegaClause);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomMetaCall = AtomAdjust(AtomMetaCall);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomMfClause = AtomAdjust(AtomMfClause);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomMinus = AtomAdjust(AtomMinus);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomModify = AtomAdjust(AtomModify);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomMultiFile = AtomAdjust(AtomMultiFile);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomMutable = AtomAdjust(AtomMutable);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomMutableVariable = AtomAdjust(AtomMutableVariable);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomMyddasDB = AtomAdjust(AtomMyddasDB);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomMyddasGoal = AtomAdjust(AtomMyddasGoal);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomMyddasHost = AtomAdjust(AtomMyddasHost);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomMyddasPass = AtomAdjust(AtomMyddasPass);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomMyddasUser = AtomAdjust(AtomMyddasUser);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomMyddasVersionName = AtomAdjust(AtomMyddasVersionName);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomNan = AtomAdjust(AtomNan);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomNb = AtomAdjust(AtomNb);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomNbTerm = AtomAdjust(AtomNbTerm);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomNew = AtomAdjust(AtomNew);
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomNoMemory = AtomAdjust(AtomNoMemory);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomNonEmptyList = AtomAdjust(AtomNonEmptyList);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomNot = AtomAdjust(AtomNot);
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomNotImplemented = AtomAdjust(AtomNotImplemented);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomNotLessThanZero = AtomAdjust(AtomNotLessThanZero);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomNotNewline = AtomAdjust(AtomNotNewline);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomNotZero = AtomAdjust(AtomNotZero);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomNumber = AtomAdjust(AtomNumber);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomOff = AtomAdjust(AtomOff);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomOffline = AtomAdjust(AtomOffline);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomOn = AtomAdjust(AtomOn);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomOnline = AtomAdjust(AtomOnline);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomOpen = AtomAdjust(AtomOpen);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomOperatingSystemError = AtomAdjust(AtomOperatingSystemError);
							 | 
						
					
						
							
								
									
										
										
										
											2010-04-22 12:11:15 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomOperatingSystemSupport = AtomAdjust(AtomOperatingSystemSupport);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomOperator = AtomAdjust(AtomOperator);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomOperatorPriority = AtomAdjust(AtomOperatorPriority);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomOperatorSpecifier = AtomAdjust(AtomOperatorSpecifier);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomOtherwise = AtomAdjust(AtomOtherwise);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomOutOfAttvarsError = AtomAdjust(AtomOutOfAttvarsError);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomOutOfAuxspaceError = AtomAdjust(AtomOutOfAuxspaceError);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomOutOfHeapError = AtomAdjust(AtomOutOfHeapError);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomOutOfRange = AtomAdjust(AtomOutOfRange);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomOutOfStackError = AtomAdjust(AtomOutOfStackError);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomOutOfTrailError = AtomAdjust(AtomOutOfTrailError);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomOutput = AtomAdjust(AtomOutput);
							 | 
						
					
						
							
								
									
										
										
										
											2009-02-16 12:25:03 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomPrologCommonsDir = AtomAdjust(AtomPrologCommonsDir);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomPastEndOfStream = AtomAdjust(AtomPastEndOfStream);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomPermissionError = AtomAdjust(AtomPermissionError);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomPi = AtomAdjust(AtomPi);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomPipe = AtomAdjust(AtomPipe);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomPlus = AtomAdjust(AtomPlus);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomPointer = AtomAdjust(AtomPointer);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomPortray = AtomAdjust(AtomPortray);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomPredicateIndicator = AtomAdjust(AtomPredicateIndicator);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomPrimitive = AtomAdjust(AtomPrimitive);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomPrivateProcedure = AtomAdjust(AtomPrivateProcedure);
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomProcedure = AtomAdjust(AtomProcedure);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomProfile = AtomAdjust(AtomProfile);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomProlog = AtomAdjust(AtomProlog);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomPtr = AtomAdjust(AtomPtr);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomQuery = AtomAdjust(AtomQuery);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomQueue = AtomAdjust(AtomQueue);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomQuiet = AtomAdjust(AtomQuiet);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomRadix = AtomAdjust(AtomRadix);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomRandom = AtomAdjust(AtomRandom);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomRead = AtomAdjust(AtomRead);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomReadutil = AtomAdjust(AtomReadutil);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomRecordedP = AtomAdjust(AtomRecordedP);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomRecordedWithKey = AtomAdjust(AtomRecordedWithKey);
							 | 
						
					
						
							
								
									
										
										
										
											2009-06-05 18:45:41 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomRedoFreeze = AtomAdjust(AtomRedoFreeze);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomRefoundVar = AtomAdjust(AtomRefoundVar);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomRepeat = AtomAdjust(AtomRepeat);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomRepeatSpace = AtomAdjust(AtomRepeatSpace);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomReposition = AtomAdjust(AtomReposition);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomRepresentationError = AtomAdjust(AtomRepresentationError);
							 | 
						
					
						
							
								
									
										
										
										
											2010-05-28 09:53:56 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomRDiv = AtomAdjust(AtomRDiv);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomResize = AtomAdjust(AtomResize);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomResourceError = AtomAdjust(AtomResourceError);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomRestoreRegs = AtomAdjust(AtomRestoreRegs);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomRetryCounter = AtomAdjust(AtomRetryCounter);
							 | 
						
					
						
							
								
									
										
										
										
											2009-02-12 16:39:20 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomRTree = AtomAdjust(AtomRTree);
							 | 
						
					
						
							
								
									
										
										
										
											2009-03-10 16:24:26 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomSafe = AtomAdjust(AtomSafe);
							 | 
						
					
						
							
								
									
										
										
										
											2009-11-27 11:21:24 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomSafeCallCleanup = AtomAdjust(AtomSafeCallCleanup);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSame = AtomAdjust(AtomSame);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSemic = AtomAdjust(AtomSemic);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomShiftCountOverflow = AtomAdjust(AtomShiftCountOverflow);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSigAlarm = AtomAdjust(AtomSigAlarm);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSigBreak = AtomAdjust(AtomSigBreak);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSigCreep = AtomAdjust(AtomSigCreep);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSigDebug = AtomAdjust(AtomSigDebug);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSigDelayCreep = AtomAdjust(AtomSigDelayCreep);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSigHup = AtomAdjust(AtomSigHup);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSigInt = AtomAdjust(AtomSigInt);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSigIti = AtomAdjust(AtomSigIti);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSigPending = AtomAdjust(AtomSigPending);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSigPipe = AtomAdjust(AtomSigPipe);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSigStackDump = AtomAdjust(AtomSigStackDump);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSigStatistics = AtomAdjust(AtomSigStatistics);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSigTrace = AtomAdjust(AtomSigTrace);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSigUsr1 = AtomAdjust(AtomSigUsr1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSigUsr2 = AtomAdjust(AtomSigUsr2);
							 | 
						
					
						
							
								
									
										
										
										
											2009-06-03 10:09:14 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomSigVTAlarm = AtomAdjust(AtomSigVTAlarm);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSigWakeUp = AtomAdjust(AtomSigWakeUp);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSlash = AtomAdjust(AtomSlash);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSocket = AtomAdjust(AtomSocket);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSourceSink = AtomAdjust(AtomSourceSink);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSpy = AtomAdjust(AtomSpy);
							 | 
						
					
						
							
								
									
										
										
										
											2009-04-25 11:01:33 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomStack = AtomAdjust(AtomStack);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomStackFree = AtomAdjust(AtomStackFree);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomStaticClause = AtomAdjust(AtomStaticClause);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomStaticProcedure = AtomAdjust(AtomStaticProcedure);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomStream = AtomAdjust(AtomStream);
							 | 
						
					
						
							
								
									
										
										
										
											2010-02-26 10:59:43 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomVStream = AtomAdjust(AtomVStream);
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-22 19:55:18 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomStreams = AtomAdjust(AtomStreams);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomStreamOrAlias = AtomAdjust(AtomStreamOrAlias);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomStreamPos = AtomAdjust(AtomStreamPos);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomStreamPosition = AtomAdjust(AtomStreamPosition);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomString = AtomAdjust(AtomString);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSwi = AtomAdjust(AtomSwi);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSyntaxError = AtomAdjust(AtomSyntaxError);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSyntaxErrorHandler = AtomAdjust(AtomSyntaxErrorHandler);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSystem = AtomAdjust(AtomSystem);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSystemError = AtomAdjust(AtomSystemError);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomSystemLibraryDir = AtomAdjust(AtomSystemLibraryDir);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomTerm = AtomAdjust(AtomTerm);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomTerms = AtomAdjust(AtomTerms);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomTextStream = AtomAdjust(AtomTextStream);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomThreads = AtomAdjust(AtomThreads);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomThrow = AtomAdjust(AtomThrow);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomTimeOutSpec = AtomAdjust(AtomTimeOutSpec);
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomTimeoutError = AtomAdjust(AtomTimeoutError);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomTopLevelGoal = AtomAdjust(AtomTopLevelGoal);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomTopThreadGoal = AtomAdjust(AtomTopThreadGoal);
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-17 09:42:56 -07:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomTrail = AtomAdjust(AtomTrail);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomTrue = AtomAdjust(AtomTrue);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomTty = AtomAdjust(AtomTty);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomTtys = AtomAdjust(AtomTtys);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomTypeError = AtomAdjust(AtomTypeError);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomUndefined = AtomAdjust(AtomUndefined);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomUndefp = AtomAdjust(AtomUndefp);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomUnderflow = AtomAdjust(AtomUnderflow);
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-17 09:42:56 -07:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  AtomUnificationStack = AtomAdjust(AtomUnificationStack);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomUnsignedByte = AtomAdjust(AtomUnsignedByte);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomUnsignedChar = AtomAdjust(AtomUnsignedChar);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomUser = AtomAdjust(AtomUser);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomUserErr = AtomAdjust(AtomUserErr);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomUserIn = AtomAdjust(AtomUserIn);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomUserOut = AtomAdjust(AtomUserOut);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomVBar = AtomAdjust(AtomVBar);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomVar = AtomAdjust(AtomVar);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomVariable = AtomAdjust(AtomVariable);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomVersionNumber = AtomAdjust(AtomVersionNumber);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomWakeUpGoal = AtomAdjust(AtomWakeUpGoal);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomWhen = AtomAdjust(AtomWhen);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomWrite = AtomAdjust(AtomWrite);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomYapHacks = AtomAdjust(AtomYapHacks);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  AtomZeroDivisor = AtomAdjust(AtomZeroDivisor);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorAfInet = FuncAdjust(FunctorAfInet);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorAfLocal = FuncAdjust(FunctorAfLocal);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorAfUnix = FuncAdjust(FunctorAfUnix);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorAltNot = FuncAdjust(FunctorAltNot);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorArg = FuncAdjust(FunctorArg);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorArrayEntry = FuncAdjust(FunctorArrayEntry);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorArrow = FuncAdjust(FunctorArrow);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorAssert = FuncAdjust(FunctorAssert);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorAtFoundOne = FuncAdjust(FunctorAtFoundOne);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorAtom = FuncAdjust(FunctorAtom);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-24 09:04:44 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorAtt1 = FuncAdjust(FunctorAtt1);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorAttGoal = FuncAdjust(FunctorAttGoal);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorBraces = FuncAdjust(FunctorBraces);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorCall = FuncAdjust(FunctorCall);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorCatch = FuncAdjust(FunctorCatch);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorChangeModule = FuncAdjust(FunctorChangeModule);
							 | 
						
					
						
							
								
									
										
										
										
											2009-06-05 18:45:41 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorCleanCall = FuncAdjust(FunctorCleanCall);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorClist = FuncAdjust(FunctorClist);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorComma = FuncAdjust(FunctorComma);
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorContext2 = FuncAdjust(FunctorContext2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorConsistencyError = FuncAdjust(FunctorConsistencyError);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorCreep = FuncAdjust(FunctorCreep);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorCsult = FuncAdjust(FunctorCsult);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorCurrentModule = FuncAdjust(FunctorCurrentModule);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorCutBy = FuncAdjust(FunctorCutBy);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorDiff = FuncAdjust(FunctorDiff);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorDoLogUpdClause = FuncAdjust(FunctorDoLogUpdClause);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorDoLogUpdClause0 = FuncAdjust(FunctorDoLogUpdClause0);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorDoLogUpdClauseErase = FuncAdjust(FunctorDoLogUpdClauseErase);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorDoStaticClause = FuncAdjust(FunctorDoStaticClause);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorDomainError = FuncAdjust(FunctorDomainError);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorDot = FuncAdjust(FunctorDot);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-24 09:04:44 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorDot10 = FuncAdjust(FunctorDot10);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorDot11 = FuncAdjust(FunctorDot11);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorDot12 = FuncAdjust(FunctorDot12);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorDot2 = FuncAdjust(FunctorDot2);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorDot3 = FuncAdjust(FunctorDot3);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorDot4 = FuncAdjust(FunctorDot4);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorDot5 = FuncAdjust(FunctorDot5);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorDot6 = FuncAdjust(FunctorDot6);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorDot7 = FuncAdjust(FunctorDot7);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorDot8 = FuncAdjust(FunctorDot8);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorDot9 = FuncAdjust(FunctorDot9);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorEq = FuncAdjust(FunctorEq);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorError = FuncAdjust(FunctorError);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorEvaluationError = FuncAdjust(FunctorEvaluationError);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorExecute2InMod = FuncAdjust(FunctorExecute2InMod);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorExecuteInMod = FuncAdjust(FunctorExecuteInMod);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorExecuteWithin = FuncAdjust(FunctorExecuteWithin);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorExistenceError = FuncAdjust(FunctorExistenceError);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorFunctor = FuncAdjust(FunctorFunctor);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorGAtom = FuncAdjust(FunctorGAtom);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorGAtomic = FuncAdjust(FunctorGAtomic);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorGCompound = FuncAdjust(FunctorGCompound);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorGFloat = FuncAdjust(FunctorGFloat);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorGFormatAt = FuncAdjust(FunctorGFormatAt);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorGInteger = FuncAdjust(FunctorGInteger);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorGNumber = FuncAdjust(FunctorGNumber);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorGPrimitive = FuncAdjust(FunctorGPrimitive);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorGVar = FuncAdjust(FunctorGVar);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorGeneratePredInfo = FuncAdjust(FunctorGeneratePredInfo);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorGoalExpansion = FuncAdjust(FunctorGoalExpansion);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorHandleThrow = FuncAdjust(FunctorHandleThrow);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorId = FuncAdjust(FunctorId);
							 | 
						
					
						
							
								
									
										
										
										
											2009-02-09 21:56:40 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorIs = FuncAdjust(FunctorIs);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorLastExecuteWithin = FuncAdjust(FunctorLastExecuteWithin);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorList = FuncAdjust(FunctorList);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorMegaClause = FuncAdjust(FunctorMegaClause);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorMetaCall = FuncAdjust(FunctorMetaCall);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-24 09:04:44 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorMinus = FuncAdjust(FunctorMinus);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorModule = FuncAdjust(FunctorModule);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorMultiFileClause = FuncAdjust(FunctorMultiFileClause);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorMutable = FuncAdjust(FunctorMutable);
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorNotImplemented = FuncAdjust(FunctorNotImplemented);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorNBQueue = FuncAdjust(FunctorNBQueue);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorNot = FuncAdjust(FunctorNot);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorOr = FuncAdjust(FunctorOr);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorPermissionError = FuncAdjust(FunctorPermissionError);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorPortray = FuncAdjust(FunctorPortray);
							 | 
						
					
						
							
								
									
										
										
										
											2009-06-05 18:45:41 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorPrologConstraint = FuncAdjust(FunctorPrologConstraint);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorQuery = FuncAdjust(FunctorQuery);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorRecordedWithKey = FuncAdjust(FunctorRecordedWithKey);
							 | 
						
					
						
							
								
									
										
										
										
											2010-05-28 09:53:56 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorRDiv = FuncAdjust(FunctorRDiv);
							 | 
						
					
						
							
								
									
										
										
										
											2009-06-05 18:45:41 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorRedoFreeze = FuncAdjust(FunctorRedoFreeze);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorRepresentationError = FuncAdjust(FunctorRepresentationError);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorResourceError = FuncAdjust(FunctorResourceError);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorRestoreRegs = FuncAdjust(FunctorRestoreRegs);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorRestoreRegs1 = FuncAdjust(FunctorRestoreRegs1);
							 | 
						
					
						
							
								
									
										
										
										
											2009-03-10 16:24:26 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorSafe = FuncAdjust(FunctorSafe);
							 | 
						
					
						
							
								
									
										
										
										
											2009-11-27 11:21:24 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorSafeCallCleanup = FuncAdjust(FunctorSafeCallCleanup);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorSame = FuncAdjust(FunctorSame);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorSlash = FuncAdjust(FunctorSlash);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorStaticClause = FuncAdjust(FunctorStaticClause);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorStream = FuncAdjust(FunctorStream);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorStreamEOS = FuncAdjust(FunctorStreamEOS);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorStreamPos = FuncAdjust(FunctorStreamPos);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-24 09:04:44 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorSyntaxError = FuncAdjust(FunctorSyntaxError);
							 | 
						
					
						
							
								
									
										
										
										
											2010-02-26 13:30:16 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorShortSyntaxError = FuncAdjust(FunctorShortSyntaxError);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorThreadRun = FuncAdjust(FunctorThreadRun);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorThrow = FuncAdjust(FunctorThrow);
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorTimeoutError = FuncAdjust(FunctorTimeoutError);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
							
								  FunctorTypeError = FuncAdjust(FunctorTypeError);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorUMinus = FuncAdjust(FunctorUMinus);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorUPlus = FuncAdjust(FunctorUPlus);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorVBar = FuncAdjust(FunctorVBar);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
							
								  FunctorVar = FuncAdjust(FunctorVar);
							 |