/* This file, iatoms.h, was generated automatically by "yap -L misc/buildatoms" {lease do not update, update misc/ATOMS instead */ Atom3Dots = Yap_LookupAtom("..."); AtomAbol = Yap_FullLookupAtom("$abol"); TermAbol = MkAtomTerm(AtomAbol); AtomAccess = Yap_LookupAtom("access"); TermAccess = MkAtomTerm(AtomAccess); AtomAfInet = Yap_LookupAtom("AF_INET"); TermAfInet = MkAtomTerm(AtomAfInet); AtomAfLocal = Yap_LookupAtom("AF_LOCAL"); TermAfLocal = MkAtomTerm(AtomAfLocal); AtomAfUnix = Yap_LookupAtom("AF_UNIX"); TermAfUnix = MkAtomTerm(AtomAfUnix); AtomAlarm = Yap_FullLookupAtom("$alarm"); TermAlarm = MkAtomTerm(AtomAlarm); AtomAlias = Yap_LookupAtom("alias"); TermAlias = MkAtomTerm(AtomAlias); AtomAll = Yap_LookupAtom("all"); TermAll = MkAtomTerm(AtomAll); AtomAltNot = Yap_LookupAtom("not"); TermAltNot = MkAtomTerm(AtomAltNot); AtomAnswer = Yap_LookupAtom("answer"); TermAnswer = MkAtomTerm(AtomAnswer); AtomAny = Yap_LookupAtom("any"); TermAny = MkAtomTerm(AtomAny); AtomAppend = Yap_LookupAtom("append"); TermAppend = MkAtomTerm(AtomAppend); AtomArg = Yap_LookupAtom("arg"); TermArg = MkAtomTerm(AtomArg); AtomArray = Yap_FullLookupAtom("$array"); TermArray = MkAtomTerm(AtomArray); AtomArrayAccess = Yap_FullLookupAtom("$array_arg"); TermArrayAccess = MkAtomTerm(AtomArrayAccess); AtomArrayOverflow = Yap_LookupAtom("array_overflow"); TermArrayOverflow = MkAtomTerm(AtomArrayOverflow); AtomArrayType = Yap_LookupAtom("array_type"); TermArrayType = MkAtomTerm(AtomArrayType); AtomArrow = Yap_LookupAtom("->"); TermArrow = MkAtomTerm(AtomArrow); AtomAttributedModule = Yap_LookupAtom("attributes_module"); TermAttributedModule = MkAtomTerm(AtomAttributedModule); AtomDoubleArrow = Yap_LookupAtom("-->"); TermDoubleArrow = MkAtomTerm(AtomDoubleArrow); AtomAssert = Yap_LookupAtom(":-"); TermAssert = MkAtomTerm(AtomAssert); AtomEmptyBrackets = Yap_LookupAtom("()"); TermEmptyBrackets = MkAtomTerm(AtomEmptyBrackets); AtomEmptySquareBrackets = Yap_LookupAtom("[]"); TermEmptySquareBrackets = MkAtomTerm(AtomEmptySquareBrackets); AtomEmptyCurlyBrackets = Yap_LookupAtom("{}"); TermEmptyCurlyBrackets = MkAtomTerm(AtomEmptyCurlyBrackets); AtomAsserta = Yap_LookupAtom("asserta"); TermAsserta = MkAtomTerm(AtomAsserta); AtomAssertaStatic = Yap_LookupAtom("asserta_static"); TermAssertaStatic = MkAtomTerm(AtomAssertaStatic); AtomAssertz = Yap_LookupAtom("assertz"); TermAssertz = MkAtomTerm(AtomAssertz); AtomAssertzStatic = Yap_LookupAtom("assertz_static"); TermAssertzStatic = MkAtomTerm(AtomAssertzStatic); AtomAt = Yap_LookupAtom("at"); TermAt = MkAtomTerm(AtomAt); AtomAtom = Yap_LookupAtom("atom"); TermAtom = MkAtomTerm(AtomAtom); AtomAtomic = Yap_LookupAtom("atomic"); TermAtomic = MkAtomTerm(AtomAtomic); AtomAtt = Yap_FullLookupAtom("$att"); TermAtt = MkAtomTerm(AtomAtt); AtomAtt1 = Yap_LookupAtom("att"); TermAtt1 = MkAtomTerm(AtomAtt1); AtomAttDo = Yap_FullLookupAtom("$att_do"); TermAttDo = MkAtomTerm(AtomAttDo); AtomAttributes = Yap_LookupAtom("attributes"); TermAttributes = MkAtomTerm(AtomAttributes); AtomB = Yap_FullLookupAtom("$last_choice_pt"); TermB = MkAtomTerm(AtomB); AtomBatched = Yap_LookupAtom("batched"); TermBatched = MkAtomTerm(AtomBatched); AtomBetween = Yap_LookupAtom("between"); TermBetween = MkAtomTerm(AtomBetween); AtomBinary = Yap_LookupAtom("binary"); TermBinary = MkAtomTerm(AtomBinary); AtomBigNum = Yap_LookupAtom("big_num"); TermBigNum = MkAtomTerm(AtomBigNum); AtomBinaryStream = Yap_LookupAtom("binary_stream"); TermBinaryStream = MkAtomTerm(AtomBinaryStream); AtomBoolean = Yap_LookupAtom("boolean"); TermBoolean = MkAtomTerm(AtomBoolean); AtomBraces = Yap_LookupAtom("{}"); TermBraces = MkAtomTerm(AtomBraces); AtomBreak = Yap_FullLookupAtom("$break"); TermBreak = MkAtomTerm(AtomBreak); AtomByte = Yap_LookupAtom("byte"); TermByte = MkAtomTerm(AtomByte); AtomCArith = Yap_FullLookupAtom("$c_arith"); TermCArith = MkAtomTerm(AtomCArith); AtomCall = Yap_LookupAtom("call"); TermCall = MkAtomTerm(AtomCall); AtomCallAndRetryCounter = Yap_LookupAtom("call_and_retry_counter"); TermCallAndRetryCounter = MkAtomTerm(AtomCallAndRetryCounter); AtomCallCounter = Yap_LookupAtom("call_counter"); TermCallCounter = MkAtomTerm(AtomCallCounter); AtomCallable = Yap_LookupAtom("callable"); TermCallable = MkAtomTerm(AtomCallable); AtomCatch = Yap_FullLookupAtom("$catch"); TermCatch = MkAtomTerm(AtomCatch); AtomChangeModule = Yap_FullLookupAtom("$change_module"); TermChangeModule = MkAtomTerm(AtomChangeModule); AtomChar = Yap_LookupAtom("char"); TermChar = MkAtomTerm(AtomChar); AtomCharsio = Yap_LookupAtom("charsio"); TermCharsio = MkAtomTerm(AtomCharsio); AtomCharacter = Yap_LookupAtom("character"); TermCharacter = MkAtomTerm(AtomCharacter); AtomCharacterCode = Yap_LookupAtom("character_code"); TermCharacterCode = MkAtomTerm(AtomCharacterCode); AtomChars = Yap_LookupAtom("chars"); TermChars = MkAtomTerm(AtomChars); AtomCharset = Yap_LookupAtom("charset"); TermCharset = MkAtomTerm(AtomCharset); AtomChType = Yap_FullLookupAtom("$char_type"); TermChType = MkAtomTerm(AtomChType); AtomCleanCall = Yap_FullLookupAtom("$clean_call"); TermCleanCall = MkAtomTerm(AtomCleanCall); AtomColon = Yap_LookupAtom(":"); TermColon = MkAtomTerm(AtomColon); AtomCodeSpace = Yap_LookupAtom("code_space"); TermCodeSpace = MkAtomTerm(AtomCodeSpace); AtomCodes = Yap_LookupAtom("codes"); TermCodes = MkAtomTerm(AtomCodes); AtomCoInductive = Yap_LookupAtom("coinductive"); TermCoInductive = MkAtomTerm(AtomCoInductive); AtomComma = Yap_LookupAtom(","); TermComma = MkAtomTerm(AtomComma); AtomCommentHook = Yap_LookupAtom("comment_hook"); TermCommentHook = MkAtomTerm(AtomCommentHook); AtomCompact = Yap_LookupAtom("compact"); TermCompact = MkAtomTerm(AtomCompact); AtomCompound = Yap_LookupAtom("compound"); TermCompound = MkAtomTerm(AtomCompound); AtomConsistencyError = Yap_LookupAtom("consistency_error"); TermConsistencyError = MkAtomTerm(AtomConsistencyError); AtomConsult = Yap_LookupAtom("consult"); TermConsult = MkAtomTerm(AtomConsult); AtomConsultOnBoot = Yap_FullLookupAtom("$consult_on_boot"); TermConsultOnBoot = MkAtomTerm(AtomConsultOnBoot); AtomContext = Yap_LookupAtom("context"); TermContext = MkAtomTerm(AtomContext); AtomCputime = Yap_LookupAtom("cputime"); TermCputime = MkAtomTerm(AtomCputime); AtomCreate = Yap_LookupAtom("create"); TermCreate = MkAtomTerm(AtomCreate); AtomCreep = Yap_FullLookupAtom("$creep"); TermCreep = MkAtomTerm(AtomCreep); AtomCryptAtoms = Yap_LookupAtom("crypt_atoms"); TermCryptAtoms = MkAtomTerm(AtomCryptAtoms); AtomCurly = Yap_LookupAtom("{}"); TermCurly = MkAtomTerm(AtomCurly); AtomCsult = Yap_FullLookupAtom("$csult"); TermCsult = MkAtomTerm(AtomCsult); AtomCurrentModule = Yap_FullLookupAtom("$current_module"); TermCurrentModule = MkAtomTerm(AtomCurrentModule); AtomCut = Yap_LookupAtom("!"); TermCut = MkAtomTerm(AtomCut); AtomCutBy = Yap_FullLookupAtom("$cut_by"); TermCutBy = MkAtomTerm(AtomCutBy); AtomDAbort = Yap_FullLookupAtom("$abort"); TermDAbort = MkAtomTerm(AtomDAbort); AtomDBLoad = Yap_FullLookupAtom("$db_load"); TermDBLoad = MkAtomTerm(AtomDBLoad); AtomDBREF = Yap_LookupAtom("DBRef"); TermDBREF = MkAtomTerm(AtomDBREF); AtomDBReference = Yap_LookupAtom("db_reference"); TermDBReference = MkAtomTerm(AtomDBReference); AtomDBTerm = Yap_LookupAtom("db_term"); TermDBTerm = MkAtomTerm(AtomDBTerm); AtomDBref = Yap_FullLookupAtom("$dbref"); TermDBref = MkAtomTerm(AtomDBref); AtomDInteger = Yap_FullLookupAtom("$integer"); TermDInteger = MkAtomTerm(AtomDInteger); AtomDebugMeta = Yap_FullLookupAtom("$debug_meta"); TermDebugMeta = MkAtomTerm(AtomDebugMeta); AtomDebuggerInput = Yap_LookupAtom("debugger_input"); TermDebuggerInput = MkAtomTerm(AtomDebuggerInput); AtomDec10 = Yap_LookupAtom("dec10"); TermDec10 = MkAtomTerm(AtomDec10); AtomDefault = Yap_LookupAtom("default"); TermDefault = MkAtomTerm(AtomDefault); AtomDevNull = Yap_LookupAtom("/dev/null"); TermDevNull = MkAtomTerm(AtomDevNull); AtomDiff = Yap_LookupAtom("\\="); TermDiff = MkAtomTerm(AtomDiff); AtomDirectory = Yap_LookupAtom("disrectorys"); TermDirectory = MkAtomTerm(AtomDirectory); AtomDiscontiguous = Yap_LookupAtom("discontiguous"); TermDiscontiguous = MkAtomTerm(AtomDiscontiguous); AtomDiscontiguousWarnings = Yap_LookupAtom("discontiguous_warnings"); TermDiscontiguousWarnings = MkAtomTerm(AtomDiscontiguousWarnings); AtomDollar = Yap_FullLookupAtom("$"); TermDollar = MkAtomTerm(AtomDollar); AtomDoLogUpdClause = Yap_FullLookupAtom("$do_log_upd_clause"); TermDoLogUpdClause = MkAtomTerm(AtomDoLogUpdClause); AtomDoLogUpdClause0 = Yap_FullLookupAtom("$do_log_upd_clause0"); TermDoLogUpdClause0 = MkAtomTerm(AtomDoLogUpdClause0); AtomDoLogUpdClauseErase = Yap_FullLookupAtom("$do_log_upd_clause_erase"); TermDoLogUpdClauseErase = MkAtomTerm(AtomDoLogUpdClauseErase); AtomDollarU = Yap_FullLookupAtom("$u"); TermDollarU = MkAtomTerm(AtomDollarU); AtomDollarUndef = Yap_FullLookupAtom("$undef"); TermDollarUndef = MkAtomTerm(AtomDollarUndef); AtomDomainError = Yap_LookupAtom("domain_error"); TermDomainError = MkAtomTerm(AtomDomainError); AtomDoStaticClause = Yap_FullLookupAtom("$do_static_clause"); TermDoStaticClause = MkAtomTerm(AtomDoStaticClause); AtomDots = Yap_LookupAtom("dots"); TermDots = MkAtomTerm(AtomDots); AtomDOUBLE = Yap_FullLookupAtom("Double"); TermDOUBLE = MkAtomTerm(AtomDOUBLE); AtomDoubleSlash = Yap_FullLookupAtom("//"); TermDoubleSlash = MkAtomTerm(AtomDoubleSlash); AtomE = Yap_LookupAtom("e"); TermE = MkAtomTerm(AtomE); AtomEOFBeforeEOT = Yap_LookupAtom("end_of_file_found_before_end_of_term"); TermEOFBeforeEOT = MkAtomTerm(AtomEOFBeforeEOT); AtomEQ = Yap_LookupAtom("="); TermEQ = MkAtomTerm(AtomEQ); AtomEmptyAtom = Yap_LookupAtom(""); TermEmptyAtom = MkAtomTerm(AtomEmptyAtom); AtomEncoding = Yap_LookupAtom("encoding"); TermEncoding = MkAtomTerm(AtomEncoding); AtomEndOfStream = Yap_LookupAtom("$end_of_stream"); TermEndOfStream = MkAtomTerm(AtomEndOfStream); AtomEof = Yap_LookupAtom("end_of_file"); TermEof = MkAtomTerm(AtomEof); AtomEOfCode = Yap_LookupAtom("eof_code"); TermEOfCode = MkAtomTerm(AtomEOfCode); AtomEq = Yap_LookupAtom("="); TermEq = MkAtomTerm(AtomEq); AtomError = Yap_LookupAtom("error"); TermError = MkAtomTerm(AtomError); AtomException = Yap_LookupAtom("exception"); TermException = MkAtomTerm(AtomException); AtomExtensions = Yap_LookupAtom("extensions"); TermExtensions = MkAtomTerm(AtomExtensions); AtomEvaluable = Yap_LookupAtom("evaluable"); TermEvaluable = MkAtomTerm(AtomEvaluable); AtomEvaluationError = Yap_LookupAtom("evaluation_error"); TermEvaluationError = MkAtomTerm(AtomEvaluationError); AtomExecutable = Yap_LookupAtom("executable"); TermExecutable = MkAtomTerm(AtomExecutable); AtomExecute = Yap_LookupAtom("execute"); TermExecute = MkAtomTerm(AtomExecute); AtomExecAnswers = Yap_LookupAtom("exec_answers"); TermExecAnswers = MkAtomTerm(AtomExecAnswers); AtomExecuteInMod = Yap_FullLookupAtom("$execute_in_mod"); TermExecuteInMod = MkAtomTerm(AtomExecuteInMod); AtomExecuteWithin = Yap_FullLookupAtom("$execute_within"); TermExecuteWithin = MkAtomTerm(AtomExecuteWithin); AtomExecuteWoMod = Yap_FullLookupAtom("$execute_wo_mod"); TermExecuteWoMod = MkAtomTerm(AtomExecuteWoMod); AtomExist = Yap_LookupAtom("exist"); TermExist = MkAtomTerm(AtomExist); AtomExists = Yap_LookupAtom("exists"); TermExists = MkAtomTerm(AtomExists); AtomExit = Yap_LookupAtom("exit"); TermExit = MkAtomTerm(AtomExit); AtomExistenceError = Yap_LookupAtom("existence_error"); TermExistenceError = MkAtomTerm(AtomExistenceError); AtomExoClause = Yap_FullLookupAtom("$exo_clause"); TermExoClause = MkAtomTerm(AtomExoClause); AtomExpectedNumber = Yap_LookupAtom("expected_number_syntax"); TermExpectedNumber = MkAtomTerm(AtomExpectedNumber); AtomExpand = Yap_LookupAtom("expand"); TermExpand = MkAtomTerm(AtomExpand); AtomExtendFileSearchPath = Yap_FullLookupAtom("$extend_file_search_path"); TermExtendFileSearchPath = MkAtomTerm(AtomExtendFileSearchPath); AtomExtendsions = Yap_LookupAtom("extensionh"); TermExtendsions = MkAtomTerm(AtomExtendsions); AtomFB = Yap_LookupAtom("fb"); TermFB = MkAtomTerm(AtomFB); AtomFail = Yap_LookupAtom("fail"); TermFail = MkAtomTerm(AtomFail); AtomFalse = Yap_LookupAtom("false"); TermFalse = MkAtomTerm(AtomFalse); AtomFast = Yap_FullLookupAtom("$fast"); TermFast = MkAtomTerm(AtomFast); AtomFastFail = Yap_LookupAtom("fast_fail"); TermFastFail = MkAtomTerm(AtomFastFail); AtomFileErrors = Yap_LookupAtom("file_errors"); TermFileErrors = MkAtomTerm(AtomFileErrors); AtomFileerrors = Yap_LookupAtom("fileerrors"); TermFileerrors = MkAtomTerm(AtomFileerrors); AtomFileType = Yap_LookupAtom("file_type"); TermFileType = MkAtomTerm(AtomFileType); AtomFirst = Yap_LookupAtom("first"); TermFirst = MkAtomTerm(AtomFirst); AtomFloat = Yap_LookupAtom("float"); TermFloat = MkAtomTerm(AtomFloat); AtomFloatFormat = Yap_LookupAtom("\%.15g"); TermFloatFormat = MkAtomTerm(AtomFloatFormat); AtomFloatOverflow = Yap_LookupAtom("float_overflow"); TermFloatOverflow = MkAtomTerm(AtomFloatOverflow); AtomFloatUnderflow = Yap_LookupAtom("float_underflow"); TermFloatUnderflow = MkAtomTerm(AtomFloatUnderflow); AtomFormat = Yap_LookupAtom("format"); TermFormat = MkAtomTerm(AtomFormat); AtomFormatAt = Yap_FullLookupAtom("$format@"); TermFormatAt = MkAtomTerm(AtomFormatAt); AtomFull = Yap_LookupAtom("full"); TermFull = MkAtomTerm(AtomFull); AtomFunctor = Yap_LookupAtom("functor"); TermFunctor = MkAtomTerm(AtomFunctor); AtomGT = Yap_LookupAtom(">"); TermGT = MkAtomTerm(AtomGT); AtomGVar = Yap_LookupAtom("var"); TermGVar = MkAtomTerm(AtomGVar); AtomGc = Yap_FullLookupAtom("$gc"); TermGc = MkAtomTerm(AtomGc); AtomGcMargin = Yap_FullLookupAtom("$gc_margin"); TermGcMargin = MkAtomTerm(AtomGcMargin); AtomGcTrace = Yap_FullLookupAtom("$gc_trace"); TermGcTrace = MkAtomTerm(AtomGcTrace); AtomGcVerbose = Yap_FullLookupAtom("$gc_verbose"); TermGcVerbose = MkAtomTerm(AtomGcVerbose); AtomGcVeryVerbose = Yap_FullLookupAtom("$gc_very_verbose"); TermGcVeryVerbose = MkAtomTerm(AtomGcVeryVerbose); AtomGeneratePredInfo = Yap_FullLookupAtom("$generate_pred_info"); TermGeneratePredInfo = MkAtomTerm(AtomGeneratePredInfo); AtomGetwork = Yap_FullLookupAtom("$getwork"); TermGetwork = MkAtomTerm(AtomGetwork); AtomGetworkSeq = Yap_FullLookupAtom("$getwork_seq"); TermGetworkSeq = MkAtomTerm(AtomGetworkSeq); AtomGlob = Yap_LookupAtom("glob"); TermGlob = MkAtomTerm(AtomGlob); AtomGlobal = Yap_LookupAtom("global"); TermGlobal = MkAtomTerm(AtomGlobal); AtomGlobalSp = Yap_LookupAtom("global_sp"); TermGlobalSp = MkAtomTerm(AtomGlobalSp); AtomGlobalTrie = Yap_LookupAtom("global_trie"); TermGlobalTrie = MkAtomTerm(AtomGlobalTrie); AtomGoalExpansion = Yap_LookupAtom("goal_expansion"); TermGoalExpansion = MkAtomTerm(AtomGoalExpansion); AtomHat = Yap_LookupAtom("^"); TermHat = MkAtomTerm(AtomHat); AtomHERE = Yap_LookupAtom("\n <====HERE====> \n"); TermHERE = MkAtomTerm(AtomHERE); AtomHandleThrow = Yap_FullLookupAtom("$handle_throw"); TermHandleThrow = MkAtomTerm(AtomHandleThrow); AtomHeap = Yap_LookupAtom("heap"); TermHeap = MkAtomTerm(AtomHeap); AtomHeapUsed = Yap_LookupAtom("heapused"); TermHeapUsed = MkAtomTerm(AtomHeapUsed); AtomHugeInt = Yap_LookupAtom("huge_int"); TermHugeInt = MkAtomTerm(AtomHugeInt); AtomIDB = Yap_LookupAtom("idb"); TermIDB = MkAtomTerm(AtomIDB); AtomIOMode = Yap_LookupAtom("io_mode"); TermIOMode = MkAtomTerm(AtomIOMode); AtomI = Yap_LookupAtom("i"); TermI = MkAtomTerm(AtomI); AtomId = Yap_LookupAtom("id"); TermId = MkAtomTerm(AtomId); AtomIgnore = Yap_LookupAtom("ignore"); TermIgnore = MkAtomTerm(AtomIgnore); AtomInf = Yap_LookupAtom("inf"); TermInf = MkAtomTerm(AtomInf); AtomInfinity = Yap_LookupAtom("infinity"); TermInfinity = MkAtomTerm(AtomInfinity); AtomInitGoal = Yap_FullLookupAtom("$init_goal"); TermInitGoal = MkAtomTerm(AtomInitGoal); AtomInitProlog = Yap_FullLookupAtom("$init_prolog"); TermInitProlog = MkAtomTerm(AtomInitProlog); AtomInStackExpansion = Yap_LookupAtom("in stack expansion"); TermInStackExpansion = MkAtomTerm(AtomInStackExpansion); AtomInput = Yap_LookupAtom("input"); TermInput = MkAtomTerm(AtomInput); AtomInstantiationError = Yap_LookupAtom("instantiation_error"); TermInstantiationError = MkAtomTerm(AtomInstantiationError); AtomInt = Yap_LookupAtom("int"); TermInt = MkAtomTerm(AtomInt); AtomIntOverflow = Yap_LookupAtom("int_overflow"); TermIntOverflow = MkAtomTerm(AtomIntOverflow); AtomInteger = Yap_LookupAtom("integer"); TermInteger = MkAtomTerm(AtomInteger); AtomInternalCompilerError = Yap_LookupAtom("internal_compiler_error"); TermInternalCompilerError = MkAtomTerm(AtomInternalCompilerError); AtomIs = Yap_LookupAtom("is"); TermIs = MkAtomTerm(AtomIs); AtomJ = Yap_LookupAtom("j"); TermJ = MkAtomTerm(AtomJ); AtomKey = Yap_LookupAtom("key"); TermKey = MkAtomTerm(AtomKey); AtomLDLibraryPath = Yap_LookupAtom("LD_LIBRARY_PATH"); TermLDLibraryPath = MkAtomTerm(AtomLDLibraryPath); AtomLONGINT = Yap_LookupAtom("LongInt"); TermLONGINT = MkAtomTerm(AtomLONGINT); AtomLOOP = Yap_LookupAtom("_LOOP_"); TermLOOP = MkAtomTerm(AtomLOOP); AtomLoopStream = Yap_LookupAtom("loop_stream"); TermLoopStream = MkAtomTerm(AtomLoopStream); AtomLT = Yap_LookupAtom("<"); TermLT = MkAtomTerm(AtomLT); AtomLastExecuteWithin = Yap_FullLookupAtom("$last_execute_within"); TermLastExecuteWithin = MkAtomTerm(AtomLastExecuteWithin); AtomLeash = Yap_FullLookupAtom("$leash"); TermLeash = MkAtomTerm(AtomLeash); AtomLeast = Yap_LookupAtom("least"); TermLeast = MkAtomTerm(AtomLeast); AtomLength = Yap_FullLookupAtom("length"); TermLength = MkAtomTerm(AtomLength); AtomList = Yap_LookupAtom("list"); TermList = MkAtomTerm(AtomList); AtomLine = Yap_LookupAtom("line"); TermLine = MkAtomTerm(AtomLine); AtomLive = Yap_FullLookupAtom("$live"); TermLive = MkAtomTerm(AtomLive); AtomLoadAnswers = Yap_LookupAtom("load_answers"); TermLoadAnswers = MkAtomTerm(AtomLoadAnswers); AtomLocal = Yap_LookupAtom("local"); TermLocal = MkAtomTerm(AtomLocal); AtomLocalSp = Yap_LookupAtom("local_sp"); TermLocalSp = MkAtomTerm(AtomLocalSp); AtomLocalTrie = Yap_LookupAtom("local_trie"); TermLocalTrie = MkAtomTerm(AtomLocalTrie); AtomMax = Yap_LookupAtom("max"); TermMax = MkAtomTerm(AtomMax); AtomMaximum = Yap_LookupAtom("maximum"); TermMaximum = MkAtomTerm(AtomMaximum); AtomMaxArity = Yap_LookupAtom("max_arity"); TermMaxArity = MkAtomTerm(AtomMaxArity); AtomMaxFiles = Yap_LookupAtom("max_files"); TermMaxFiles = MkAtomTerm(AtomMaxFiles); AtomMegaClause = Yap_FullLookupAtom("$mega_clause"); TermMegaClause = MkAtomTerm(AtomMegaClause); AtomMetaCall = Yap_FullLookupAtom("$call"); TermMetaCall = MkAtomTerm(AtomMetaCall); AtomMfClause = Yap_FullLookupAtom("$mf_clause"); TermMfClause = MkAtomTerm(AtomMfClause); AtomMin = Yap_LookupAtom("min"); TermMin = MkAtomTerm(AtomMin); AtomMinimum = Yap_LookupAtom("minimum"); TermMinimum = MkAtomTerm(AtomMinimum); AtomMinus = Yap_LookupAtom("-"); TermMinus = MkAtomTerm(AtomMinus); AtomModify = Yap_LookupAtom("modify"); TermModify = MkAtomTerm(AtomModify); AtomModule = Yap_LookupAtom("module"); TermModule = MkAtomTerm(AtomModule); AtomMost = Yap_LookupAtom("most"); TermMost = MkAtomTerm(AtomMost); AtomMulti = Yap_LookupAtom("multi"); TermMulti = MkAtomTerm(AtomMulti); AtomMultiFile = Yap_FullLookupAtom("$mf"); TermMultiFile = MkAtomTerm(AtomMultiFile); AtomMultiple = Yap_FullLookupAtom("multiple"); TermMultiple = MkAtomTerm(AtomMultiple); AtomMutable = Yap_LookupAtom("mutable"); TermMutable = MkAtomTerm(AtomMutable); AtomMutableVariable = Yap_FullLookupAtom("$mutable_variable"); TermMutableVariable = MkAtomTerm(AtomMutableVariable); AtomMutex = Yap_LookupAtom("mutex"); TermMutex = MkAtomTerm(AtomMutex); AtomMyddasDB = Yap_FullLookupAtom("$myddas_db"); TermMyddasDB = MkAtomTerm(AtomMyddasDB); AtomMyddasGoal = Yap_FullLookupAtom("$myddas_goal"); TermMyddasGoal = MkAtomTerm(AtomMyddasGoal); AtomMyddasHost = Yap_FullLookupAtom("$myddas_host"); TermMyddasHost = MkAtomTerm(AtomMyddasHost); AtomMyddasPass = Yap_FullLookupAtom("$myddas_pass"); TermMyddasPass = MkAtomTerm(AtomMyddasPass); AtomMyddasUser = Yap_FullLookupAtom("$myddas_user"); TermMyddasUser = MkAtomTerm(AtomMyddasUser); AtomMyddasVersionName = Yap_FullLookupAtom("$myddas_version_name"); TermMyddasVersionName = MkAtomTerm(AtomMyddasVersionName); AtomNan = Yap_LookupAtom("nan"); TermNan = MkAtomTerm(AtomNan); AtomNb = Yap_LookupAtom("nb"); TermNb = MkAtomTerm(AtomNb); AtomNbTerm = Yap_LookupAtom("nb_term"); TermNbTerm = MkAtomTerm(AtomNbTerm); AtomNew = Yap_LookupAtom("new"); TermNew = MkAtomTerm(AtomNew); AtomNewLine = Yap_LookupAtom("nl"); TermNewLine = MkAtomTerm(AtomNewLine); AtomNl = Yap_LookupAtom("nl"); TermNl = MkAtomTerm(AtomNl); AtomNoEffect = Yap_LookupAtom("no_effect"); TermNoEffect = MkAtomTerm(AtomNoEffect); AtomNoMemory = Yap_LookupAtom("no_memory"); TermNoMemory = MkAtomTerm(AtomNoMemory); AtomNone = Yap_LookupAtom("none"); TermNone = MkAtomTerm(AtomNone); AtomNonEmptyList = Yap_LookupAtom("non_empty_list"); TermNonEmptyList = MkAtomTerm(AtomNonEmptyList); AtomNot = Yap_LookupAtom("\\+"); TermNot = MkAtomTerm(AtomNot); AtomNotImplemented = Yap_LookupAtom("not_implemented"); TermNotImplemented = MkAtomTerm(AtomNotImplemented); AtomNotLessThanZero = Yap_LookupAtom("not_less_than_zero"); TermNotLessThanZero = MkAtomTerm(AtomNotLessThanZero); AtomNotNewline = Yap_LookupAtom("not_newline"); TermNotNewline = MkAtomTerm(AtomNotNewline); AtomNotZero = Yap_LookupAtom("not_zero"); TermNotZero = MkAtomTerm(AtomNotZero); AtomNumber = Yap_LookupAtom("number"); TermNumber = MkAtomTerm(AtomNumber); AtomObj = Yap_LookupAtom("o__bj__"); TermObj = MkAtomTerm(AtomObj); AtomOff = Yap_LookupAtom("off"); TermOff = MkAtomTerm(AtomOff); AtomOffline = Yap_LookupAtom("offline"); TermOffline = MkAtomTerm(AtomOffline); AtomOn = Yap_LookupAtom("on"); TermOn = MkAtomTerm(AtomOn); AtomOnline = Yap_LookupAtom("online"); TermOnline = MkAtomTerm(AtomOnline); AtomOpen = Yap_LookupAtom("open"); TermOpen = MkAtomTerm(AtomOpen); AtomOperatingSystemError = Yap_LookupAtom("operating_SYSTEM_ERROR_INTERNAL"); TermOperatingSystemError = MkAtomTerm(AtomOperatingSystemError); AtomOperatingSystemSupport = Yap_LookupAtom("operating_system_support"); TermOperatingSystemSupport = MkAtomTerm(AtomOperatingSystemSupport); AtomOperator = Yap_LookupAtom("operator"); TermOperator = MkAtomTerm(AtomOperator); AtomOperatorPriority = Yap_LookupAtom("operator_priority"); TermOperatorPriority = MkAtomTerm(AtomOperatorPriority); AtomOperatorSpecifier = Yap_LookupAtom("operator_specifier"); TermOperatorSpecifier = MkAtomTerm(AtomOperatorSpecifier); AtomOpt = Yap_LookupAtom("opt"); TermOpt = MkAtomTerm(AtomOpt); AtomOtherwise = Yap_LookupAtom("otherwise"); TermOtherwise = MkAtomTerm(AtomOtherwise); AtomOutOfAttvarsError = Yap_LookupAtom("out_of_attvars_error"); TermOutOfAttvarsError = MkAtomTerm(AtomOutOfAttvarsError); AtomOutOfAuxspaceError = Yap_LookupAtom("out_of_auxspace_error"); TermOutOfAuxspaceError = MkAtomTerm(AtomOutOfAuxspaceError); AtomOutOfHeapError = Yap_LookupAtom("out_of_heap_error"); TermOutOfHeapError = MkAtomTerm(AtomOutOfHeapError); AtomOutOfRange = Yap_LookupAtom("out_of_range"); TermOutOfRange = MkAtomTerm(AtomOutOfRange); AtomOutOfStackError = Yap_LookupAtom("out_of_stack_error"); TermOutOfStackError = MkAtomTerm(AtomOutOfStackError); AtomOutOfTrailError = Yap_LookupAtom("out_of_trail_error"); TermOutOfTrailError = MkAtomTerm(AtomOutOfTrailError); AtomOutput = Yap_LookupAtom("output"); TermOutput = MkAtomTerm(AtomOutput); AtomParameter = Yap_LookupAtom("parameter"); TermParameter = MkAtomTerm(AtomParameter); AtomPrologCommonsDir = Yap_LookupAtom("prolog_commons_directory"); TermPrologCommonsDir = MkAtomTerm(AtomPrologCommonsDir); AtomPast = Yap_LookupAtom("past"); TermPast = MkAtomTerm(AtomPast); AtomPastEndOfStream = Yap_LookupAtom("past_end_of_stream"); TermPastEndOfStream = MkAtomTerm(AtomPastEndOfStream); AtomPermissionError = Yap_LookupAtom("permission_error"); TermPermissionError = MkAtomTerm(AtomPermissionError); AtomPi = Yap_LookupAtom("pi"); TermPi = MkAtomTerm(AtomPi); AtomPipe = Yap_LookupAtom("pipe"); TermPipe = MkAtomTerm(AtomPipe); AtomPlus = Yap_LookupAtom("+"); TermPlus = MkAtomTerm(AtomPlus); AtomPointer = Yap_LookupAtom("pointer"); TermPointer = MkAtomTerm(AtomPointer); AtomPortray = Yap_FullLookupAtom("portray"); TermPortray = MkAtomTerm(AtomPortray); AtomPredicateIndicator = Yap_LookupAtom("predicate_indicator"); TermPredicateIndicator = MkAtomTerm(AtomPredicateIndicator); AtomPrimitive = Yap_LookupAtom("primitive"); TermPrimitive = MkAtomTerm(AtomPrimitive); AtomPrintMessage = Yap_LookupAtom("print_message"); TermPrintMessage = MkAtomTerm(AtomPrintMessage); AtomPrivateProcedure = Yap_LookupAtom("private_procedure"); TermPrivateProcedure = MkAtomTerm(AtomPrivateProcedure); AtomProcedure = Yap_LookupAtom("procedure"); TermProcedure = MkAtomTerm(AtomProcedure); AtomProfile = Yap_FullLookupAtom("$profile"); TermProfile = MkAtomTerm(AtomProfile); AtomProlog = Yap_LookupAtom("prolog"); TermProlog = MkAtomTerm(AtomProlog); AtomProtectStack = Yap_FullLookupAtom("$protect_stack"); TermProtectStack = MkAtomTerm(AtomProtectStack); AtomQly = Yap_LookupAtom("qly"); TermQly = MkAtomTerm(AtomQly); AtomQuery = Yap_LookupAtom("?-"); TermQuery = MkAtomTerm(AtomQuery); AtomQueue = Yap_LookupAtom("queue"); TermQueue = MkAtomTerm(AtomQueue); AtomQuiet = Yap_LookupAtom("quiet"); TermQuiet = MkAtomTerm(AtomQuiet); AtomRadix = Yap_LookupAtom("radix"); TermRadix = MkAtomTerm(AtomRadix); AtomRandom = Yap_LookupAtom("random"); TermRandom = MkAtomTerm(AtomRandom); AtomRange = Yap_LookupAtom("range"); TermRange = MkAtomTerm(AtomRange); AtomRDiv = Yap_LookupAtom("rdiv"); TermRDiv = MkAtomTerm(AtomRDiv); AtomRead = Yap_LookupAtom("read"); TermRead = MkAtomTerm(AtomRead); AtomReadOnly = Yap_LookupAtom("read_only"); TermReadOnly = MkAtomTerm(AtomReadOnly); AtomReadWrite = Yap_LookupAtom("read_write"); TermReadWrite = MkAtomTerm(AtomReadWrite); AtomReadutil = Yap_LookupAtom("readutil"); TermReadutil = MkAtomTerm(AtomReadutil); AtomReconsult = Yap_LookupAtom("reconsult"); TermReconsult = MkAtomTerm(AtomReconsult); AtomRecordedP = Yap_FullLookupAtom("$recordep"); TermRecordedP = MkAtomTerm(AtomRecordedP); AtomRecordedWithKey = Yap_FullLookupAtom("$recorded_with_key"); TermRecordedWithKey = MkAtomTerm(AtomRecordedWithKey); AtomRedefineWarnings = Yap_LookupAtom("redefine_warnings"); TermRedefineWarnings = MkAtomTerm(AtomRedefineWarnings); AtomRedoFreeze = Yap_FullLookupAtom("$redo_freeze"); TermRedoFreeze = MkAtomTerm(AtomRedoFreeze); AtomRefoundVar = Yap_FullLookupAtom("$I_FOUND_THE_VARIABLE_AGAIN"); TermRefoundVar = MkAtomTerm(AtomRefoundVar); AtomRelativeTo = Yap_FullLookupAtom("relative_to"); TermRelativeTo = MkAtomTerm(AtomRelativeTo); AtomRepeat = Yap_LookupAtom("repeat"); TermRepeat = MkAtomTerm(AtomRepeat); AtomRepeatSpace = Yap_LookupAtom("repeat "); TermRepeatSpace = MkAtomTerm(AtomRepeatSpace); AtomReposition = Yap_LookupAtom("reposition"); TermReposition = MkAtomTerm(AtomReposition); AtomRepresentationError = Yap_LookupAtom("representation_error"); TermRepresentationError = MkAtomTerm(AtomRepresentationError); AtomReset = Yap_LookupAtom("reset"); TermReset = MkAtomTerm(AtomReset); AtomResize = Yap_LookupAtom("resize"); TermResize = MkAtomTerm(AtomResize); AtomResourceError = Yap_LookupAtom("resource_error"); TermResourceError = MkAtomTerm(AtomResourceError); AtomRestoreRegs = Yap_FullLookupAtom("$restore_regs"); TermRestoreRegs = MkAtomTerm(AtomRestoreRegs); AtomRetry = Yap_LookupAtom("retry"); TermRetry = MkAtomTerm(AtomRetry); AtomRetryCounter = Yap_LookupAtom("retry_counter"); TermRetryCounter = MkAtomTerm(AtomRetryCounter); AtomRTree = Yap_LookupAtom("rtree"); TermRTree = MkAtomTerm(AtomRTree); AtomSafe = Yap_FullLookupAtom("$safe"); TermSafe = MkAtomTerm(AtomSafe); AtomSafeCallCleanup = Yap_FullLookupAtom("$safe_call_cleanup"); TermSafeCallCleanup = MkAtomTerm(AtomSafeCallCleanup); AtomSame = Yap_LookupAtom("=="); TermSame = MkAtomTerm(AtomSame); AtomSemic = Yap_LookupAtom(";"); TermSemic = MkAtomTerm(AtomSemic); AtomShiftCountOverflow = Yap_LookupAtom("shift_count_overflow"); TermShiftCountOverflow = MkAtomTerm(AtomShiftCountOverflow); AtomSigAlarm = Yap_LookupAtom("sig_alarm"); TermSigAlarm = MkAtomTerm(AtomSigAlarm); AtomSigBreak = Yap_LookupAtom("sig_break"); TermSigBreak = MkAtomTerm(AtomSigBreak); AtomSigCreep = Yap_LookupAtom("sig_creep"); TermSigCreep = MkAtomTerm(AtomSigCreep); AtomSigDebug = Yap_LookupAtom("sig_debug"); TermSigDebug = MkAtomTerm(AtomSigDebug); AtomSigDelayCreep = Yap_LookupAtom("sig_delay_creep"); TermSigDelayCreep = MkAtomTerm(AtomSigDelayCreep); AtomSigFPE = Yap_LookupAtom("sig_fpe"); TermSigFPE = MkAtomTerm(AtomSigFPE); AtomSigHup = Yap_LookupAtom("sig_hup"); TermSigHup = MkAtomTerm(AtomSigHup); AtomSigInt = Yap_LookupAtom("sig_int"); TermSigInt = MkAtomTerm(AtomSigInt); AtomSigIti = Yap_LookupAtom("sig_iti"); TermSigIti = MkAtomTerm(AtomSigIti); AtomSigPending = Yap_FullLookupAtom("$sig_pending"); TermSigPending = MkAtomTerm(AtomSigPending); AtomSigPipe = Yap_LookupAtom("sig_pipe"); TermSigPipe = MkAtomTerm(AtomSigPipe); AtomSigStackDump = Yap_LookupAtom("sig_stack_dump"); TermSigStackDump = MkAtomTerm(AtomSigStackDump); AtomSigStatistics = Yap_LookupAtom("sig_statistics"); TermSigStatistics = MkAtomTerm(AtomSigStatistics); AtomSigTrace = Yap_LookupAtom("sig_trace"); TermSigTrace = MkAtomTerm(AtomSigTrace); AtomSigUsr1 = Yap_LookupAtom("sig_usr1"); TermSigUsr1 = MkAtomTerm(AtomSigUsr1); AtomSigUsr2 = Yap_LookupAtom("sig_usr2"); TermSigUsr2 = MkAtomTerm(AtomSigUsr2); AtomSigVTAlarm = Yap_LookupAtom("sig_vtalarm"); TermSigVTAlarm = MkAtomTerm(AtomSigVTAlarm); AtomSigWakeUp = Yap_LookupAtom("sig_wake_up"); TermSigWakeUp = MkAtomTerm(AtomSigWakeUp); AtomSilent = Yap_LookupAtom("Silent"); TermSilent = MkAtomTerm(AtomSilent); AtomSingle = Yap_LookupAtom("single"); TermSingle = MkAtomTerm(AtomSingle); AtomSingleVarWarnings = Yap_LookupAtom("single_var_warnings"); TermSingleVarWarnings = MkAtomTerm(AtomSingleVarWarnings); AtomSingleton = Yap_LookupAtom("singleton"); TermSingleton = MkAtomTerm(AtomSingleton); AtomSlash = Yap_LookupAtom("/"); TermSlash = MkAtomTerm(AtomSlash); AtomSocket = Yap_LookupAtom("socket"); TermSocket = MkAtomTerm(AtomSocket); AtomSolutions = Yap_LookupAtom("solutions"); TermSolutions = MkAtomTerm(AtomSolutions); AtomSource = Yap_LookupAtom("source"); TermSource = MkAtomTerm(AtomSource); AtomSourceSink = Yap_LookupAtom("source_sink"); TermSourceSink = MkAtomTerm(AtomSourceSink); AtomSpy = Yap_FullLookupAtom("$spy"); TermSpy = MkAtomTerm(AtomSpy); AtomStack = Yap_LookupAtom("stack"); TermStack = MkAtomTerm(AtomStack); AtomStackFree = Yap_LookupAtom("stackfree"); TermStackFree = MkAtomTerm(AtomStackFree); AtomStartupSavedState = Yap_FullLookupAtom("$startup_saved_state"); TermStartupSavedState = MkAtomTerm(AtomStartupSavedState); AtomStaticClause = Yap_FullLookupAtom("$static_clause"); TermStaticClause = MkAtomTerm(AtomStaticClause); AtomStaticProcedure = Yap_LookupAtom("static_procedure"); TermStaticProcedure = MkAtomTerm(AtomStaticProcedure); AtomStream = Yap_FullLookupAtom("$stream"); TermStream = MkAtomTerm(AtomStream); AtomSWIStream = Yap_FullLookupAtom(""); TermSWIStream = MkAtomTerm(AtomSWIStream); AtomVStream = Yap_LookupAtom("stream"); TermVStream = MkAtomTerm(AtomVStream); AtomStreams = Yap_LookupAtom("streams"); TermStreams = MkAtomTerm(AtomStreams); AtomStreamOrAlias = Yap_LookupAtom("stream_or_alias"); TermStreamOrAlias = MkAtomTerm(AtomStreamOrAlias); AtomStreamPos = Yap_FullLookupAtom("$stream_position"); TermStreamPos = MkAtomTerm(AtomStreamPos); AtomStreamPosition = Yap_LookupAtom("stream_position"); TermStreamPosition = MkAtomTerm(AtomStreamPosition); AtomString = Yap_LookupAtom("string"); TermString = MkAtomTerm(AtomString); AtomStyleCheck = Yap_LookupAtom("style_check"); TermStyleCheck = MkAtomTerm(AtomStyleCheck); AtomSTRING = Yap_FullLookupAtom("String"); TermSTRING = MkAtomTerm(AtomSTRING); AtomSwi = Yap_LookupAtom("swi"); TermSwi = MkAtomTerm(AtomSwi); AtomSymbolChar = Yap_LookupAtom("symbol_char"); TermSymbolChar = MkAtomTerm(AtomSymbolChar); AtomSyntaxError = Yap_LookupAtom("syntax_error"); TermSyntaxError = MkAtomTerm(AtomSyntaxError); AtomSyntaxErrors = Yap_LookupAtom("syntax_errors"); TermSyntaxErrors = MkAtomTerm(AtomSyntaxErrors); AtomSyntaxErrorHandler = Yap_LookupAtom("syntax_error_handler"); TermSyntaxErrorHandler = MkAtomTerm(AtomSyntaxErrorHandler); AtomSystem = Yap_LookupAtom("system"); TermSystem = MkAtomTerm(AtomSystem); AtomSystemError = Yap_LookupAtom("SYSTEM_ERROR_INTERNAL"); TermSystemError = MkAtomTerm(AtomSystemError); AtomSystemLibraryDir = Yap_LookupAtom("system_library_directory"); TermSystemLibraryDir = MkAtomTerm(AtomSystemLibraryDir); AtomT = Yap_LookupAtom("t"); TermT = MkAtomTerm(AtomT); AtomTerm = Yap_LookupAtom("term"); TermTerm = MkAtomTerm(AtomTerm); AtomTermExpansion = Yap_LookupAtom("term_expansion"); TermTermExpansion = MkAtomTerm(AtomTermExpansion); AtomTerms = Yap_LookupAtom("terms"); TermTerms = MkAtomTerm(AtomTerms); AtomText = Yap_LookupAtom("text"); TermText = MkAtomTerm(AtomText); AtomTextStream = Yap_LookupAtom("text_stream"); TermTextStream = MkAtomTerm(AtomTextStream); AtomThread = Yap_LookupAtom("thread"); TermThread = MkAtomTerm(AtomThread); AtomThreads = Yap_LookupAtom("threads"); TermThreads = MkAtomTerm(AtomThreads); AtomThrow = Yap_LookupAtom("throw"); TermThrow = MkAtomTerm(AtomThrow); AtomTimeOutSpec = Yap_LookupAtom("time_out_spec"); TermTimeOutSpec = MkAtomTerm(AtomTimeOutSpec); AtomTimeoutError = Yap_LookupAtom("timeout_error"); TermTimeoutError = MkAtomTerm(AtomTimeoutError); AtomTopLevelGoal = Yap_FullLookupAtom("$top_level_goal"); TermTopLevelGoal = MkAtomTerm(AtomTopLevelGoal); AtomTopThreadGoal = Yap_FullLookupAtom("$top_thread_goal"); TermTopThreadGoal = MkAtomTerm(AtomTopThreadGoal); AtomTraceMetaCall = Yap_FullLookupAtom("$trace_meta_call"); TermTraceMetaCall = MkAtomTerm(AtomTraceMetaCall); AtomTrail = Yap_LookupAtom("trail"); AtomTrue = Yap_LookupAtom("true"); TermTrue = MkAtomTerm(AtomTrue); AtomTty = Yap_LookupAtom("tty"); TermTty = MkAtomTerm(AtomTty); AtomTtys = Yap_LookupAtom("ttys"); TermTtys = MkAtomTerm(AtomTtys); AtomTuple = Yap_LookupAtom("tuple"); TermTuple = MkAtomTerm(AtomTuple); AtomTxt = Yap_LookupAtom("txt"); TermTxt = MkAtomTerm(AtomTxt); AtomTypeError = Yap_LookupAtom("type_error"); TermTypeError = MkAtomTerm(AtomTypeError); AtomUndefined = Yap_LookupAtom("undefined"); TermUndefined = MkAtomTerm(AtomUndefined); AtomUndefp = Yap_FullLookupAtom("$undefp"); TermUndefp = MkAtomTerm(AtomUndefp); AtomUndefp0 = Yap_FullLookupAtom("$undefp0"); TermUndefp0 = MkAtomTerm(AtomUndefp0); AtomUnderflow = Yap_LookupAtom("underflow"); TermUnderflow = MkAtomTerm(AtomUnderflow); AtomUnificationStack = Yap_LookupAtom("unification_stack"); TermUnificationStack = MkAtomTerm(AtomUnificationStack); AtomUnique = Yap_LookupAtom("unique"); TermUnique = MkAtomTerm(AtomUnique); AtomUnsignedByte = Yap_LookupAtom("unsigned_byte"); TermUnsignedByte = MkAtomTerm(AtomUnsignedByte); AtomUnsignedChar = Yap_LookupAtom("unsigned_char"); TermUnsignedChar = MkAtomTerm(AtomUnsignedChar); AtomUser = Yap_LookupAtom("user"); TermUser = MkAtomTerm(AtomUser); AtomUserErr = Yap_LookupAtom("user_error"); TermUserErr = MkAtomTerm(AtomUserErr); AtomUserIn = Yap_LookupAtom("user_input"); TermUserIn = MkAtomTerm(AtomUserIn); AtomUserOut = Yap_LookupAtom("user_output"); TermUserOut = MkAtomTerm(AtomUserOut); AtomDollarVar = Yap_LookupAtom("$VAR"); TermDollarVar = MkAtomTerm(AtomDollarVar); AtomVBar = Yap_LookupAtom("|"); TermVBar = MkAtomTerm(AtomVBar); AtomVarBranches = Yap_LookupAtom("var_branches"); TermVarBranches = MkAtomTerm(AtomVarBranches); AtomVariableNames = Yap_LookupAtom("variable_names"); TermVariableNames = MkAtomTerm(AtomVariableNames); AtomHiddenVar = Yap_FullLookupAtom("$V"); TermHiddenVar = MkAtomTerm(AtomHiddenVar); AtomVariable = Yap_LookupAtom("variable"); TermVariable = MkAtomTerm(AtomVariable); AtomVerbose = Yap_LookupAtom("verbose"); TermVerbose = MkAtomTerm(AtomVerbose); AtomVerboseFileSearch = Yap_LookupAtom("verbose_file_search"); TermVerboseFileSearch = MkAtomTerm(AtomVerboseFileSearch); AtomVersionNumber = Yap_FullLookupAtom("$version_name"); TermVersionNumber = MkAtomTerm(AtomVersionNumber); AtomVeryVerbose = Yap_LookupAtom("very_verbose"); TermVeryVerbose = MkAtomTerm(AtomVeryVerbose); AtomWakeUpGoal = Yap_FullLookupAtom("$wake_up_goal"); TermWakeUpGoal = MkAtomTerm(AtomWakeUpGoal); AtomWarning = Yap_LookupAtom("warning"); TermWarning = MkAtomTerm(AtomWarning); AtomWhen = Yap_FullLookupAtom("$when"); TermWhen = MkAtomTerm(AtomWhen); AtomWrite = Yap_LookupAtom("write"); TermWrite = MkAtomTerm(AtomWrite); AtomWriteTerm = Yap_LookupAtom("write_term"); TermWriteTerm = MkAtomTerm(AtomWriteTerm); AtomXml = Yap_LookupAtom("xml"); TermXml = MkAtomTerm(AtomXml); AtomYapHacks = Yap_LookupAtom("yap_hacks"); TermYapHacks = MkAtomTerm(AtomYapHacks); AtomZeroDivisor = Yap_LookupAtom("zero_divisor"); TermZeroDivisor = MkAtomTerm(AtomZeroDivisor); 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); FunctorDoubleArrow = Yap_MkFunctor(AtomDoubleArrow,2); FunctorAssert1 = Yap_MkFunctor(AtomAssert,1); FunctorAssert = Yap_MkFunctor(AtomAssert,2); FunctorAtFoundOne = Yap_MkFunctor(AtomFoundVar,2); FunctorAtom = Yap_MkFunctor(AtomAtom,1); FunctorAtt1 = Yap_MkFunctor(AtomAtt1,3); FunctorAttGoal = Yap_MkFunctor(AtomAttDo,2); FunctorBraces = Yap_MkFunctor(AtomBraces,1); FunctorCall = Yap_MkFunctor(AtomCall,1); FunctorCatch = Yap_MkFunctor(AtomCatch,3); FunctorChangeModule = Yap_MkFunctor(AtomChangeModule,1); FunctorChars = Yap_MkFunctor(AtomChars,2); FunctorChars1 = Yap_MkFunctor(AtomChars,1); FunctorCleanCall = Yap_MkFunctor(AtomCleanCall,2); FunctorClist = Yap_MkFunctor(AtomWhen,4); FunctorCodes = Yap_MkFunctor(AtomCodes,2); FunctorCodes1 = Yap_MkFunctor(AtomCodes,1); FunctorColon = Yap_MkFunctor(AtomColon,2); FunctorComma = Yap_MkFunctor(AtomComma,2); FunctorCommentHook = Yap_MkFunctor(AtomCommentHook,3); FunctorContext2 = Yap_MkFunctor(AtomContext,2); FunctorConsistencyError = Yap_MkFunctor(AtomConsistencyError,1); FunctorCreep = Yap_MkFunctor(AtomCreep,1); FunctorCsult = Yap_MkFunctor(AtomCsult,2); FunctorCurrentModule = Yap_MkFunctor(AtomCurrentModule,1); FunctorCutBy = Yap_MkFunctor(AtomCutBy,1); FunctorDBREF = Yap_MkFunctor(AtomDBREF,1); FunctorDiff = Yap_MkFunctor(AtomDiff,2); FunctorDoLogUpdClause = Yap_MkFunctor(AtomDoLogUpdClause,6); FunctorDoLogUpdClause0 = Yap_MkFunctor(AtomDoLogUpdClause0,6); FunctorDoLogUpdClauseErase = Yap_MkFunctor(AtomDoLogUpdClauseErase,6); FunctorDoStaticClause = Yap_MkFunctor(AtomDoStaticClause,5); FunctorDollar = Yap_MkFunctor(AtomDollar,1); FunctorDollarVar = Yap_MkFunctor(AtomDollarVar,1); FunctorDomainError = Yap_MkFunctor(AtomDomainError,2); FunctorDot = Yap_MkFunctor(AtomDot,2); 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); FunctorDoubleSlash = Yap_MkFunctor(AtomDoubleSlash,2); FunctorEmptySquareBrackets = Yap_MkFunctor(AtomEmptySquareBrackets,2); FunctorEmptyCurlyBrackets = Yap_MkFunctor(AtomEmptyCurlyBrackets,2); FunctorEq = Yap_MkFunctor(AtomEq,2); FunctorError = Yap_MkFunctor(AtomError,2); FunctorEvaluationError = Yap_MkFunctor(AtomEvaluationError,1); FunctorException = Yap_MkFunctor(AtomException,1); FunctorExecute2InMod = Yap_MkFunctor(AtomExecuteWoMod,2); FunctorExecuteInMod = Yap_MkFunctor(AtomExecuteInMod,2); FunctorExecuteWithin = Yap_MkFunctor(AtomExecuteWithin,1); FunctorExistenceError = Yap_MkFunctor(AtomExistenceError,2); FunctorExoClause = Yap_MkFunctor(AtomExoClause,2); 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); FunctorGFormatAt = Yap_MkFunctor(AtomFormatAt,2); 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); FunctorGoalExpansion2 = Yap_MkFunctor(AtomGoalExpansion,2); FunctorGoalExpansion = Yap_MkFunctor(AtomGoalExpansion,3); FunctorHandleThrow = Yap_MkFunctor(AtomHandleThrow,3); FunctorHat = Yap_MkFunctor(AtomHat,2); FunctorI = Yap_MkFunctor(AtomI,2); FunctorId = Yap_MkFunctor(AtomId,1); FunctorIs = Yap_MkFunctor(AtomIs,2); FunctorJ = Yap_MkFunctor(AtomJ,2); FunctorLastExecuteWithin = Yap_MkFunctor(AtomLastExecuteWithin,1); FunctorList = Yap_MkFunctor(AtomDot,2); FunctorLOOP = Yap_MkFunctor(AtomLOOP,1); FunctorMegaClause = Yap_MkFunctor(AtomMegaClause,2); FunctorMetaCall = Yap_MkFunctor(AtomMetaCall,4); FunctorMinus = Yap_MkFunctor(AtomMinus,2); FunctorModule = Yap_MkFunctor(AtomColon,2); FunctorMultiFileClause = Yap_MkFunctor(AtomMfClause,5); FunctorMutable = Yap_MkFunctor(AtomMutableVariable,(sizeof(timed_var)/sizeof(CELL))); FunctorMutex = Yap_MkFunctor(AtomMutex,2); FunctorNotImplemented = Yap_MkFunctor(AtomNotImplemented,2); FunctorNBQueue = Yap_MkFunctor(AtomQueue,4); FunctorNot = Yap_MkFunctor(AtomNot,1); FunctorObj = Yap_MkFunctor(AtomObj,1); FunctorOr = Yap_MkFunctor(AtomSemic,2); FunctorPermissionError = Yap_MkFunctor(AtomPermissionError,3); FunctorPlus = Yap_MkFunctor(AtomPlus,2); FunctorPortray = Yap_MkFunctor(AtomPortray,1); FunctorPrintMessage = Yap_MkFunctor(AtomPrintMessage,2); FunctorProcedure = Yap_MkFunctor(AtomProcedure,5); FunctorPrologConstraint = Yap_MkFunctor(AtomProlog,2); FunctorProtectStack = Yap_MkFunctor(AtomProtectStack,4); FunctorQuery = Yap_MkFunctor(AtomQuery,1); FunctorRecordedWithKey = Yap_MkFunctor(AtomRecordedWithKey,6); FunctorRDiv = Yap_MkFunctor(AtomRDiv,2); FunctorRedoFreeze = Yap_MkFunctor(AtomRedoFreeze,3); FunctorRepresentationError = Yap_MkFunctor(AtomRepresentationError,1); FunctorResourceError = Yap_MkFunctor(AtomResourceError,1); FunctorRestoreRegs = Yap_MkFunctor(AtomRestoreRegs,2); FunctorRestoreRegs1 = Yap_MkFunctor(AtomRestoreRegs,1); FunctorSafe = Yap_MkFunctor(AtomSafe,1); FunctorSafeCallCleanup = Yap_MkFunctor(AtomSafeCallCleanup,4); FunctorSame = Yap_MkFunctor(AtomSame,2); FunctorSlash = Yap_MkFunctor(AtomSlash,2); FunctorStaticClause = Yap_MkFunctor(AtomStaticClause,2); FunctorStream = Yap_MkFunctor(AtomStream,1); FunctorStreamEOS = Yap_MkFunctor(AtomEndOfStream,1); FunctorStreamPos = Yap_MkFunctor(AtomStreamPos,4); FunctorString1 = Yap_MkFunctor(AtomString,1); FunctorStyleCheck = Yap_MkFunctor(AtomStyleCheck,4); FunctorSyntaxError = Yap_MkFunctor(AtomSyntaxError,4); FunctorShortSyntaxError = Yap_MkFunctor(AtomSyntaxError,1); FunctorTermExpansion = Yap_MkFunctor(AtomTermExpansion,2); FunctorThreadRun = Yap_MkFunctor(AtomTopThreadGoal,2); FunctorThrow = Yap_MkFunctor(AtomThrow,1); FunctorTimeoutError = Yap_MkFunctor(AtomTimeoutError,2); FunctorTraceMetaCall = Yap_MkFunctor(AtomTraceMetaCall,3); FunctorTypeError = Yap_MkFunctor(AtomTypeError,2); FunctorUMinus = Yap_MkFunctor(AtomMinus,1); FunctorUPlus = Yap_MkFunctor(AtomPlus,1); FunctorVBar = Yap_MkFunctor(AtomVBar,2); FunctorWriteTerm = Yap_MkFunctor(AtomWriteTerm,2); FunctorHiddenVar = Yap_MkFunctor(AtomHiddenVar,1);