2015-08-18 14:36:10 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
										
									
								 | 
							
							
								
							 | 
						
					
						
							
								
									
										
										
										
											2015-08-07 16:57:53 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  /* This file, iatoms.h, was generated automatically by "yap -L misc/buildatoms"
							 | 
						
					
						
							
								
									
										
										
										
											2010-04-18 21:48:20 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								     please do not update, update misc/ATOMS instead */
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  Atom3Dots = Yap_LookupAtom("...");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAbol = Yap_FullLookupAtom("$abol");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAccess = Yap_LookupAtom("access");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAfInet = Yap_LookupAtom("AF_INET");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAfLocal = Yap_LookupAtom("AF_LOCAL");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAfUnix = Yap_LookupAtom("AF_UNIX");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAlarm = Yap_FullLookupAtom("$alarm");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAlias = Yap_LookupAtom("alias");
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-21 17:05:36 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAll = Yap_LookupAtom("all");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAltNot = Yap_LookupAtom("not");
							 | 
						
					
						
							
								
									
										
										
										
											2013-04-29 11:58:05 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAny = Yap_LookupAtom("any");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAppend = Yap_LookupAtom("append");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomArg = Yap_LookupAtom("arg");
							 | 
						
					
						
							
								
									
										
										
										
											2009-04-22 11:34:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomArray = Yap_FullLookupAtom("$array");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomArrayAccess = Yap_FullLookupAtom("$array_arg");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomArrayOverflow = Yap_LookupAtom("array_overflow");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomArrayType = Yap_LookupAtom("array_type");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomArrow = Yap_LookupAtom("->");
							 | 
						
					
						
							
								
									
										
										
										
											2014-04-24 08:26:31 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDoubleArrow = Yap_LookupAtom("-->");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAssert = Yap_LookupAtom(":-");
							 | 
						
					
						
							
								
									
										
										
										
											2013-07-07 16:15:25 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomEmptyBrackets = Yap_LookupAtom("()");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomEmptySquareBrackets = Yap_LookupAtom("[]");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomEmptyCurlyBrackets = Yap_LookupAtom("{}");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAt = Yap_LookupAtom("at");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAtom = Yap_LookupAtom("atom");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAtomic = Yap_LookupAtom("atomic");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAtt = Yap_FullLookupAtom("$att");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAtt1 = Yap_LookupAtom("att");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAttDo = Yap_FullLookupAtom("$att_do");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomAttributes = Yap_LookupAtom("attributes");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomB = Yap_FullLookupAtom("$last_choice_pt");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomBatched = Yap_LookupAtom("batched");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomBetween = Yap_LookupAtom("between");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomBinary = Yap_LookupAtom("binary");
							 | 
						
					
						
							
								
									
										
										
										
											2013-12-02 14:49:41 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomBigNum = Yap_LookupAtom("big_num");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomBinaryStream = Yap_LookupAtom("binary_stream");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomBoolean = Yap_LookupAtom("boolean");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomBraces = Yap_LookupAtom("{}");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomBreak = Yap_FullLookupAtom("$break");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomByte = Yap_LookupAtom("byte");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCArith = Yap_FullLookupAtom("$c_arith");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCall = Yap_LookupAtom("call");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCallAndRetryCounter = Yap_LookupAtom("call_and_retry_counter");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCallCounter = Yap_LookupAtom("call_counter");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCallable = Yap_LookupAtom("callable");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCatch = Yap_FullLookupAtom("$catch");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomChangeModule = Yap_FullLookupAtom("$change_module");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomChar = Yap_LookupAtom("char");
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-17 09:42:56 -07:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCharsio = Yap_LookupAtom("charsio");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCharacter = Yap_LookupAtom("character");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCharacterCode = Yap_LookupAtom("character_code");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomChars = Yap_LookupAtom("chars");
							 | 
						
					
						
							
								
									
										
										
										
											2014-04-23 21:39:32 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCharset = Yap_LookupAtom("charset");
							 | 
						
					
						
							
								
									
										
										
										
											2009-06-05 18:45:41 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCleanCall = Yap_FullLookupAtom("$clean_call");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomColomn = Yap_LookupAtom(":");
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-17 09:42:56 -07:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCodeSpace = Yap_LookupAtom("code_space");
							 | 
						
					
						
							
								
									
										
										
										
											2010-07-19 14:48:42 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCodes = Yap_LookupAtom("codes");
							 | 
						
					
						
							
								
									
										
										
										
											2013-12-19 16:56:55 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCoInductive = Yap_LookupAtom("coinductive");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomComma = Yap_LookupAtom(",");
							 | 
						
					
						
							
								
									
										
										
										
											2013-12-08 22:56:48 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCommentHook = Yap_LookupAtom("comment_hook");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCompact = Yap_LookupAtom("compact");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCompound = Yap_LookupAtom("compound");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomConsistencyError = Yap_LookupAtom("consistency_error");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomConsultOnBoot = Yap_FullLookupAtom("$consult_on_boot");
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomContext = Yap_LookupAtom("context");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCputime = Yap_LookupAtom("cputime");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCreate = Yap_LookupAtom("create");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCreep = Yap_FullLookupAtom("$creep");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCryptAtoms = Yap_LookupAtom("crypt_atoms");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCsult = Yap_FullLookupAtom("$csult");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCurrentModule = Yap_FullLookupAtom("$current_module");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCut = Yap_LookupAtom("!");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomCutBy = Yap_FullLookupAtom("$cut_by");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDAbort = Yap_FullLookupAtom("$abort");
							 | 
						
					
						
							
								
									
										
										
										
											2011-04-30 01:16:40 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDBLoad = Yap_FullLookupAtom("$db_load");
							 | 
						
					
						
							
								
									
										
										
										
											2010-02-12 15:51:31 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDBREF = Yap_LookupAtom("DBRef");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDBReference = Yap_LookupAtom("db_reference");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDBTerm = Yap_LookupAtom("db_term");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDBref = Yap_FullLookupAtom("$dbref");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDInteger = Yap_FullLookupAtom("$integer");
							 | 
						
					
						
							
								
									
										
										
										
											2015-07-22 19:19:35 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDebugMeta = Yap_FullLookupAtom("$debug_meta");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDebuggerInput = Yap_LookupAtom("debugger_input");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDec10 = Yap_LookupAtom("dec10");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDefault = Yap_LookupAtom("default");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDevNull = Yap_LookupAtom("/dev/null");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDiff = Yap_LookupAtom("\\=");
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-21 17:05:36 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDirectory = Yap_LookupAtom("disrectorys");
							 | 
						
					
						
							
								
									
										
										
										
											2014-04-23 21:39:32 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDiscontiguous = Yap_LookupAtom("discontiguous");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDiscontiguousWarnings = Yap_LookupAtom("discontiguous_warnings");
							 | 
						
					
						
							
								
									
										
										
										
											2013-01-14 22:46:06 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDollar = Yap_FullLookupAtom("$");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDoLogUpdClause = Yap_FullLookupAtom("$do_log_upd_clause");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDoLogUpdClause0 = Yap_FullLookupAtom("$do_log_upd_clause0");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDoLogUpdClauseErase = Yap_FullLookupAtom("$do_log_upd_clause_erase");
							 | 
						
					
						
							
								
									
										
										
										
											2009-02-09 21:56:40 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDollarU = Yap_FullLookupAtom("$u");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDollarUndef = Yap_FullLookupAtom("$undef");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDomainError = Yap_LookupAtom("domain_error");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDoStaticClause = Yap_FullLookupAtom("$do_static_clause");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDots = Yap_LookupAtom("dots");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomDOUBLE = Yap_FullLookupAtom("Double");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomE = Yap_LookupAtom("e");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomEOFBeforeEOT = Yap_LookupAtom("end_of_file_found_before_end_of_term");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomEQ = Yap_LookupAtom("=");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomEmptyAtom = Yap_LookupAtom("");
							 | 
						
					
						
							
								
									
										
										
										
											2010-10-27 14:49:27 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomEncoding = Yap_LookupAtom("encoding");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomEndOfStream = Yap_LookupAtom("$end_of_stream");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomEof = Yap_LookupAtom("end_of_file");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomEOfCode = Yap_LookupAtom("eof_code");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomEq = Yap_LookupAtom("=");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomError = Yap_LookupAtom("error");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomException = Yap_LookupAtom("exception");
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-21 17:05:36 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomExtensions = Yap_LookupAtom("extensions");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomEvaluable = Yap_LookupAtom("evaluable");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomEvaluationError = Yap_LookupAtom("evaluation_error");
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-21 17:05:36 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomExecutable = Yap_LookupAtom("executable");
							 | 
						
					
						
							
								
									
										
										
										
											2010-08-03 21:04:16 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomExecute = Yap_LookupAtom("execute");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomExecAnswers = Yap_LookupAtom("exec_answers");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomExecuteInMod = Yap_FullLookupAtom("$execute_in_mod");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomExecuteWithin = Yap_FullLookupAtom("$execute_within");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomExecuteWoMod = Yap_FullLookupAtom("$execute_wo_mod");
							 | 
						
					
						
							
								
									
										
										
										
											2010-08-03 21:04:16 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomExist = Yap_LookupAtom("exist");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomExistenceError = Yap_LookupAtom("existence_error");
							 | 
						
					
						
							
								
									
										
										
										
											2013-01-11 16:45:14 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomExoClause = Yap_FullLookupAtom("$exo_clause");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomExpectedNumber = Yap_LookupAtom("expected_number_syntax");
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-21 17:05:36 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomExpand = Yap_LookupAtom("expand");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomExtendFileSearchPath = Yap_FullLookupAtom("$extend_file_search_path");
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-21 17:05:36 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomExtendsions = Yap_LookupAtom("extensionh");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomFB = Yap_LookupAtom("fb");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomFail = Yap_LookupAtom("fail");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomFalse = Yap_LookupAtom("false");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomFast = Yap_FullLookupAtom("$fast");
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-21 17:05:36 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomFileErrors = Yap_LookupAtom("file_errors");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomFileerrors = Yap_LookupAtom("fileerrors");
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-21 17:05:36 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomFileType = Yap_LookupAtom("file_type");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomFirst = Yap_LookupAtom("first");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomFloat = Yap_LookupAtom("float");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomFloatFormat = Yap_LookupAtom("\%.15g");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomFloatOverflow = Yap_LookupAtom("float_overflow");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomFloatUnderflow = Yap_LookupAtom("float_underflow");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomFormat = Yap_LookupAtom("format");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomFormatAt = Yap_FullLookupAtom("$format@");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomFull = Yap_LookupAtom("full");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomFunctor = Yap_LookupAtom("functor");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomGT = Yap_LookupAtom(">");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomGVar = Yap_LookupAtom("var");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomGc = Yap_FullLookupAtom("$gc");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomGcMargin = Yap_FullLookupAtom("$gc_margin");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomGcTrace = Yap_FullLookupAtom("$gc_trace");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomGcVerbose = Yap_FullLookupAtom("$gc_verbose");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomGcVeryVerbose = Yap_FullLookupAtom("$gc_very_verbose");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomGeneratePredInfo = Yap_FullLookupAtom("$generate_pred_info");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomGetwork = Yap_FullLookupAtom("$getwork");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomGetworkSeq = Yap_FullLookupAtom("$getwork_seq");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomGlobal = Yap_LookupAtom("global");
							 | 
						
					
						
							
								
									
										
										
										
											2010-04-16 02:08:06 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomGlobalSp = Yap_LookupAtom("global_sp");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomGlobalTrie = Yap_LookupAtom("global_trie");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomGoalExpansion = Yap_LookupAtom("goal_expansion");
							 | 
						
					
						
							
								
									
										
										
										
											2013-01-14 22:46:06 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomHat = Yap_LookupAtom("^");
							 | 
						
					
						
							
								
									
										
										
										
											2009-02-09 21:56:40 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomHERE = Yap_LookupAtom("\n   <====HERE====>  \n");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomHandleThrow = Yap_FullLookupAtom("$handle_throw");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomHeap = Yap_LookupAtom("heap");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomHeapUsed = Yap_LookupAtom("heapused");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomHugeInt = Yap_LookupAtom("huge_int");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomIDB = Yap_LookupAtom("idb");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomIOMode = Yap_LookupAtom("io_mode");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomId = Yap_LookupAtom("id");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomIgnore = Yap_LookupAtom("ignore");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomInf = Yap_LookupAtom("inf");
							 | 
						
					
						
							
								
									
										
										
										
											2013-04-29 18:22:53 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomInfinity = Yap_LookupAtom("infinity");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomInitGoal = Yap_FullLookupAtom("$init_goal");
							 | 
						
					
						
							
								
									
										
										
										
											2012-09-21 11:49:59 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomInitProlog = Yap_FullLookupAtom("$init_prolog");
							 | 
						
					
						
							
								
									
										
										
										
											2009-06-13 16:05:45 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomInStackExpansion = Yap_LookupAtom("in stack expansion");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomInput = Yap_LookupAtom("input");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomInstantiationError = Yap_LookupAtom("instantiation_error");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomInt = Yap_LookupAtom("int");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomIntOverflow = Yap_LookupAtom("int_overflow");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomInteger = Yap_LookupAtom("integer");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomInternalCompilerError = Yap_LookupAtom("internal_compiler_error");
							 | 
						
					
						
							
								
									
										
										
										
											2009-02-09 21:56:40 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomIs = Yap_LookupAtom("is");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomKey = Yap_LookupAtom("key");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomLDLibraryPath = Yap_LookupAtom("LD_LIBRARY_PATH");
							 | 
						
					
						
							
								
									
										
										
										
											2009-02-09 21:56:40 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomLONGINT = Yap_LookupAtom("LongInt");
							 | 
						
					
						
							
								
									
										
										
										
											2010-11-01 20:11:28 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomLOOP = Yap_LookupAtom("_LOOP_");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomLoopStream = Yap_LookupAtom("loop_stream");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomLT = Yap_LookupAtom("<");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomLastExecuteWithin = Yap_FullLookupAtom("$last_execute_within");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomLeash = Yap_FullLookupAtom("$leash");
							 | 
						
					
						
							
								
									
										
										
										
											2013-06-25 22:53:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomLeast = Yap_LookupAtom("least");
							 | 
						
					
						
							
								
									
										
										
										
											2011-10-27 12:36:48 +02:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomLength = Yap_FullLookupAtom("length");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomList = Yap_LookupAtom("list");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomLine = Yap_LookupAtom("line");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomLive = Yap_FullLookupAtom("$live");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomLoadAnswers = Yap_LookupAtom("load_answers");
							 | 
						
					
						
							
								
									
										
										
										
											2010-04-16 02:08:06 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomLocal = Yap_LookupAtom("local");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomLocalSp = Yap_LookupAtom("local_sp");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomLocalTrie = Yap_LookupAtom("local_trie");
							 | 
						
					
						
							
								
									
										
										
										
											2013-04-16 20:04:53 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMax = Yap_LookupAtom("max");
							 | 
						
					
						
							
								
									
										
										
										
											2013-06-25 22:53:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMaximum = Yap_LookupAtom("maximum");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMaxArity = Yap_LookupAtom("max_arity");
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMaxFiles = Yap_LookupAtom("max_files");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMegaClause = Yap_FullLookupAtom("$mega_clause");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMetaCall = Yap_FullLookupAtom("$call");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMfClause = Yap_FullLookupAtom("$mf_clause");
							 | 
						
					
						
							
								
									
										
										
										
											2013-04-16 20:04:53 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMin = Yap_LookupAtom("min");
							 | 
						
					
						
							
								
									
										
										
										
											2013-06-25 22:53:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMinimum = Yap_LookupAtom("minimum");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMinus = Yap_LookupAtom("-");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomModify = Yap_LookupAtom("modify");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomModule = Yap_LookupAtom("module");
							 | 
						
					
						
							
								
									
										
										
										
											2013-06-25 22:53:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMost = Yap_LookupAtom("most");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMulti = Yap_LookupAtom("multi");
							 | 
						
					
						
							
								
									
										
										
										
											2010-12-15 00:06:14 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMultiFile = Yap_FullLookupAtom("$mf");
							 | 
						
					
						
							
								
									
										
										
										
											2014-04-23 21:39:32 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMultiple = Yap_FullLookupAtom("multiple");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMutable = Yap_LookupAtom("mutable");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMutableVariable = Yap_FullLookupAtom("$mutable_variable");
							 | 
						
					
						
							
								
									
										
										
										
											2014-11-27 10:02:04 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMutex = Yap_LookupAtom("mutex");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMyddasDB = Yap_FullLookupAtom("$myddas_db");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMyddasGoal = Yap_FullLookupAtom("$myddas_goal");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMyddasHost = Yap_FullLookupAtom("$myddas_host");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMyddasPass = Yap_FullLookupAtom("$myddas_pass");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMyddasUser = Yap_FullLookupAtom("$myddas_user");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomMyddasVersionName = Yap_FullLookupAtom("$myddas_version_name");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomNan = Yap_LookupAtom("nan");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomNb = Yap_LookupAtom("nb");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomNbTerm = Yap_LookupAtom("nb_term");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomNew = Yap_LookupAtom("new");
							 | 
						
					
						
							
								
									
										
										
										
											2015-08-18 14:36:10 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomNewLine = Yap_LookupAtom("nl");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomNl = Yap_LookupAtom("nl");
							 | 
						
					
						
							
								
									
										
										
										
											2014-04-23 21:39:32 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomNoEffect = Yap_LookupAtom("no_effect");
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomNoMemory = Yap_LookupAtom("no_memory");
							 | 
						
					
						
							
								
									
										
										
										
											2010-08-03 21:04:16 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomNone = Yap_LookupAtom("none");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomNonEmptyList = Yap_LookupAtom("non_empty_list");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomNot = Yap_LookupAtom("\\+");
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomNotImplemented = Yap_LookupAtom("not_implemented");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomNotLessThanZero = Yap_LookupAtom("not_less_than_zero");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomNotNewline = Yap_LookupAtom("not_newline");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomNotZero = Yap_LookupAtom("not_zero");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomNumber = Yap_LookupAtom("number");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOff = Yap_LookupAtom("off");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOffline = Yap_LookupAtom("offline");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOn = Yap_LookupAtom("on");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOnline = Yap_LookupAtom("online");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOpen = Yap_LookupAtom("open");
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-25 10:57:26 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOperatingSystemError = Yap_LookupAtom("operating_SYSTEM_ERROR_INTERNAL");
							 | 
						
					
						
							
								
									
										
										
										
											2010-04-22 12:11:15 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOperatingSystemSupport = Yap_LookupAtom("operating_system_support");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOperator = Yap_LookupAtom("operator");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOperatorPriority = Yap_LookupAtom("operator_priority");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOperatorSpecifier = Yap_LookupAtom("operator_specifier");
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-21 17:05:36 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOpt = Yap_LookupAtom("opt");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOtherwise = Yap_LookupAtom("otherwise");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOutOfAttvarsError = Yap_LookupAtom("out_of_attvars_error");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOutOfAuxspaceError = Yap_LookupAtom("out_of_auxspace_error");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOutOfHeapError = Yap_LookupAtom("out_of_heap_error");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOutOfRange = Yap_LookupAtom("out_of_range");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOutOfStackError = Yap_LookupAtom("out_of_stack_error");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOutOfTrailError = Yap_LookupAtom("out_of_trail_error");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomOutput = Yap_LookupAtom("output");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomParameter = Yap_LookupAtom("parameter");
							 | 
						
					
						
							
								
									
										
										
										
											2009-02-16 12:25:03 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomPrologCommonsDir = Yap_LookupAtom("prolog_commons_directory");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomPast = Yap_LookupAtom("past");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomPastEndOfStream = Yap_LookupAtom("past_end_of_stream");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomPermissionError = Yap_LookupAtom("permission_error");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomPi = Yap_LookupAtom("pi");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomPipe = Yap_LookupAtom("pipe");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomPlus = Yap_LookupAtom("+");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomPointer = Yap_LookupAtom("pointer");
							 | 
						
					
						
							
								
									
										
										
										
											2014-10-23 01:21:22 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomPortray = Yap_FullLookupAtom("portray");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomPredicateIndicator = Yap_LookupAtom("predicate_indicator");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomPrimitive = Yap_LookupAtom("primitive");
							 | 
						
					
						
							
								
									
										
										
										
											2013-11-21 00:22:03 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomPrintMessage = Yap_LookupAtom("print_message");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomPrivateProcedure = Yap_LookupAtom("private_procedure");
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomProcedure = Yap_LookupAtom("procedure");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomProfile = Yap_FullLookupAtom("$profile");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomProlog = Yap_LookupAtom("prolog");
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-21 17:05:36 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomQly = Yap_LookupAtom("qly");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomQuery = Yap_LookupAtom("?-");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomQueue = Yap_LookupAtom("queue");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomQuiet = Yap_LookupAtom("quiet");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomRadix = Yap_LookupAtom("radix");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomRandom = Yap_LookupAtom("random");
							 | 
						
					
						
							
								
									
										
										
										
											2012-10-23 14:55:44 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomRange = Yap_LookupAtom("range");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomRDiv = Yap_LookupAtom("rdiv");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomRead = Yap_LookupAtom("read");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomReadOnly = Yap_LookupAtom("read_only");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomReadWrite = Yap_LookupAtom("read_write");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomReadutil = Yap_LookupAtom("readutil");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomRecordedP = Yap_FullLookupAtom("$recordep");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomRecordedWithKey = Yap_FullLookupAtom("$recorded_with_key");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomRedefineWarnings = Yap_LookupAtom("redefine_warnings");
							 | 
						
					
						
							
								
									
										
										
										
											2009-06-05 18:45:41 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomRedoFreeze = Yap_FullLookupAtom("$redo_freeze");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomRefoundVar = Yap_FullLookupAtom("$I_FOUND_THE_VARIABLE_AGAIN");
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-21 17:05:36 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomRelativeTo = Yap_FullLookupAtom("relative_to");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomRepeat = Yap_LookupAtom("repeat");
							 | 
						
					
						
							
								
									
										
										
										
											2009-02-09 21:56:40 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomRepeatSpace = Yap_LookupAtom("repeat ");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomReposition = Yap_LookupAtom("reposition");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomRepresentationError = Yap_LookupAtom("representation_error");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomReset = Yap_LookupAtom("reset");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomResize = Yap_LookupAtom("resize");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomResourceError = Yap_LookupAtom("resource_error");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomRestoreRegs = Yap_FullLookupAtom("$restore_regs");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomRetryCounter = Yap_LookupAtom("retry_counter");
							 | 
						
					
						
							
								
									
										
										
										
											2009-02-12 16:39:20 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomRTree = Yap_LookupAtom("rtree");
							 | 
						
					
						
							
								
									
										
										
										
											2009-03-10 16:24:26 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSafe = Yap_FullLookupAtom("$safe");
							 | 
						
					
						
							
								
									
										
										
										
											2009-11-27 11:21:24 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSafeCallCleanup = Yap_FullLookupAtom("$safe_call_cleanup");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSame = Yap_LookupAtom("==");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSemic = Yap_LookupAtom(";");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomShiftCountOverflow = Yap_LookupAtom("shift_count_overflow");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigAlarm = Yap_LookupAtom("sig_alarm");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigBreak = Yap_LookupAtom("sig_break");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigCreep = Yap_LookupAtom("sig_creep");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigDebug = Yap_LookupAtom("sig_debug");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigDelayCreep = Yap_LookupAtom("sig_delay_creep");
							 | 
						
					
						
							
								
									
										
										
										
											2014-10-15 11:06:07 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigFPE = Yap_LookupAtom("sig_fpe");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigHup = Yap_LookupAtom("sig_hup");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigInt = Yap_LookupAtom("sig_int");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigIti = Yap_LookupAtom("sig_iti");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigPending = Yap_FullLookupAtom("$sig_pending");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigPipe = Yap_LookupAtom("sig_pipe");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigStackDump = Yap_LookupAtom("sig_stack_dump");
							 | 
						
					
						
							
								
									
										
										
										
											2010-04-28 00:32:37 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigStatistics = Yap_LookupAtom("sig_statistics");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigTrace = Yap_LookupAtom("sig_trace");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigUsr1 = Yap_LookupAtom("sig_usr1");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigUsr2 = Yap_LookupAtom("sig_usr2");
							 | 
						
					
						
							
								
									
										
										
										
											2009-06-03 10:09:14 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigVTAlarm = Yap_LookupAtom("sig_vtalarm");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSigWakeUp = Yap_LookupAtom("sig_wake_up");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSilent = Yap_LookupAtom("Silent");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSingle = Yap_LookupAtom("single");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSingleVarWarnings = Yap_LookupAtom("single_var_warnings");
							 | 
						
					
						
							
								
									
										
										
										
											2014-04-23 21:39:32 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSingleton = Yap_LookupAtom("singleton");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSlash = Yap_LookupAtom("/");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSocket = Yap_LookupAtom("socket");
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-21 17:05:36 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSolutions = Yap_LookupAtom("solutions");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSource = Yap_LookupAtom("source");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSourceSink = Yap_LookupAtom("source_sink");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSpy = Yap_FullLookupAtom("$spy");
							 | 
						
					
						
							
								
									
										
										
										
											2009-04-25 11:01:33 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomStack = Yap_LookupAtom("stack");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomStackFree = Yap_LookupAtom("stackfree");
							 | 
						
					
						
							
								
									
										
										
										
											2010-12-07 15:06:53 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomStartupSavedState = Yap_FullLookupAtom("$startup_saved_state");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomStaticClause = Yap_FullLookupAtom("$static_clause");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomStaticProcedure = Yap_LookupAtom("static_procedure");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomStream = Yap_FullLookupAtom("$stream");
							 | 
						
					
						
							
								
									
										
										
										
											2012-02-27 08:53:18 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSWIStream = Yap_FullLookupAtom("<stream>");
							 | 
						
					
						
							
								
									
										
										
										
											2010-02-26 10:59:43 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomVStream = Yap_LookupAtom("stream");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomStreams = Yap_LookupAtom("streams");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomStreamOrAlias = Yap_LookupAtom("stream_or_alias");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomStreamPos = Yap_FullLookupAtom("$stream_position");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomStreamPosition = Yap_LookupAtom("stream_position");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomString = Yap_LookupAtom("string");
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-21 17:05:36 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomStyleCheck = Yap_LookupAtom("style_check");
							 | 
						
					
						
							
								
									
										
										
										
											2013-12-02 14:49:41 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSTRING = Yap_FullLookupAtom("String");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSwi = Yap_LookupAtom("swi");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSymbolChar = Yap_LookupAtom("symbol_char");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSyntaxError = Yap_LookupAtom("syntax_error");
							 | 
						
					
						
							
								
									
										
										
										
											2015-07-06 12:01:55 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSyntaxErrors = Yap_LookupAtom("syntax_errors");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSyntaxErrorHandler = Yap_LookupAtom("syntax_error_handler");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSystem = Yap_LookupAtom("system");
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-25 10:57:26 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSystemError = Yap_LookupAtom("SYSTEM_ERROR_INTERNAL");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomSystemLibraryDir = Yap_LookupAtom("system_library_directory");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomTerm = Yap_LookupAtom("term");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomTerms = Yap_LookupAtom("terms");
							 | 
						
					
						
							
								
									
										
										
										
											2012-12-07 08:08:32 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomTermExpansion = Yap_LookupAtom("term_expansion");
							 | 
						
					
						
							
								
									
										
										
										
											2013-12-08 19:12:24 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomText = Yap_LookupAtom("text");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomTextStream = Yap_LookupAtom("text_stream");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomThread = Yap_LookupAtom("thread");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomThreads = Yap_LookupAtom("threads");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomThrow = Yap_LookupAtom("throw");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomTimeOutSpec = Yap_LookupAtom("time_out_spec");
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomTimeoutError = Yap_LookupAtom("timeout_error");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomTopLevelGoal = Yap_FullLookupAtom("$top_level_goal");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomTopThreadGoal = Yap_FullLookupAtom("$top_thread_goal");
							 | 
						
					
						
							
								
									
										
										
										
											2015-07-22 19:19:35 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomTraceMetaCall = Yap_FullLookupAtom("$trace_meta_call");
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-17 09:42:56 -07:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomTrail = Yap_LookupAtom("trail");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomTrue = Yap_LookupAtom("true");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomTty = Yap_LookupAtom("tty");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomTtys = Yap_LookupAtom("ttys");
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-21 17:05:36 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomTxt = Yap_LookupAtom("txt");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomTypeError = Yap_LookupAtom("type_error");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomUndefined = Yap_LookupAtom("undefined");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomUndefp = Yap_FullLookupAtom("$undefp");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomUnderflow = Yap_LookupAtom("underflow");
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-17 09:42:56 -07:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomUnificationStack = Yap_LookupAtom("unification_stack");
							 | 
						
					
						
							
								
									
										
										
										
											2013-04-29 11:58:05 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomUnique = Yap_LookupAtom("unique");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomUnsignedByte = Yap_LookupAtom("unsigned_byte");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomUnsignedChar = Yap_LookupAtom("unsigned_char");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomUser = Yap_LookupAtom("user");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomUserErr = Yap_LookupAtom("user_error");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomUserIn = Yap_LookupAtom("user_input");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomUserOut = Yap_LookupAtom("user_output");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomVBar = Yap_LookupAtom("|");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomVar = Yap_FullLookupAtom("$VAR");
							 | 
						
					
						
							
								
									
										
										
										
											2014-04-23 21:39:32 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomVarBranches = Yap_LookupAtom("var_branches");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomVariableNames = Yap_LookupAtom("variable_names");
							 | 
						
					
						
							
								
									
										
										
										
											2012-03-15 22:19:48 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomHiddenVar = Yap_FullLookupAtom("$V");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomVariable = Yap_LookupAtom("variable");
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-21 17:05:36 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomVerboseFileSearch = Yap_LookupAtom("verbose_file_search");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomVersionNumber = Yap_FullLookupAtom("$version_name");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomWakeUpGoal = Yap_FullLookupAtom("$wake_up_goal");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomWarning = Yap_LookupAtom("warning");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomWhen = Yap_FullLookupAtom("$when");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomWrite = Yap_LookupAtom("write");
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomXml = Yap_LookupAtom("xml");
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomYapHacks = Yap_LookupAtom("yap_hacks");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  AtomZeroDivisor = Yap_LookupAtom("zero_divisor");
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorAfInet = Yap_MkFunctor(AtomAfInet,2);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorAfLocal = Yap_MkFunctor(AtomAfLocal,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorAfUnix = Yap_MkFunctor(AtomAfUnix,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorAltNot = Yap_MkFunctor(AtomAltNot,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorArg = Yap_MkFunctor(AtomArg,3);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorArrayEntry = Yap_MkFunctor(AtomArrayAccess,3);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorArrow = Yap_MkFunctor(AtomArrow,2);
							 | 
						
					
						
							
								
									
										
										
										
											2014-04-24 08:26:31 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDoubleArrow = Yap_MkFunctor(AtomDoubleArrow,2);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorAssert1 = Yap_MkFunctor(AtomAssert,1);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorAssert = Yap_MkFunctor(AtomAssert,2);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorAtFoundOne = Yap_MkFunctor(AtomFoundVar,2);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorAtom = Yap_MkFunctor(AtomAtom,1);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-24 09:04:44 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorAtt1 = Yap_MkFunctor(AtomAtt1,3);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorAttGoal = Yap_MkFunctor(AtomAttDo,2);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorBraces = Yap_MkFunctor(AtomBraces,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorCall = Yap_MkFunctor(AtomCall,1);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorCatch = Yap_MkFunctor(AtomCatch,3);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorChangeModule = Yap_MkFunctor(AtomChangeModule,1);
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorChars = Yap_MkFunctor(AtomChars,2);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorChars1 = Yap_MkFunctor(AtomChars,1);
							 | 
						
					
						
							
								
									
										
										
										
											2009-06-05 18:45:41 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorCleanCall = Yap_MkFunctor(AtomCleanCall,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorClist = Yap_MkFunctor(AtomWhen,4);
							 | 
						
					
						
							
								
									
										
										
										
											2010-07-19 14:48:42 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorCodes = Yap_MkFunctor(AtomCodes,2);
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorCodes1 = Yap_MkFunctor(AtomCodes,1);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorComma = Yap_MkFunctor(AtomComma,2);
							 | 
						
					
						
							
								
									
										
										
										
											2013-12-08 22:56:48 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorCommentHook = Yap_MkFunctor(AtomCommentHook,3);
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorContext2 = Yap_MkFunctor(AtomContext,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorConsistencyError = Yap_MkFunctor(AtomConsistencyError,1);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorCreep = Yap_MkFunctor(AtomCreep,1);
							 | 
						
					
						
							
								
									
										
										
										
											2014-06-11 19:36:50 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorCsult = Yap_MkFunctor(AtomCsult,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorCurrentModule = Yap_MkFunctor(AtomCurrentModule,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorCutBy = Yap_MkFunctor(AtomCutBy,1);
							 | 
						
					
						
							
								
									
										
										
										
											2011-03-11 19:49:32 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDBREF = Yap_MkFunctor(AtomDBREF,1);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDiff = Yap_MkFunctor(AtomDiff,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDoLogUpdClause = Yap_MkFunctor(AtomDoLogUpdClause,6);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDoLogUpdClause0 = Yap_MkFunctor(AtomDoLogUpdClause0,6);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDoLogUpdClauseErase = Yap_MkFunctor(AtomDoLogUpdClauseErase,6);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDoStaticClause = Yap_MkFunctor(AtomDoStaticClause,5);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDomainError = Yap_MkFunctor(AtomDomainError,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDot = Yap_MkFunctor(AtomDot,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-24 09:04:44 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDot10 = Yap_MkFunctor(AtomDot,10);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDot11 = Yap_MkFunctor(AtomDot,11);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDot12 = Yap_MkFunctor(AtomDot,12);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDot2 = Yap_MkFunctor(AtomDot,2);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDot3 = Yap_MkFunctor(AtomDot,3);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDot4 = Yap_MkFunctor(AtomDot,4);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDot5 = Yap_MkFunctor(AtomDot,5);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDot6 = Yap_MkFunctor(AtomDot,6);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDot7 = Yap_MkFunctor(AtomDot,7);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDot8 = Yap_MkFunctor(AtomDot,8);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorDot9 = Yap_MkFunctor(AtomDot,9);
							 | 
						
					
						
							
								
									
										
										
										
											2013-09-13 11:44:26 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorEmptySquareBrackets = Yap_MkFunctor(AtomEmptySquareBrackets,2);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorEmptyCurlyBrackets = Yap_MkFunctor(AtomEmptyCurlyBrackets,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorEq = Yap_MkFunctor(AtomEq,2);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorError = Yap_MkFunctor(AtomError,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorEvaluationError = Yap_MkFunctor(AtomEvaluationError,1);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorExecute2InMod = Yap_MkFunctor(AtomExecuteWoMod,2);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorExecuteInMod = Yap_MkFunctor(AtomExecuteInMod,2);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorExecuteWithin = Yap_MkFunctor(AtomExecuteWithin,1);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorExistenceError = Yap_MkFunctor(AtomExistenceError,2);
							 | 
						
					
						
							
								
									
										
										
										
											2013-01-11 16:45:14 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorExoClause = Yap_MkFunctor(AtomExoClause,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorFunctor = Yap_MkFunctor(AtomFunctor,3);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorGAtom = Yap_MkFunctor(AtomAtom,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorGAtomic = Yap_MkFunctor(AtomAtomic,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorGCompound = Yap_MkFunctor(AtomCompound,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorGFloat = Yap_MkFunctor(AtomFloat,1);
							 | 
						
					
						
							
								
									
										
										
										
											2009-10-21 00:07:31 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorGFormatAt = Yap_MkFunctor(AtomFormatAt,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorGInteger = Yap_MkFunctor(AtomInteger,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorGNumber = Yap_MkFunctor(AtomNumber,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorGPrimitive = Yap_MkFunctor(AtomPrimitive,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorGVar = Yap_MkFunctor(AtomGVar,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorGeneratePredInfo = Yap_MkFunctor(AtomGeneratePredInfo,4);
							 | 
						
					
						
							
								
									
										
										
										
											2012-11-07 13:49:54 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorGoalExpansion2 = Yap_MkFunctor(AtomGoalExpansion,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorGoalExpansion = Yap_MkFunctor(AtomGoalExpansion,3);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorHandleThrow = Yap_MkFunctor(AtomHandleThrow,3);
							 | 
						
					
						
							
								
									
										
										
										
											2013-01-14 22:46:06 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorHat = Yap_MkFunctor(AtomHat,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorId = Yap_MkFunctor(AtomId,1);
							 | 
						
					
						
							
								
									
										
										
										
											2009-02-09 21:56:40 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorIs = Yap_MkFunctor(AtomIs,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorLastExecuteWithin = Yap_MkFunctor(AtomLastExecuteWithin,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorList = Yap_MkFunctor(AtomDot,2);
							 | 
						
					
						
							
								
									
										
										
										
											2010-11-01 20:11:28 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorLOOP = Yap_MkFunctor(AtomLOOP,1);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorMegaClause = Yap_MkFunctor(AtomMegaClause,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorMetaCall = Yap_MkFunctor(AtomMetaCall,4);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-24 09:04:44 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorMinus = Yap_MkFunctor(AtomMinus,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorModule = Yap_MkFunctor(AtomColomn,2);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorMultiFileClause = Yap_MkFunctor(AtomMfClause,5);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorMutable = Yap_MkFunctor(AtomMutableVariable,(sizeof(timed_var)/sizeof(CELL)));
							 | 
						
					
						
							
								
									
										
										
										
											2014-11-27 10:02:04 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorMutex = Yap_MkFunctor(AtomMutex,2);
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorNotImplemented = Yap_MkFunctor(AtomNotImplemented,2);
							 | 
						
					
						
							
								
									
										
										
										
											2010-03-12 22:40:17 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorNBQueue = Yap_MkFunctor(AtomQueue,4);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorNot = Yap_MkFunctor(AtomNot,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorOr = Yap_MkFunctor(AtomSemic,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorPermissionError = Yap_MkFunctor(AtomPermissionError,3);
							 | 
						
					
						
							
								
									
										
										
										
											2011-04-04 13:20:35 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorPlus = Yap_MkFunctor(AtomPlus,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorPortray = Yap_MkFunctor(AtomPortray,1);
							 | 
						
					
						
							
								
									
										
										
										
											2013-11-21 00:22:03 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorPrintMessage = Yap_MkFunctor(AtomPrintMessage,2);
							 | 
						
					
						
							
								
									
										
										
										
											2009-06-05 18:45:41 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorPrologConstraint = Yap_MkFunctor(AtomProlog,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorQuery = Yap_MkFunctor(AtomQuery,1);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorRecordedWithKey = Yap_MkFunctor(AtomRecordedWithKey,6);
							 | 
						
					
						
							
								
									
										
										
										
											2010-05-28 09:53:56 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorRDiv = Yap_MkFunctor(AtomRDiv,2);
							 | 
						
					
						
							
								
									
										
										
										
											2009-06-05 18:45:41 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorRedoFreeze = Yap_MkFunctor(AtomRedoFreeze,3);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorRepresentationError = Yap_MkFunctor(AtomRepresentationError,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorResourceError = Yap_MkFunctor(AtomResourceError,1);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorRestoreRegs = Yap_MkFunctor(AtomRestoreRegs,2);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorRestoreRegs1 = Yap_MkFunctor(AtomRestoreRegs,1);
							 | 
						
					
						
							
								
									
										
										
										
											2009-03-10 16:24:26 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorSafe = Yap_MkFunctor(AtomSafe,1);
							 | 
						
					
						
							
								
									
										
										
										
											2009-11-27 11:21:24 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorSafeCallCleanup = Yap_MkFunctor(AtomSafeCallCleanup,4);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorSame = Yap_MkFunctor(AtomSame,2);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorSlash = Yap_MkFunctor(AtomSlash,2);
							 | 
						
					
						
							
								
									
										
										
										
											2013-11-07 23:51:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorStaticClause = Yap_MkFunctor(AtomStaticClause,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorStream = Yap_MkFunctor(AtomStream,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorStreamEOS = Yap_MkFunctor(AtomEndOfStream,1);
							 | 
						
					
						
							
								
									
										
										
										
											2011-02-14 23:39:27 -08:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorStreamPos = Yap_MkFunctor(AtomStreamPos,4);
							 | 
						
					
						
							
								
									
										
										
										
											2015-06-19 00:56:24 +01:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorString1 = Yap_MkFunctor(AtomString,1);
							 | 
						
					
						
							
								
									
										
										
										
											2015-09-21 17:05:36 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorStyleCheck = Yap_MkFunctor(AtomStyleCheck,4);
							 | 
						
					
						
							
								
									
										
										
										
											2015-08-18 14:36:10 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorSyntaxError = Yap_MkFunctor(AtomSyntaxError,4);
							 | 
						
					
						
							
								
									
										
										
										
											2010-02-26 13:30:16 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorShortSyntaxError = Yap_MkFunctor(AtomSyntaxError,1);
							 | 
						
					
						
							
								
									
										
										
										
											2012-12-07 08:08:32 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorTermExpansion = Yap_MkFunctor(AtomTermExpansion,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorThreadRun = Yap_MkFunctor(AtomTopThreadGoal,2);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorThrow = Yap_MkFunctor(AtomThrow,1);
							 | 
						
					
						
							
								
									
										
										
										
											2009-05-30 12:52:23 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorTimeoutError = Yap_MkFunctor(AtomTimeoutError,2);
							 | 
						
					
						
							
								
									
										
										
										
											2015-07-22 19:19:35 -05:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorTraceMetaCall = Yap_MkFunctor(AtomTraceMetaCall,3);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 02:20:22 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorTypeError = Yap_MkFunctor(AtomTypeError,2);
							 | 
						
					
						
							
								
									
										
										
										
											2008-12-23 01:53:52 +00:00
										 
									 
								 
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorUMinus = Yap_MkFunctor(AtomMinus,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorUPlus = Yap_MkFunctor(AtomPlus,1);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorVBar = Yap_MkFunctor(AtomVBar,2);
							 | 
						
					
						
							| 
								
							 | 
							
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorVar = Yap_MkFunctor(AtomVar,1);
							 | 
						
					
						
							
								
									
										
										
										
											2012-03-15 22:19:48 +00:00
										 
									 
								 
							 | 
							
								
									
										
									
								
							 | 
							
								
							 | 
							
								
									
								 | 
							
							
								  FunctorHiddenVar = Yap_MkFunctor(AtomHiddenVar,1);
							 |