yap-6.3/H/generated/tatoms.h

  /* This file, tatoms.h, was generated automatically by "yap -L misc/buildatoms"
     please do not update, update misc/ATOMS instead */

  Atom Atom3Dots_;
#define Atom3Dots Yap_heap_regs->Atom3Dots_
#define Term3Dots MkAtomTerm( Yap_heap_regs->Atom3Dots_ )
  Atom AtomAbol_;
#define AtomAbol Yap_heap_regs->AtomAbol_
#define TermAbol MkAtomTerm( Yap_heap_regs->AtomAbol_ )
  Atom AtomAccess_;
#define AtomAccess Yap_heap_regs->AtomAccess_
#define TermAccess MkAtomTerm( Yap_heap_regs->AtomAccess_ )
  Atom AtomAfInet_;
#define AtomAfInet Yap_heap_regs->AtomAfInet_
#define TermAfInet MkAtomTerm( Yap_heap_regs->AtomAfInet_ )
  Atom AtomAfLocal_;
#define AtomAfLocal Yap_heap_regs->AtomAfLocal_
#define TermAfLocal MkAtomTerm( Yap_heap_regs->AtomAfLocal_ )
  Atom AtomAfUnix_;
#define AtomAfUnix Yap_heap_regs->AtomAfUnix_
#define TermAfUnix MkAtomTerm( Yap_heap_regs->AtomAfUnix_ )
  Atom AtomAlarm_;
#define AtomAlarm Yap_heap_regs->AtomAlarm_
#define TermAlarm MkAtomTerm( Yap_heap_regs->AtomAlarm_ )
  Atom AtomAlias_;
#define AtomAlias Yap_heap_regs->AtomAlias_
#define TermAlias MkAtomTerm( Yap_heap_regs->AtomAlias_ )
  Atom AtomAll_;
#define AtomAll Yap_heap_regs->AtomAll_
#define TermAll MkAtomTerm( Yap_heap_regs->AtomAll_ )
  Atom AtomAltNot_;
#define AtomAltNot Yap_heap_regs->AtomAltNot_
#define TermAltNot MkAtomTerm( Yap_heap_regs->AtomAltNot_ )
  Atom AtomAny_;
#define AtomAny Yap_heap_regs->AtomAny_
#define TermAny MkAtomTerm( Yap_heap_regs->AtomAny_ )
  Atom AtomAppend_;
#define AtomAppend Yap_heap_regs->AtomAppend_
#define TermAppend MkAtomTerm( Yap_heap_regs->AtomAppend_ )
  Atom AtomArg_;
#define AtomArg Yap_heap_regs->AtomArg_
#define TermArg MkAtomTerm( Yap_heap_regs->AtomArg_ )
  Atom AtomArray_;
#define AtomArray Yap_heap_regs->AtomArray_
#define TermArray MkAtomTerm( Yap_heap_regs->AtomArray_ )
  Atom AtomArrayAccess_;
#define AtomArrayAccess Yap_heap_regs->AtomArrayAccess_
#define TermArrayAccess MkAtomTerm( Yap_heap_regs->AtomArrayAccess_ )
  Atom AtomArrayOverflow_;
#define AtomArrayOverflow Yap_heap_regs->AtomArrayOverflow_
#define TermArrayOverflow MkAtomTerm( Yap_heap_regs->AtomArrayOverflow_ )
  Atom AtomArrayType_;
#define AtomArrayType Yap_heap_regs->AtomArrayType_
#define TermArrayType MkAtomTerm( Yap_heap_regs->AtomArrayType_ )
  Atom AtomArrow_;
#define AtomArrow Yap_heap_regs->AtomArrow_
#define TermArrow MkAtomTerm( Yap_heap_regs->AtomArrow_ )
  Atom AtomAttributedModule_;
#define AtomAttributedModule Yap_heap_regs->AtomAttributedModule_
#define TermAttributedModule MkAtomTerm( Yap_heap_regs->AtomAttributedModule_ )
  Atom AtomDoubleArrow_;
#define AtomDoubleArrow Yap_heap_regs->AtomDoubleArrow_
#define TermDoubleArrow MkAtomTerm( Yap_heap_regs->AtomDoubleArrow_ )
  Atom AtomAssert_;
#define AtomAssert Yap_heap_regs->AtomAssert_
#define TermAssert MkAtomTerm( Yap_heap_regs->AtomAssert_ )
  Atom AtomEmptyBrackets_;
#define AtomEmptyBrackets Yap_heap_regs->AtomEmptyBrackets_
#define TermEmptyBrackets MkAtomTerm( Yap_heap_regs->AtomEmptyBrackets_ )
  Atom AtomEmptySquareBrackets_;
#define AtomEmptySquareBrackets Yap_heap_regs->AtomEmptySquareBrackets_
#define TermEmptySquareBrackets MkAtomTerm( Yap_heap_regs->AtomEmptySquareBrackets_ )
  Atom AtomEmptyCurlyBrackets_;
#define AtomEmptyCurlyBrackets Yap_heap_regs->AtomEmptyCurlyBrackets_
#define TermEmptyCurlyBrackets MkAtomTerm( Yap_heap_regs->AtomEmptyCurlyBrackets_ )
  Atom AtomAsserta_;
#define AtomAsserta Yap_heap_regs->AtomAsserta_
#define TermAsserta MkAtomTerm( Yap_heap_regs->AtomAsserta_ )
  Atom AtomAssertaStatic_;
#define AtomAssertaStatic Yap_heap_regs->AtomAssertaStatic_
#define TermAssertaStatic MkAtomTerm( Yap_heap_regs->AtomAssertaStatic_ )
  Atom AtomAssertz_;
#define AtomAssertz Yap_heap_regs->AtomAssertz_
#define TermAssertz MkAtomTerm( Yap_heap_regs->AtomAssertz_ )
  Atom AtomAssertzStatic_;
#define AtomAssertzStatic Yap_heap_regs->AtomAssertzStatic_
#define TermAssertzStatic MkAtomTerm( Yap_heap_regs->AtomAssertzStatic_ )
  Atom AtomAt_;
#define AtomAt Yap_heap_regs->AtomAt_
#define TermAt MkAtomTerm( Yap_heap_regs->AtomAt_ )
  Atom AtomAtom_;
#define AtomAtom Yap_heap_regs->AtomAtom_
#define TermAtom MkAtomTerm( Yap_heap_regs->AtomAtom_ )
  Atom AtomAtomic_;
#define AtomAtomic Yap_heap_regs->AtomAtomic_
#define TermAtomic MkAtomTerm( Yap_heap_regs->AtomAtomic_ )
  Atom AtomAtt_;
#define AtomAtt Yap_heap_regs->AtomAtt_
#define TermAtt MkAtomTerm( Yap_heap_regs->AtomAtt_ )
  Atom AtomAtt1_;
#define AtomAtt1 Yap_heap_regs->AtomAtt1_
#define TermAtt1 MkAtomTerm( Yap_heap_regs->AtomAtt1_ )
  Atom AtomAttDo_;
#define AtomAttDo Yap_heap_regs->AtomAttDo_
#define TermAttDo MkAtomTerm( Yap_heap_regs->AtomAttDo_ )
  Atom AtomAttributes_;
#define AtomAttributes Yap_heap_regs->AtomAttributes_
#define TermAttributes MkAtomTerm( Yap_heap_regs->AtomAttributes_ )
  Atom AtomB_;
#define AtomB Yap_heap_regs->AtomB_
#define TermB MkAtomTerm( Yap_heap_regs->AtomB_ )
  Atom AtomBatched_;
#define AtomBatched Yap_heap_regs->AtomBatched_
#define TermBatched MkAtomTerm( Yap_heap_regs->AtomBatched_ )
  Atom AtomBetween_;
#define AtomBetween Yap_heap_regs->AtomBetween_
#define TermBetween MkAtomTerm( Yap_heap_regs->AtomBetween_ )
  Atom AtomBinary_;
#define AtomBinary Yap_heap_regs->AtomBinary_
#define TermBinary MkAtomTerm( Yap_heap_regs->AtomBinary_ )
  Atom AtomBigNum_;
#define AtomBigNum Yap_heap_regs->AtomBigNum_
#define TermBigNum MkAtomTerm( Yap_heap_regs->AtomBigNum_ )
  Atom AtomBinaryStream_;
#define AtomBinaryStream Yap_heap_regs->AtomBinaryStream_
#define TermBinaryStream MkAtomTerm( Yap_heap_regs->AtomBinaryStream_ )
  Atom AtomBoolean_;
#define AtomBoolean Yap_heap_regs->AtomBoolean_
#define TermBoolean MkAtomTerm( Yap_heap_regs->AtomBoolean_ )
  Atom AtomBraces_;
#define AtomBraces Yap_heap_regs->AtomBraces_
#define TermBraces MkAtomTerm( Yap_heap_regs->AtomBraces_ )
  Atom AtomBreak_;
#define AtomBreak Yap_heap_regs->AtomBreak_
#define TermBreak MkAtomTerm( Yap_heap_regs->AtomBreak_ )
  Atom AtomByte_;
#define AtomByte Yap_heap_regs->AtomByte_
#define TermByte MkAtomTerm( Yap_heap_regs->AtomByte_ )
  Atom AtomCArith_;
#define AtomCArith Yap_heap_regs->AtomCArith_
#define TermCArith MkAtomTerm( Yap_heap_regs->AtomCArith_ )
  Atom AtomCall_;
#define AtomCall Yap_heap_regs->AtomCall_
#define TermCall MkAtomTerm( Yap_heap_regs->AtomCall_ )
  Atom AtomCallAndRetryCounter_;
#define AtomCallAndRetryCounter Yap_heap_regs->AtomCallAndRetryCounter_
#define TermCallAndRetryCounter MkAtomTerm( Yap_heap_regs->AtomCallAndRetryCounter_ )
  Atom AtomCallCounter_;
#define AtomCallCounter Yap_heap_regs->AtomCallCounter_
#define TermCallCounter MkAtomTerm( Yap_heap_regs->AtomCallCounter_ )
  Atom AtomCallable_;
#define AtomCallable Yap_heap_regs->AtomCallable_
#define TermCallable MkAtomTerm( Yap_heap_regs->AtomCallable_ )
  Atom AtomCatch_;
#define AtomCatch Yap_heap_regs->AtomCatch_
#define TermCatch MkAtomTerm( Yap_heap_regs->AtomCatch_ )
  Atom AtomChangeModule_;
#define AtomChangeModule Yap_heap_regs->AtomChangeModule_
#define TermChangeModule MkAtomTerm( Yap_heap_regs->AtomChangeModule_ )
  Atom AtomChar_;
#define AtomChar Yap_heap_regs->AtomChar_
#define TermChar MkAtomTerm( Yap_heap_regs->AtomChar_ )
  Atom AtomCharsio_;
#define AtomCharsio Yap_heap_regs->AtomCharsio_
#define TermCharsio MkAtomTerm( Yap_heap_regs->AtomCharsio_ )
  Atom AtomCharacter_;
#define AtomCharacter Yap_heap_regs->AtomCharacter_
#define TermCharacter MkAtomTerm( Yap_heap_regs->AtomCharacter_ )
  Atom AtomCharacterCode_;
#define AtomCharacterCode Yap_heap_regs->AtomCharacterCode_
#define TermCharacterCode MkAtomTerm( Yap_heap_regs->AtomCharacterCode_ )
  Atom AtomChars_;
#define AtomChars Yap_heap_regs->AtomChars_
#define TermChars MkAtomTerm( Yap_heap_regs->AtomChars_ )
  Atom AtomCharset_;
#define AtomCharset Yap_heap_regs->AtomCharset_
#define TermCharset MkAtomTerm( Yap_heap_regs->AtomCharset_ )
  Atom AtomChType_;
#define AtomChType Yap_heap_regs->AtomChType_
#define TermChType MkAtomTerm( Yap_heap_regs->AtomChType_ )
  Atom AtomCleanCall_;
#define AtomCleanCall Yap_heap_regs->AtomCleanCall_
#define TermCleanCall MkAtomTerm( Yap_heap_regs->AtomCleanCall_ )
  Atom AtomColomn_;
#define AtomColomn Yap_heap_regs->AtomColomn_
#define TermColomn MkAtomTerm( Yap_heap_regs->AtomColomn_ )
  Atom AtomCodeSpace_;
#define AtomCodeSpace Yap_heap_regs->AtomCodeSpace_
#define TermCodeSpace MkAtomTerm( Yap_heap_regs->AtomCodeSpace_ )
  Atom AtomCodes_;
#define AtomCodes Yap_heap_regs->AtomCodes_
#define TermCodes MkAtomTerm( Yap_heap_regs->AtomCodes_ )
  Atom AtomCoInductive_;
#define AtomCoInductive Yap_heap_regs->AtomCoInductive_
#define TermCoInductive MkAtomTerm( Yap_heap_regs->AtomCoInductive_ )
  Atom AtomComma_;
#define AtomComma Yap_heap_regs->AtomComma_
#define TermComma MkAtomTerm( Yap_heap_regs->AtomComma_ )
  Atom AtomCommentHook_;
#define AtomCommentHook Yap_heap_regs->AtomCommentHook_
#define TermCommentHook MkAtomTerm( Yap_heap_regs->AtomCommentHook_ )
  Atom AtomCompact_;
#define AtomCompact Yap_heap_regs->AtomCompact_
#define TermCompact MkAtomTerm( Yap_heap_regs->AtomCompact_ )
  Atom AtomCompound_;
#define AtomCompound Yap_heap_regs->AtomCompound_
#define TermCompound MkAtomTerm( Yap_heap_regs->AtomCompound_ )
  Atom AtomConsistencyError_;
#define AtomConsistencyError Yap_heap_regs->AtomConsistencyError_
#define TermConsistencyError MkAtomTerm( Yap_heap_regs->AtomConsistencyError_ )
  Atom AtomConsult_;
#define AtomConsult Yap_heap_regs->AtomConsult_
#define TermConsult MkAtomTerm( Yap_heap_regs->AtomConsult_ )
  Atom AtomConsultOnBoot_;
#define AtomConsultOnBoot Yap_heap_regs->AtomConsultOnBoot_
#define TermConsultOnBoot MkAtomTerm( Yap_heap_regs->AtomConsultOnBoot_ )
  Atom AtomContext_;
#define AtomContext Yap_heap_regs->AtomContext_
#define TermContext MkAtomTerm( Yap_heap_regs->AtomContext_ )
  Atom AtomCputime_;
#define AtomCputime Yap_heap_regs->AtomCputime_
#define TermCputime MkAtomTerm( Yap_heap_regs->AtomCputime_ )
  Atom AtomCreate_;
#define AtomCreate Yap_heap_regs->AtomCreate_
#define TermCreate MkAtomTerm( Yap_heap_regs->AtomCreate_ )
  Atom AtomCreep_;
#define AtomCreep Yap_heap_regs->AtomCreep_
#define TermCreep MkAtomTerm( Yap_heap_regs->AtomCreep_ )
  Atom AtomCryptAtoms_;
#define AtomCryptAtoms Yap_heap_regs->AtomCryptAtoms_
#define TermCryptAtoms MkAtomTerm( Yap_heap_regs->AtomCryptAtoms_ )
  Atom AtomCsult_;
#define AtomCsult Yap_heap_regs->AtomCsult_
#define TermCsult MkAtomTerm( Yap_heap_regs->AtomCsult_ )
  Atom AtomCurrentModule_;
#define AtomCurrentModule Yap_heap_regs->AtomCurrentModule_
#define TermCurrentModule MkAtomTerm( Yap_heap_regs->AtomCurrentModule_ )
  Atom AtomCut_;
#define AtomCut Yap_heap_regs->AtomCut_
#define TermCut MkAtomTerm( Yap_heap_regs->AtomCut_ )
  Atom AtomCutBy_;
#define AtomCutBy Yap_heap_regs->AtomCutBy_
#define TermCutBy MkAtomTerm( Yap_heap_regs->AtomCutBy_ )
  Atom AtomDAbort_;
#define AtomDAbort Yap_heap_regs->AtomDAbort_
#define TermDAbort MkAtomTerm( Yap_heap_regs->AtomDAbort_ )
  Atom AtomDBLoad_;
#define AtomDBLoad Yap_heap_regs->AtomDBLoad_
#define TermDBLoad MkAtomTerm( Yap_heap_regs->AtomDBLoad_ )
  Atom AtomDBREF_;
#define AtomDBREF Yap_heap_regs->AtomDBREF_
#define TermDBREF MkAtomTerm( Yap_heap_regs->AtomDBREF_ )
  Atom AtomDBReference_;
#define AtomDBReference Yap_heap_regs->AtomDBReference_
#define TermDBReference MkAtomTerm( Yap_heap_regs->AtomDBReference_ )
  Atom AtomDBTerm_;
#define AtomDBTerm Yap_heap_regs->AtomDBTerm_
#define TermDBTerm MkAtomTerm( Yap_heap_regs->AtomDBTerm_ )
  Atom AtomDBref_;
#define AtomDBref Yap_heap_regs->AtomDBref_
#define TermDBref MkAtomTerm( Yap_heap_regs->AtomDBref_ )
  Atom AtomDInteger_;
#define AtomDInteger Yap_heap_regs->AtomDInteger_
#define TermDInteger MkAtomTerm( Yap_heap_regs->AtomDInteger_ )
  Atom AtomDebugMeta_;
#define AtomDebugMeta Yap_heap_regs->AtomDebugMeta_
#define TermDebugMeta MkAtomTerm( Yap_heap_regs->AtomDebugMeta_ )
  Atom AtomDebuggerInput_;
#define AtomDebuggerInput Yap_heap_regs->AtomDebuggerInput_
#define TermDebuggerInput MkAtomTerm( Yap_heap_regs->AtomDebuggerInput_ )
  Atom AtomDec10_;
#define AtomDec10 Yap_heap_regs->AtomDec10_
#define TermDec10 MkAtomTerm( Yap_heap_regs->AtomDec10_ )
  Atom AtomDefault_;
#define AtomDefault Yap_heap_regs->AtomDefault_
#define TermDefault MkAtomTerm( Yap_heap_regs->AtomDefault_ )
  Atom AtomDevNull_;
#define AtomDevNull Yap_heap_regs->AtomDevNull_
#define TermDevNull MkAtomTerm( Yap_heap_regs->AtomDevNull_ )
  Atom AtomDiff_;
#define AtomDiff Yap_heap_regs->AtomDiff_
#define TermDiff MkAtomTerm( Yap_heap_regs->AtomDiff_ )
  Atom AtomDirectory_;
#define AtomDirectory Yap_heap_regs->AtomDirectory_
#define TermDirectory MkAtomTerm( Yap_heap_regs->AtomDirectory_ )
  Atom AtomDiscontiguous_;
#define AtomDiscontiguous Yap_heap_regs->AtomDiscontiguous_
#define TermDiscontiguous MkAtomTerm( Yap_heap_regs->AtomDiscontiguous_ )
  Atom AtomDiscontiguousWarnings_;
#define AtomDiscontiguousWarnings Yap_heap_regs->AtomDiscontiguousWarnings_
#define TermDiscontiguousWarnings MkAtomTerm( Yap_heap_regs->AtomDiscontiguousWarnings_ )
  Atom AtomDollar_;
#define AtomDollar Yap_heap_regs->AtomDollar_
#define TermDollar MkAtomTerm( Yap_heap_regs->AtomDollar_ )
  Atom AtomDoLogUpdClause_;
#define AtomDoLogUpdClause Yap_heap_regs->AtomDoLogUpdClause_
#define TermDoLogUpdClause MkAtomTerm( Yap_heap_regs->AtomDoLogUpdClause_ )
  Atom AtomDoLogUpdClause0_;
#define AtomDoLogUpdClause0 Yap_heap_regs->AtomDoLogUpdClause0_
#define TermDoLogUpdClause0 MkAtomTerm( Yap_heap_regs->AtomDoLogUpdClause0_ )
  Atom AtomDoLogUpdClauseErase_;
#define AtomDoLogUpdClauseErase Yap_heap_regs->AtomDoLogUpdClauseErase_
#define TermDoLogUpdClauseErase MkAtomTerm( Yap_heap_regs->AtomDoLogUpdClauseErase_ )
  Atom AtomDollarU_;
#define AtomDollarU Yap_heap_regs->AtomDollarU_
#define TermDollarU MkAtomTerm( Yap_heap_regs->AtomDollarU_ )
  Atom AtomDollarUndef_;
#define AtomDollarUndef Yap_heap_regs->AtomDollarUndef_
#define TermDollarUndef MkAtomTerm( Yap_heap_regs->AtomDollarUndef_ )
  Atom AtomDomainError_;
#define AtomDomainError Yap_heap_regs->AtomDomainError_
#define TermDomainError MkAtomTerm( Yap_heap_regs->AtomDomainError_ )
  Atom AtomDoStaticClause_;
#define AtomDoStaticClause Yap_heap_regs->AtomDoStaticClause_
#define TermDoStaticClause MkAtomTerm( Yap_heap_regs->AtomDoStaticClause_ )
  Atom AtomDots_;
#define AtomDots Yap_heap_regs->AtomDots_
#define TermDots MkAtomTerm( Yap_heap_regs->AtomDots_ )
  Atom AtomDOUBLE_;
#define AtomDOUBLE Yap_heap_regs->AtomDOUBLE_
#define TermDOUBLE MkAtomTerm( Yap_heap_regs->AtomDOUBLE_ )
  Atom AtomDoubleSlash_;
#define AtomDoubleSlash Yap_heap_regs->AtomDoubleSlash_
#define TermDoubleSlash MkAtomTerm( Yap_heap_regs->AtomDoubleSlash_ )
  Atom AtomE_;
#define AtomE Yap_heap_regs->AtomE_
#define TermE MkAtomTerm( Yap_heap_regs->AtomE_ )
  Atom AtomEOFBeforeEOT_;
#define AtomEOFBeforeEOT Yap_heap_regs->AtomEOFBeforeEOT_
#define TermEOFBeforeEOT MkAtomTerm( Yap_heap_regs->AtomEOFBeforeEOT_ )
  Atom AtomEQ_;
#define AtomEQ Yap_heap_regs->AtomEQ_
#define TermEQ MkAtomTerm( Yap_heap_regs->AtomEQ_ )
  Atom AtomEmptyAtom_;
#define AtomEmptyAtom Yap_heap_regs->AtomEmptyAtom_
#define TermEmptyAtom MkAtomTerm( Yap_heap_regs->AtomEmptyAtom_ )
  Atom AtomEncoding_;
#define AtomEncoding Yap_heap_regs->AtomEncoding_
#define TermEncoding MkAtomTerm( Yap_heap_regs->AtomEncoding_ )
  Atom AtomEndOfStream_;
#define AtomEndOfStream Yap_heap_regs->AtomEndOfStream_
#define TermEndOfStream MkAtomTerm( Yap_heap_regs->AtomEndOfStream_ )
  Atom AtomEof_;
#define AtomEof Yap_heap_regs->AtomEof_
#define TermEof MkAtomTerm( Yap_heap_regs->AtomEof_ )
  Atom AtomEOfCode_;
#define AtomEOfCode Yap_heap_regs->AtomEOfCode_
#define TermEOfCode MkAtomTerm( Yap_heap_regs->AtomEOfCode_ )
  Atom AtomEq_;
#define AtomEq Yap_heap_regs->AtomEq_
#define TermEq MkAtomTerm( Yap_heap_regs->AtomEq_ )
  Atom AtomError_;
#define AtomError Yap_heap_regs->AtomError_
#define TermError MkAtomTerm( Yap_heap_regs->AtomError_ )
  Atom AtomException_;
#define AtomException Yap_heap_regs->AtomException_
#define TermException MkAtomTerm( Yap_heap_regs->AtomException_ )
  Atom AtomExtensions_;
#define AtomExtensions Yap_heap_regs->AtomExtensions_
#define TermExtensions MkAtomTerm( Yap_heap_regs->AtomExtensions_ )
  Atom AtomEvaluable_;
#define AtomEvaluable Yap_heap_regs->AtomEvaluable_
#define TermEvaluable MkAtomTerm( Yap_heap_regs->AtomEvaluable_ )
  Atom AtomEvaluationError_;
#define AtomEvaluationError Yap_heap_regs->AtomEvaluationError_
#define TermEvaluationError MkAtomTerm( Yap_heap_regs->AtomEvaluationError_ )
  Atom AtomExecutable_;
#define AtomExecutable Yap_heap_regs->AtomExecutable_
#define TermExecutable MkAtomTerm( Yap_heap_regs->AtomExecutable_ )
  Atom AtomExecute_;
#define AtomExecute Yap_heap_regs->AtomExecute_
#define TermExecute MkAtomTerm( Yap_heap_regs->AtomExecute_ )
  Atom AtomExecAnswers_;
#define AtomExecAnswers Yap_heap_regs->AtomExecAnswers_
#define TermExecAnswers MkAtomTerm( Yap_heap_regs->AtomExecAnswers_ )
  Atom AtomExecuteInMod_;
#define AtomExecuteInMod Yap_heap_regs->AtomExecuteInMod_
#define TermExecuteInMod MkAtomTerm( Yap_heap_regs->AtomExecuteInMod_ )
  Atom AtomExecuteWithin_;
#define AtomExecuteWithin Yap_heap_regs->AtomExecuteWithin_
#define TermExecuteWithin MkAtomTerm( Yap_heap_regs->AtomExecuteWithin_ )
  Atom AtomExecuteWoMod_;
#define AtomExecuteWoMod Yap_heap_regs->AtomExecuteWoMod_
#define TermExecuteWoMod MkAtomTerm( Yap_heap_regs->AtomExecuteWoMod_ )
  Atom AtomExist_;
#define AtomExist Yap_heap_regs->AtomExist_
#define TermExist MkAtomTerm( Yap_heap_regs->AtomExist_ )
  Atom AtomExistenceError_;
#define AtomExistenceError Yap_heap_regs->AtomExistenceError_
#define TermExistenceError MkAtomTerm( Yap_heap_regs->AtomExistenceError_ )
  Atom AtomExoClause_;
#define AtomExoClause Yap_heap_regs->AtomExoClause_
#define TermExoClause MkAtomTerm( Yap_heap_regs->AtomExoClause_ )
  Atom AtomExpectedNumber_;
#define AtomExpectedNumber Yap_heap_regs->AtomExpectedNumber_
#define TermExpectedNumber MkAtomTerm( Yap_heap_regs->AtomExpectedNumber_ )
  Atom AtomExpand_;
#define AtomExpand Yap_heap_regs->AtomExpand_
#define TermExpand MkAtomTerm( Yap_heap_regs->AtomExpand_ )
  Atom AtomExtendFileSearchPath_;
#define AtomExtendFileSearchPath Yap_heap_regs->AtomExtendFileSearchPath_
#define TermExtendFileSearchPath MkAtomTerm( Yap_heap_regs->AtomExtendFileSearchPath_ )
  Atom AtomExtendsions_;
#define AtomExtendsions Yap_heap_regs->AtomExtendsions_
#define TermExtendsions MkAtomTerm( Yap_heap_regs->AtomExtendsions_ )
  Atom AtomFB_;
#define AtomFB Yap_heap_regs->AtomFB_
#define TermFB MkAtomTerm( Yap_heap_regs->AtomFB_ )
  Atom AtomFail_;
#define AtomFail Yap_heap_regs->AtomFail_
#define TermFail MkAtomTerm( Yap_heap_regs->AtomFail_ )
  Atom AtomFalse_;
#define AtomFalse Yap_heap_regs->AtomFalse_
#define TermFalse MkAtomTerm( Yap_heap_regs->AtomFalse_ )
  Atom AtomFast_;
#define AtomFast Yap_heap_regs->AtomFast_
#define TermFast MkAtomTerm( Yap_heap_regs->AtomFast_ )
  Atom AtomFastFail_;
#define AtomFastFail Yap_heap_regs->AtomFastFail_
#define TermFastFail MkAtomTerm( Yap_heap_regs->AtomFastFail_ )
  Atom AtomFileErrors_;
#define AtomFileErrors Yap_heap_regs->AtomFileErrors_
#define TermFileErrors MkAtomTerm( Yap_heap_regs->AtomFileErrors_ )
  Atom AtomFileerrors_;
#define AtomFileerrors Yap_heap_regs->AtomFileerrors_
#define TermFileerrors MkAtomTerm( Yap_heap_regs->AtomFileerrors_ )
  Atom AtomFileType_;
#define AtomFileType Yap_heap_regs->AtomFileType_
#define TermFileType MkAtomTerm( Yap_heap_regs->AtomFileType_ )
  Atom AtomFirst_;
#define AtomFirst Yap_heap_regs->AtomFirst_
#define TermFirst MkAtomTerm( Yap_heap_regs->AtomFirst_ )
  Atom AtomFloat_;
#define AtomFloat Yap_heap_regs->AtomFloat_
#define TermFloat MkAtomTerm( Yap_heap_regs->AtomFloat_ )
  Atom AtomFloatFormat_;
#define AtomFloatFormat Yap_heap_regs->AtomFloatFormat_
#define TermFloatFormat MkAtomTerm( Yap_heap_regs->AtomFloatFormat_ )
  Atom AtomFloatOverflow_;
#define AtomFloatOverflow Yap_heap_regs->AtomFloatOverflow_
#define TermFloatOverflow MkAtomTerm( Yap_heap_regs->AtomFloatOverflow_ )
  Atom AtomFloatUnderflow_;
#define AtomFloatUnderflow Yap_heap_regs->AtomFloatUnderflow_
#define TermFloatUnderflow MkAtomTerm( Yap_heap_regs->AtomFloatUnderflow_ )
  Atom AtomFormat_;
#define AtomFormat Yap_heap_regs->AtomFormat_
#define TermFormat MkAtomTerm( Yap_heap_regs->AtomFormat_ )
  Atom AtomFormatAt_;
#define AtomFormatAt Yap_heap_regs->AtomFormatAt_
#define TermFormatAt MkAtomTerm( Yap_heap_regs->AtomFormatAt_ )
  Atom AtomFull_;
#define AtomFull Yap_heap_regs->AtomFull_
#define TermFull MkAtomTerm( Yap_heap_regs->AtomFull_ )
  Atom AtomFunctor_;
#define AtomFunctor Yap_heap_regs->AtomFunctor_
#define TermFunctor MkAtomTerm( Yap_heap_regs->AtomFunctor_ )
  Atom AtomGT_;
#define AtomGT Yap_heap_regs->AtomGT_
#define TermGT MkAtomTerm( Yap_heap_regs->AtomGT_ )
  Atom AtomGVar_;
#define AtomGVar Yap_heap_regs->AtomGVar_
#define TermGVar MkAtomTerm( Yap_heap_regs->AtomGVar_ )
  Atom AtomGc_;
#define AtomGc Yap_heap_regs->AtomGc_
#define TermGc MkAtomTerm( Yap_heap_regs->AtomGc_ )
  Atom AtomGcMargin_;
#define AtomGcMargin Yap_heap_regs->AtomGcMargin_
#define TermGcMargin MkAtomTerm( Yap_heap_regs->AtomGcMargin_ )
  Atom AtomGcTrace_;
#define AtomGcTrace Yap_heap_regs->AtomGcTrace_
#define TermGcTrace MkAtomTerm( Yap_heap_regs->AtomGcTrace_ )
  Atom AtomGcVerbose_;
#define AtomGcVerbose Yap_heap_regs->AtomGcVerbose_
#define TermGcVerbose MkAtomTerm( Yap_heap_regs->AtomGcVerbose_ )
  Atom AtomGcVeryVerbose_;
#define AtomGcVeryVerbose Yap_heap_regs->AtomGcVeryVerbose_
#define TermGcVeryVerbose MkAtomTerm( Yap_heap_regs->AtomGcVeryVerbose_ )
  Atom AtomGeneratePredInfo_;
#define AtomGeneratePredInfo Yap_heap_regs->AtomGeneratePredInfo_
#define TermGeneratePredInfo MkAtomTerm( Yap_heap_regs->AtomGeneratePredInfo_ )
  Atom AtomGetwork_;
#define AtomGetwork Yap_heap_regs->AtomGetwork_
#define TermGetwork MkAtomTerm( Yap_heap_regs->AtomGetwork_ )
  Atom AtomGetworkSeq_;
#define AtomGetworkSeq Yap_heap_regs->AtomGetworkSeq_
#define TermGetworkSeq MkAtomTerm( Yap_heap_regs->AtomGetworkSeq_ )
  Atom AtomGlob_;
#define AtomGlob Yap_heap_regs->AtomGlob_
#define TermGlob MkAtomTerm( Yap_heap_regs->AtomGlob_ )
  Atom AtomGlobal_;
#define AtomGlobal Yap_heap_regs->AtomGlobal_
#define TermGlobal MkAtomTerm( Yap_heap_regs->AtomGlobal_ )
  Atom AtomGlobalSp_;
#define AtomGlobalSp Yap_heap_regs->AtomGlobalSp_
#define TermGlobalSp MkAtomTerm( Yap_heap_regs->AtomGlobalSp_ )
  Atom AtomGlobalTrie_;
#define AtomGlobalTrie Yap_heap_regs->AtomGlobalTrie_
#define TermGlobalTrie MkAtomTerm( Yap_heap_regs->AtomGlobalTrie_ )
  Atom AtomGoalExpansion_;
#define AtomGoalExpansion Yap_heap_regs->AtomGoalExpansion_
#define TermGoalExpansion MkAtomTerm( Yap_heap_regs->AtomGoalExpansion_ )
  Atom AtomHat_;
#define AtomHat Yap_heap_regs->AtomHat_
#define TermHat MkAtomTerm( Yap_heap_regs->AtomHat_ )
  Atom AtomHERE_;
#define AtomHERE Yap_heap_regs->AtomHERE_
#define TermHERE MkAtomTerm( Yap_heap_regs->AtomHERE_ )
  Atom AtomHandleThrow_;
#define AtomHandleThrow Yap_heap_regs->AtomHandleThrow_
#define TermHandleThrow MkAtomTerm( Yap_heap_regs->AtomHandleThrow_ )
  Atom AtomHeap_;
#define AtomHeap Yap_heap_regs->AtomHeap_
#define TermHeap MkAtomTerm( Yap_heap_regs->AtomHeap_ )
  Atom AtomHeapUsed_;
#define AtomHeapUsed Yap_heap_regs->AtomHeapUsed_
#define TermHeapUsed MkAtomTerm( Yap_heap_regs->AtomHeapUsed_ )
  Atom AtomHugeInt_;
#define AtomHugeInt Yap_heap_regs->AtomHugeInt_
#define TermHugeInt MkAtomTerm( Yap_heap_regs->AtomHugeInt_ )
  Atom AtomIDB_;
#define AtomIDB Yap_heap_regs->AtomIDB_
#define TermIDB MkAtomTerm( Yap_heap_regs->AtomIDB_ )
  Atom AtomIOMode_;
#define AtomIOMode Yap_heap_regs->AtomIOMode_
#define TermIOMode MkAtomTerm( Yap_heap_regs->AtomIOMode_ )
  Atom AtomId_;
#define AtomId Yap_heap_regs->AtomId_
#define TermId MkAtomTerm( Yap_heap_regs->AtomId_ )
  Atom AtomIgnore_;
#define AtomIgnore Yap_heap_regs->AtomIgnore_
#define TermIgnore MkAtomTerm( Yap_heap_regs->AtomIgnore_ )
  Atom AtomInf_;
#define AtomInf Yap_heap_regs->AtomInf_
#define TermInf MkAtomTerm( Yap_heap_regs->AtomInf_ )
  Atom AtomInfinity_;
#define AtomInfinity Yap_heap_regs->AtomInfinity_
#define TermInfinity MkAtomTerm( Yap_heap_regs->AtomInfinity_ )
  Atom AtomInitGoal_;
#define AtomInitGoal Yap_heap_regs->AtomInitGoal_
#define TermInitGoal MkAtomTerm( Yap_heap_regs->AtomInitGoal_ )
  Atom AtomInitProlog_;
#define AtomInitProlog Yap_heap_regs->AtomInitProlog_
#define TermInitProlog MkAtomTerm( Yap_heap_regs->AtomInitProlog_ )
  Atom AtomInStackExpansion_;
#define AtomInStackExpansion Yap_heap_regs->AtomInStackExpansion_
#define TermInStackExpansion MkAtomTerm( Yap_heap_regs->AtomInStackExpansion_ )
  Atom AtomInput_;
#define AtomInput Yap_heap_regs->AtomInput_
#define TermInput MkAtomTerm( Yap_heap_regs->AtomInput_ )
  Atom AtomInstantiationError_;
#define AtomInstantiationError Yap_heap_regs->AtomInstantiationError_
#define TermInstantiationError MkAtomTerm( Yap_heap_regs->AtomInstantiationError_ )
  Atom AtomInt_;
#define AtomInt Yap_heap_regs->AtomInt_
#define TermInt MkAtomTerm( Yap_heap_regs->AtomInt_ )
  Atom AtomIntOverflow_;
#define AtomIntOverflow Yap_heap_regs->AtomIntOverflow_
#define TermIntOverflow MkAtomTerm( Yap_heap_regs->AtomIntOverflow_ )
  Atom AtomInteger_;
#define AtomInteger Yap_heap_regs->AtomInteger_
#define TermInteger MkAtomTerm( Yap_heap_regs->AtomInteger_ )
  Atom AtomInternalCompilerError_;
#define AtomInternalCompilerError Yap_heap_regs->AtomInternalCompilerError_
#define TermInternalCompilerError MkAtomTerm( Yap_heap_regs->AtomInternalCompilerError_ )
  Atom AtomIs_;
#define AtomIs Yap_heap_regs->AtomIs_
#define TermIs MkAtomTerm( Yap_heap_regs->AtomIs_ )
  Atom AtomKey_;
#define AtomKey Yap_heap_regs->AtomKey_
#define TermKey MkAtomTerm( Yap_heap_regs->AtomKey_ )
  Atom AtomLDLibraryPath_;
#define AtomLDLibraryPath Yap_heap_regs->AtomLDLibraryPath_
#define TermLDLibraryPath MkAtomTerm( Yap_heap_regs->AtomLDLibraryPath_ )
  Atom AtomLONGINT_;
#define AtomLONGINT Yap_heap_regs->AtomLONGINT_
#define TermLONGINT MkAtomTerm( Yap_heap_regs->AtomLONGINT_ )
  Atom AtomLOOP_;
#define AtomLOOP Yap_heap_regs->AtomLOOP_
#define TermLOOP MkAtomTerm( Yap_heap_regs->AtomLOOP_ )
  Atom AtomLoopStream_;
#define AtomLoopStream Yap_heap_regs->AtomLoopStream_
#define TermLoopStream MkAtomTerm( Yap_heap_regs->AtomLoopStream_ )
  Atom AtomLT_;
#define AtomLT Yap_heap_regs->AtomLT_
#define TermLT MkAtomTerm( Yap_heap_regs->AtomLT_ )
  Atom AtomLastExecuteWithin_;
#define AtomLastExecuteWithin Yap_heap_regs->AtomLastExecuteWithin_
#define TermLastExecuteWithin MkAtomTerm( Yap_heap_regs->AtomLastExecuteWithin_ )
  Atom AtomLeash_;
#define AtomLeash Yap_heap_regs->AtomLeash_
#define TermLeash MkAtomTerm( Yap_heap_regs->AtomLeash_ )
  Atom AtomLeast_;
#define AtomLeast Yap_heap_regs->AtomLeast_
#define TermLeast MkAtomTerm( Yap_heap_regs->AtomLeast_ )
  Atom AtomLength_;
#define AtomLength Yap_heap_regs->AtomLength_
#define TermLength MkAtomTerm( Yap_heap_regs->AtomLength_ )
  Atom AtomList_;
#define AtomList Yap_heap_regs->AtomList_
#define TermList MkAtomTerm( Yap_heap_regs->AtomList_ )
  Atom AtomLine_;
#define AtomLine Yap_heap_regs->AtomLine_
#define TermLine MkAtomTerm( Yap_heap_regs->AtomLine_ )
  Atom AtomLive_;
#define AtomLive Yap_heap_regs->AtomLive_
#define TermLive MkAtomTerm( Yap_heap_regs->AtomLive_ )
  Atom AtomLoadAnswers_;
#define AtomLoadAnswers Yap_heap_regs->AtomLoadAnswers_
#define TermLoadAnswers MkAtomTerm( Yap_heap_regs->AtomLoadAnswers_ )
  Atom AtomLocal_;
#define AtomLocal Yap_heap_regs->AtomLocal_
#define TermLocal MkAtomTerm( Yap_heap_regs->AtomLocal_ )
  Atom AtomLocalSp_;
#define AtomLocalSp Yap_heap_regs->AtomLocalSp_
#define TermLocalSp MkAtomTerm( Yap_heap_regs->AtomLocalSp_ )
  Atom AtomLocalTrie_;
#define AtomLocalTrie Yap_heap_regs->AtomLocalTrie_
#define TermLocalTrie MkAtomTerm( Yap_heap_regs->AtomLocalTrie_ )
  Atom AtomMax_;
#define AtomMax Yap_heap_regs->AtomMax_
#define TermMax MkAtomTerm( Yap_heap_regs->AtomMax_ )
  Atom AtomMaximum_;
#define AtomMaximum Yap_heap_regs->AtomMaximum_
#define TermMaximum MkAtomTerm( Yap_heap_regs->AtomMaximum_ )
  Atom AtomMaxArity_;
#define AtomMaxArity Yap_heap_regs->AtomMaxArity_
#define TermMaxArity MkAtomTerm( Yap_heap_regs->AtomMaxArity_ )
  Atom AtomMaxFiles_;
#define AtomMaxFiles Yap_heap_regs->AtomMaxFiles_
#define TermMaxFiles MkAtomTerm( Yap_heap_regs->AtomMaxFiles_ )
  Atom AtomMegaClause_;
#define AtomMegaClause Yap_heap_regs->AtomMegaClause_
#define TermMegaClause MkAtomTerm( Yap_heap_regs->AtomMegaClause_ )
  Atom AtomMetaCall_;
#define AtomMetaCall Yap_heap_regs->AtomMetaCall_
#define TermMetaCall MkAtomTerm( Yap_heap_regs->AtomMetaCall_ )
  Atom AtomMfClause_;
#define AtomMfClause Yap_heap_regs->AtomMfClause_
#define TermMfClause MkAtomTerm( Yap_heap_regs->AtomMfClause_ )
  Atom AtomMin_;
#define AtomMin Yap_heap_regs->AtomMin_
#define TermMin MkAtomTerm( Yap_heap_regs->AtomMin_ )
  Atom AtomMinimum_;
#define AtomMinimum Yap_heap_regs->AtomMinimum_
#define TermMinimum MkAtomTerm( Yap_heap_regs->AtomMinimum_ )
  Atom AtomMinus_;
#define AtomMinus Yap_heap_regs->AtomMinus_
#define TermMinus MkAtomTerm( Yap_heap_regs->AtomMinus_ )
  Atom AtomModify_;
#define AtomModify Yap_heap_regs->AtomModify_
#define TermModify MkAtomTerm( Yap_heap_regs->AtomModify_ )
  Atom AtomModule_;
#define AtomModule Yap_heap_regs->AtomModule_
#define TermModule MkAtomTerm( Yap_heap_regs->AtomModule_ )
  Atom AtomMost_;
#define AtomMost Yap_heap_regs->AtomMost_
#define TermMost MkAtomTerm( Yap_heap_regs->AtomMost_ )
  Atom AtomMulti_;
#define AtomMulti Yap_heap_regs->AtomMulti_
#define TermMulti MkAtomTerm( Yap_heap_regs->AtomMulti_ )
  Atom AtomMultiFile_;
#define AtomMultiFile Yap_heap_regs->AtomMultiFile_
#define TermMultiFile MkAtomTerm( Yap_heap_regs->AtomMultiFile_ )
  Atom AtomMultiple_;
#define AtomMultiple Yap_heap_regs->AtomMultiple_
#define TermMultiple MkAtomTerm( Yap_heap_regs->AtomMultiple_ )
  Atom AtomMutable_;
#define AtomMutable Yap_heap_regs->AtomMutable_
#define TermMutable MkAtomTerm( Yap_heap_regs->AtomMutable_ )
  Atom AtomMutableVariable_;
#define AtomMutableVariable Yap_heap_regs->AtomMutableVariable_
#define TermMutableVariable MkAtomTerm( Yap_heap_regs->AtomMutableVariable_ )
  Atom AtomMutex_;
#define AtomMutex Yap_heap_regs->AtomMutex_
#define TermMutex MkAtomTerm( Yap_heap_regs->AtomMutex_ )
  Atom AtomMyddasDB_;
#define AtomMyddasDB Yap_heap_regs->AtomMyddasDB_
#define TermMyddasDB MkAtomTerm( Yap_heap_regs->AtomMyddasDB_ )
  Atom AtomMyddasGoal_;
#define AtomMyddasGoal Yap_heap_regs->AtomMyddasGoal_
#define TermMyddasGoal MkAtomTerm( Yap_heap_regs->AtomMyddasGoal_ )
  Atom AtomMyddasHost_;
#define AtomMyddasHost Yap_heap_regs->AtomMyddasHost_
#define TermMyddasHost MkAtomTerm( Yap_heap_regs->AtomMyddasHost_ )
  Atom AtomMyddasPass_;
#define AtomMyddasPass Yap_heap_regs->AtomMyddasPass_
#define TermMyddasPass MkAtomTerm( Yap_heap_regs->AtomMyddasPass_ )
  Atom AtomMyddasUser_;
#define AtomMyddasUser Yap_heap_regs->AtomMyddasUser_
#define TermMyddasUser MkAtomTerm( Yap_heap_regs->AtomMyddasUser_ )
  Atom AtomMyddasVersionName_;
#define AtomMyddasVersionName Yap_heap_regs->AtomMyddasVersionName_
#define TermMyddasVersionName MkAtomTerm( Yap_heap_regs->AtomMyddasVersionName_ )
  Atom AtomNan_;
#define AtomNan Yap_heap_regs->AtomNan_
#define TermNan MkAtomTerm( Yap_heap_regs->AtomNan_ )
  Atom AtomNb_;
#define AtomNb Yap_heap_regs->AtomNb_
#define TermNb MkAtomTerm( Yap_heap_regs->AtomNb_ )
  Atom AtomNbTerm_;
#define AtomNbTerm Yap_heap_regs->AtomNbTerm_
#define TermNbTerm MkAtomTerm( Yap_heap_regs->AtomNbTerm_ )
  Atom AtomNew_;
#define AtomNew Yap_heap_regs->AtomNew_
#define TermNew MkAtomTerm( Yap_heap_regs->AtomNew_ )
  Atom AtomNewLine_;
#define AtomNewLine Yap_heap_regs->AtomNewLine_
#define TermNewLine MkAtomTerm( Yap_heap_regs->AtomNewLine_ )
  Atom AtomNl_;
#define AtomNl Yap_heap_regs->AtomNl_
#define TermNl MkAtomTerm( Yap_heap_regs->AtomNl_ )
  Atom AtomNoEffect_;
#define AtomNoEffect Yap_heap_regs->AtomNoEffect_
#define TermNoEffect MkAtomTerm( Yap_heap_regs->AtomNoEffect_ )
  Atom AtomNoMemory_;
#define AtomNoMemory Yap_heap_regs->AtomNoMemory_
#define TermNoMemory MkAtomTerm( Yap_heap_regs->AtomNoMemory_ )
  Atom AtomNone_;
#define AtomNone Yap_heap_regs->AtomNone_
#define TermNone MkAtomTerm( Yap_heap_regs->AtomNone_ )
  Atom AtomNonEmptyList_;
#define AtomNonEmptyList Yap_heap_regs->AtomNonEmptyList_
#define TermNonEmptyList MkAtomTerm( Yap_heap_regs->AtomNonEmptyList_ )
  Atom AtomNot_;
#define AtomNot Yap_heap_regs->AtomNot_
#define TermNot MkAtomTerm( Yap_heap_regs->AtomNot_ )
  Atom AtomNotImplemented_;
#define AtomNotImplemented Yap_heap_regs->AtomNotImplemented_
#define TermNotImplemented MkAtomTerm( Yap_heap_regs->AtomNotImplemented_ )
  Atom AtomNotLessThanZero_;
#define AtomNotLessThanZero Yap_heap_regs->AtomNotLessThanZero_
#define TermNotLessThanZero MkAtomTerm( Yap_heap_regs->AtomNotLessThanZero_ )
  Atom AtomNotNewline_;
#define AtomNotNewline Yap_heap_regs->AtomNotNewline_
#define TermNotNewline MkAtomTerm( Yap_heap_regs->AtomNotNewline_ )
  Atom AtomNotZero_;
#define AtomNotZero Yap_heap_regs->AtomNotZero_
#define TermNotZero MkAtomTerm( Yap_heap_regs->AtomNotZero_ )
  Atom AtomNumber_;
#define AtomNumber Yap_heap_regs->AtomNumber_
#define TermNumber MkAtomTerm( Yap_heap_regs->AtomNumber_ )
  Atom AtomOff_;
#define AtomOff Yap_heap_regs->AtomOff_
#define TermOff MkAtomTerm( Yap_heap_regs->AtomOff_ )
  Atom AtomOffline_;
#define AtomOffline Yap_heap_regs->AtomOffline_
#define TermOffline MkAtomTerm( Yap_heap_regs->AtomOffline_ )
  Atom AtomOn_;
#define AtomOn Yap_heap_regs->AtomOn_
#define TermOn MkAtomTerm( Yap_heap_regs->AtomOn_ )
  Atom AtomOnline_;
#define AtomOnline Yap_heap_regs->AtomOnline_
#define TermOnline MkAtomTerm( Yap_heap_regs->AtomOnline_ )
  Atom AtomOpen_;
#define AtomOpen Yap_heap_regs->AtomOpen_
#define TermOpen MkAtomTerm( Yap_heap_regs->AtomOpen_ )
  Atom AtomOperatingSystemError_;
#define AtomOperatingSystemError Yap_heap_regs->AtomOperatingSystemError_
#define TermOperatingSystemError MkAtomTerm( Yap_heap_regs->AtomOperatingSystemError_ )
  Atom AtomOperatingSystemSupport_;
#define AtomOperatingSystemSupport Yap_heap_regs->AtomOperatingSystemSupport_
#define TermOperatingSystemSupport MkAtomTerm( Yap_heap_regs->AtomOperatingSystemSupport_ )
  Atom AtomOperator_;
#define AtomOperator Yap_heap_regs->AtomOperator_
#define TermOperator MkAtomTerm( Yap_heap_regs->AtomOperator_ )
  Atom AtomOperatorPriority_;
#define AtomOperatorPriority Yap_heap_regs->AtomOperatorPriority_
#define TermOperatorPriority MkAtomTerm( Yap_heap_regs->AtomOperatorPriority_ )
  Atom AtomOperatorSpecifier_;
#define AtomOperatorSpecifier Yap_heap_regs->AtomOperatorSpecifier_
#define TermOperatorSpecifier MkAtomTerm( Yap_heap_regs->AtomOperatorSpecifier_ )
  Atom AtomOpt_;
#define AtomOpt Yap_heap_regs->AtomOpt_
#define TermOpt MkAtomTerm( Yap_heap_regs->AtomOpt_ )
  Atom AtomOtherwise_;
#define AtomOtherwise Yap_heap_regs->AtomOtherwise_
#define TermOtherwise MkAtomTerm( Yap_heap_regs->AtomOtherwise_ )
  Atom AtomOutOfAttvarsError_;
#define AtomOutOfAttvarsError Yap_heap_regs->AtomOutOfAttvarsError_
#define TermOutOfAttvarsError MkAtomTerm( Yap_heap_regs->AtomOutOfAttvarsError_ )
  Atom AtomOutOfAuxspaceError_;
#define AtomOutOfAuxspaceError Yap_heap_regs->AtomOutOfAuxspaceError_
#define TermOutOfAuxspaceError MkAtomTerm( Yap_heap_regs->AtomOutOfAuxspaceError_ )
  Atom AtomOutOfHeapError_;
#define AtomOutOfHeapError Yap_heap_regs->AtomOutOfHeapError_
#define TermOutOfHeapError MkAtomTerm( Yap_heap_regs->AtomOutOfHeapError_ )
  Atom AtomOutOfRange_;
#define AtomOutOfRange Yap_heap_regs->AtomOutOfRange_
#define TermOutOfRange MkAtomTerm( Yap_heap_regs->AtomOutOfRange_ )
  Atom AtomOutOfStackError_;
#define AtomOutOfStackError Yap_heap_regs->AtomOutOfStackError_
#define TermOutOfStackError MkAtomTerm( Yap_heap_regs->AtomOutOfStackError_ )
  Atom AtomOutOfTrailError_;
#define AtomOutOfTrailError Yap_heap_regs->AtomOutOfTrailError_
#define TermOutOfTrailError MkAtomTerm( Yap_heap_regs->AtomOutOfTrailError_ )
  Atom AtomOutput_;
#define AtomOutput Yap_heap_regs->AtomOutput_
#define TermOutput MkAtomTerm( Yap_heap_regs->AtomOutput_ )
  Atom AtomParameter_;
#define AtomParameter Yap_heap_regs->AtomParameter_
#define TermParameter MkAtomTerm( Yap_heap_regs->AtomParameter_ )
  Atom AtomPrologCommonsDir_;
#define AtomPrologCommonsDir Yap_heap_regs->AtomPrologCommonsDir_
#define TermPrologCommonsDir MkAtomTerm( Yap_heap_regs->AtomPrologCommonsDir_ )
  Atom AtomPast_;
#define AtomPast Yap_heap_regs->AtomPast_
#define TermPast MkAtomTerm( Yap_heap_regs->AtomPast_ )
  Atom AtomPastEndOfStream_;
#define AtomPastEndOfStream Yap_heap_regs->AtomPastEndOfStream_
#define TermPastEndOfStream MkAtomTerm( Yap_heap_regs->AtomPastEndOfStream_ )
  Atom AtomPermissionError_;
#define AtomPermissionError Yap_heap_regs->AtomPermissionError_
#define TermPermissionError MkAtomTerm( Yap_heap_regs->AtomPermissionError_ )
  Atom AtomPi_;
#define AtomPi Yap_heap_regs->AtomPi_
#define TermPi MkAtomTerm( Yap_heap_regs->AtomPi_ )
  Atom AtomPipe_;
#define AtomPipe Yap_heap_regs->AtomPipe_
#define TermPipe MkAtomTerm( Yap_heap_regs->AtomPipe_ )
  Atom AtomPlus_;
#define AtomPlus Yap_heap_regs->AtomPlus_
#define TermPlus MkAtomTerm( Yap_heap_regs->AtomPlus_ )
  Atom AtomPointer_;
#define AtomPointer Yap_heap_regs->AtomPointer_
#define TermPointer MkAtomTerm( Yap_heap_regs->AtomPointer_ )
  Atom AtomPortray_;
#define AtomPortray Yap_heap_regs->AtomPortray_
#define TermPortray MkAtomTerm( Yap_heap_regs->AtomPortray_ )
  Atom AtomPredicateIndicator_;
#define AtomPredicateIndicator Yap_heap_regs->AtomPredicateIndicator_
#define TermPredicateIndicator MkAtomTerm( Yap_heap_regs->AtomPredicateIndicator_ )
  Atom AtomPrimitive_;
#define AtomPrimitive Yap_heap_regs->AtomPrimitive_
#define TermPrimitive MkAtomTerm( Yap_heap_regs->AtomPrimitive_ )
  Atom AtomPrintMessage_;
#define AtomPrintMessage Yap_heap_regs->AtomPrintMessage_
#define TermPrintMessage MkAtomTerm( Yap_heap_regs->AtomPrintMessage_ )
  Atom AtomPrivateProcedure_;
#define AtomPrivateProcedure Yap_heap_regs->AtomPrivateProcedure_
#define TermPrivateProcedure MkAtomTerm( Yap_heap_regs->AtomPrivateProcedure_ )
  Atom AtomProcedure_;
#define AtomProcedure Yap_heap_regs->AtomProcedure_
#define TermProcedure MkAtomTerm( Yap_heap_regs->AtomProcedure_ )
  Atom AtomProfile_;
#define AtomProfile Yap_heap_regs->AtomProfile_
#define TermProfile MkAtomTerm( Yap_heap_regs->AtomProfile_ )
  Atom AtomProlog_;
#define AtomProlog Yap_heap_regs->AtomProlog_
#define TermProlog MkAtomTerm( Yap_heap_regs->AtomProlog_ )
  Atom AtomQly_;
#define AtomQly Yap_heap_regs->AtomQly_
#define TermQly MkAtomTerm( Yap_heap_regs->AtomQly_ )
  Atom AtomQuery_;
#define AtomQuery Yap_heap_regs->AtomQuery_
#define TermQuery MkAtomTerm( Yap_heap_regs->AtomQuery_ )
  Atom AtomQueue_;
#define AtomQueue Yap_heap_regs->AtomQueue_
#define TermQueue MkAtomTerm( Yap_heap_regs->AtomQueue_ )
  Atom AtomQuiet_;
#define AtomQuiet Yap_heap_regs->AtomQuiet_
#define TermQuiet MkAtomTerm( Yap_heap_regs->AtomQuiet_ )
  Atom AtomRadix_;
#define AtomRadix Yap_heap_regs->AtomRadix_
#define TermRadix MkAtomTerm( Yap_heap_regs->AtomRadix_ )
  Atom AtomRandom_;
#define AtomRandom Yap_heap_regs->AtomRandom_
#define TermRandom MkAtomTerm( Yap_heap_regs->AtomRandom_ )
  Atom AtomRange_;
#define AtomRange Yap_heap_regs->AtomRange_
#define TermRange MkAtomTerm( Yap_heap_regs->AtomRange_ )
  Atom AtomRDiv_;
#define AtomRDiv Yap_heap_regs->AtomRDiv_
#define TermRDiv MkAtomTerm( Yap_heap_regs->AtomRDiv_ )
  Atom AtomRead_;
#define AtomRead Yap_heap_regs->AtomRead_
#define TermRead MkAtomTerm( Yap_heap_regs->AtomRead_ )
  Atom AtomReadOnly_;
#define AtomReadOnly Yap_heap_regs->AtomReadOnly_
#define TermReadOnly MkAtomTerm( Yap_heap_regs->AtomReadOnly_ )
  Atom AtomReadWrite_;
#define AtomReadWrite Yap_heap_regs->AtomReadWrite_
#define TermReadWrite MkAtomTerm( Yap_heap_regs->AtomReadWrite_ )
  Atom AtomReadutil_;
#define AtomReadutil Yap_heap_regs->AtomReadutil_
#define TermReadutil MkAtomTerm( Yap_heap_regs->AtomReadutil_ )
  Atom AtomReconsult_;
#define AtomReconsult Yap_heap_regs->AtomReconsult_
#define TermReconsult MkAtomTerm( Yap_heap_regs->AtomReconsult_ )
  Atom AtomRecordedP_;
#define AtomRecordedP Yap_heap_regs->AtomRecordedP_
#define TermRecordedP MkAtomTerm( Yap_heap_regs->AtomRecordedP_ )
  Atom AtomRecordedWithKey_;
#define AtomRecordedWithKey Yap_heap_regs->AtomRecordedWithKey_
#define TermRecordedWithKey MkAtomTerm( Yap_heap_regs->AtomRecordedWithKey_ )
  Atom AtomRedefineWarnings_;
#define AtomRedefineWarnings Yap_heap_regs->AtomRedefineWarnings_
#define TermRedefineWarnings MkAtomTerm( Yap_heap_regs->AtomRedefineWarnings_ )
  Atom AtomRedoFreeze_;
#define AtomRedoFreeze Yap_heap_regs->AtomRedoFreeze_
#define TermRedoFreeze MkAtomTerm( Yap_heap_regs->AtomRedoFreeze_ )
  Atom AtomRefoundVar_;
#define AtomRefoundVar Yap_heap_regs->AtomRefoundVar_
#define TermRefoundVar MkAtomTerm( Yap_heap_regs->AtomRefoundVar_ )
  Atom AtomRelativeTo_;
#define AtomRelativeTo Yap_heap_regs->AtomRelativeTo_
#define TermRelativeTo MkAtomTerm( Yap_heap_regs->AtomRelativeTo_ )
  Atom AtomRepeat_;
#define AtomRepeat Yap_heap_regs->AtomRepeat_
#define TermRepeat MkAtomTerm( Yap_heap_regs->AtomRepeat_ )
  Atom AtomRepeatSpace_;
#define AtomRepeatSpace Yap_heap_regs->AtomRepeatSpace_
#define TermRepeatSpace MkAtomTerm( Yap_heap_regs->AtomRepeatSpace_ )
  Atom AtomReposition_;
#define AtomReposition Yap_heap_regs->AtomReposition_
#define TermReposition MkAtomTerm( Yap_heap_regs->AtomReposition_ )
  Atom AtomRepresentationError_;
#define AtomRepresentationError Yap_heap_regs->AtomRepresentationError_
#define TermRepresentationError MkAtomTerm( Yap_heap_regs->AtomRepresentationError_ )
  Atom AtomReset_;
#define AtomReset Yap_heap_regs->AtomReset_
#define TermReset MkAtomTerm( Yap_heap_regs->AtomReset_ )
  Atom AtomResize_;
#define AtomResize Yap_heap_regs->AtomResize_
#define TermResize MkAtomTerm( Yap_heap_regs->AtomResize_ )
  Atom AtomResourceError_;
#define AtomResourceError Yap_heap_regs->AtomResourceError_
#define TermResourceError MkAtomTerm( Yap_heap_regs->AtomResourceError_ )
  Atom AtomRestoreRegs_;
#define AtomRestoreRegs Yap_heap_regs->AtomRestoreRegs_
#define TermRestoreRegs MkAtomTerm( Yap_heap_regs->AtomRestoreRegs_ )
  Atom AtomRetryCounter_;
#define AtomRetryCounter Yap_heap_regs->AtomRetryCounter_
#define TermRetryCounter MkAtomTerm( Yap_heap_regs->AtomRetryCounter_ )
  Atom AtomRTree_;
#define AtomRTree Yap_heap_regs->AtomRTree_
#define TermRTree MkAtomTerm( Yap_heap_regs->AtomRTree_ )
  Atom AtomSafe_;
#define AtomSafe Yap_heap_regs->AtomSafe_
#define TermSafe MkAtomTerm( Yap_heap_regs->AtomSafe_ )
  Atom AtomSafeCallCleanup_;
#define AtomSafeCallCleanup Yap_heap_regs->AtomSafeCallCleanup_
#define TermSafeCallCleanup MkAtomTerm( Yap_heap_regs->AtomSafeCallCleanup_ )
  Atom AtomSame_;
#define AtomSame Yap_heap_regs->AtomSame_
#define TermSame MkAtomTerm( Yap_heap_regs->AtomSame_ )
  Atom AtomSemic_;
#define AtomSemic Yap_heap_regs->AtomSemic_
#define TermSemic MkAtomTerm( Yap_heap_regs->AtomSemic_ )
  Atom AtomShiftCountOverflow_;
#define AtomShiftCountOverflow Yap_heap_regs->AtomShiftCountOverflow_
#define TermShiftCountOverflow MkAtomTerm( Yap_heap_regs->AtomShiftCountOverflow_ )
  Atom AtomSigAlarm_;
#define AtomSigAlarm Yap_heap_regs->AtomSigAlarm_
#define TermSigAlarm MkAtomTerm( Yap_heap_regs->AtomSigAlarm_ )
  Atom AtomSigBreak_;
#define AtomSigBreak Yap_heap_regs->AtomSigBreak_
#define TermSigBreak MkAtomTerm( Yap_heap_regs->AtomSigBreak_ )
  Atom AtomSigCreep_;
#define AtomSigCreep Yap_heap_regs->AtomSigCreep_
#define TermSigCreep MkAtomTerm( Yap_heap_regs->AtomSigCreep_ )
  Atom AtomSigDebug_;
#define AtomSigDebug Yap_heap_regs->AtomSigDebug_
#define TermSigDebug MkAtomTerm( Yap_heap_regs->AtomSigDebug_ )
  Atom AtomSigDelayCreep_;
#define AtomSigDelayCreep Yap_heap_regs->AtomSigDelayCreep_
#define TermSigDelayCreep MkAtomTerm( Yap_heap_regs->AtomSigDelayCreep_ )
  Atom AtomSigFPE_;
#define AtomSigFPE Yap_heap_regs->AtomSigFPE_
#define TermSigFPE MkAtomTerm( Yap_heap_regs->AtomSigFPE_ )
  Atom AtomSigHup_;
#define AtomSigHup Yap_heap_regs->AtomSigHup_
#define TermSigHup MkAtomTerm( Yap_heap_regs->AtomSigHup_ )
  Atom AtomSigInt_;
#define AtomSigInt Yap_heap_regs->AtomSigInt_
#define TermSigInt MkAtomTerm( Yap_heap_regs->AtomSigInt_ )
  Atom AtomSigIti_;
#define AtomSigIti Yap_heap_regs->AtomSigIti_
#define TermSigIti MkAtomTerm( Yap_heap_regs->AtomSigIti_ )
  Atom AtomSigPending_;
#define AtomSigPending Yap_heap_regs->AtomSigPending_
#define TermSigPending MkAtomTerm( Yap_heap_regs->AtomSigPending_ )
  Atom AtomSigPipe_;
#define AtomSigPipe Yap_heap_regs->AtomSigPipe_
#define TermSigPipe MkAtomTerm( Yap_heap_regs->AtomSigPipe_ )
  Atom AtomSigStackDump_;
#define AtomSigStackDump Yap_heap_regs->AtomSigStackDump_
#define TermSigStackDump MkAtomTerm( Yap_heap_regs->AtomSigStackDump_ )
  Atom AtomSigStatistics_;
#define AtomSigStatistics Yap_heap_regs->AtomSigStatistics_
#define TermSigStatistics MkAtomTerm( Yap_heap_regs->AtomSigStatistics_ )
  Atom AtomSigTrace_;
#define AtomSigTrace Yap_heap_regs->AtomSigTrace_
#define TermSigTrace MkAtomTerm( Yap_heap_regs->AtomSigTrace_ )
  Atom AtomSigUsr1_;
#define AtomSigUsr1 Yap_heap_regs->AtomSigUsr1_
#define TermSigUsr1 MkAtomTerm( Yap_heap_regs->AtomSigUsr1_ )
  Atom AtomSigUsr2_;
#define AtomSigUsr2 Yap_heap_regs->AtomSigUsr2_
#define TermSigUsr2 MkAtomTerm( Yap_heap_regs->AtomSigUsr2_ )
  Atom AtomSigVTAlarm_;
#define AtomSigVTAlarm Yap_heap_regs->AtomSigVTAlarm_
#define TermSigVTAlarm MkAtomTerm( Yap_heap_regs->AtomSigVTAlarm_ )
  Atom AtomSigWakeUp_;
#define AtomSigWakeUp Yap_heap_regs->AtomSigWakeUp_
#define TermSigWakeUp MkAtomTerm( Yap_heap_regs->AtomSigWakeUp_ )
  Atom AtomSilent_;
#define AtomSilent Yap_heap_regs->AtomSilent_
#define TermSilent MkAtomTerm( Yap_heap_regs->AtomSilent_ )
  Atom AtomSingle_;
#define AtomSingle Yap_heap_regs->AtomSingle_
#define TermSingle MkAtomTerm( Yap_heap_regs->AtomSingle_ )
  Atom AtomSingleVarWarnings_;
#define AtomSingleVarWarnings Yap_heap_regs->AtomSingleVarWarnings_
#define TermSingleVarWarnings MkAtomTerm( Yap_heap_regs->AtomSingleVarWarnings_ )
  Atom AtomSingleton_;
#define AtomSingleton Yap_heap_regs->AtomSingleton_
#define TermSingleton MkAtomTerm( Yap_heap_regs->AtomSingleton_ )
  Atom AtomSlash_;
#define AtomSlash Yap_heap_regs->AtomSlash_
#define TermSlash MkAtomTerm( Yap_heap_regs->AtomSlash_ )
  Atom AtomSocket_;
#define AtomSocket Yap_heap_regs->AtomSocket_
#define TermSocket MkAtomTerm( Yap_heap_regs->AtomSocket_ )
  Atom AtomSolutions_;
#define AtomSolutions Yap_heap_regs->AtomSolutions_
#define TermSolutions MkAtomTerm( Yap_heap_regs->AtomSolutions_ )
  Atom AtomSource_;
#define AtomSource Yap_heap_regs->AtomSource_
#define TermSource MkAtomTerm( Yap_heap_regs->AtomSource_ )
  Atom AtomSourceSink_;
#define AtomSourceSink Yap_heap_regs->AtomSourceSink_
#define TermSourceSink MkAtomTerm( Yap_heap_regs->AtomSourceSink_ )
  Atom AtomSpy_;
#define AtomSpy Yap_heap_regs->AtomSpy_
#define TermSpy MkAtomTerm( Yap_heap_regs->AtomSpy_ )
  Atom AtomStack_;
#define AtomStack Yap_heap_regs->AtomStack_
#define TermStack MkAtomTerm( Yap_heap_regs->AtomStack_ )
  Atom AtomStackFree_;
#define AtomStackFree Yap_heap_regs->AtomStackFree_
#define TermStackFree MkAtomTerm( Yap_heap_regs->AtomStackFree_ )
  Atom AtomStartupSavedState_;
#define AtomStartupSavedState Yap_heap_regs->AtomStartupSavedState_
#define TermStartupSavedState MkAtomTerm( Yap_heap_regs->AtomStartupSavedState_ )
  Atom AtomStaticClause_;
#define AtomStaticClause Yap_heap_regs->AtomStaticClause_
#define TermStaticClause MkAtomTerm( Yap_heap_regs->AtomStaticClause_ )
  Atom AtomStaticProcedure_;
#define AtomStaticProcedure Yap_heap_regs->AtomStaticProcedure_
#define TermStaticProcedure MkAtomTerm( Yap_heap_regs->AtomStaticProcedure_ )
  Atom AtomStream_;
#define AtomStream Yap_heap_regs->AtomStream_
#define TermStream MkAtomTerm( Yap_heap_regs->AtomStream_ )
  Atom AtomSWIStream_;
#define AtomSWIStream Yap_heap_regs->AtomSWIStream_
#define TermSWIStream MkAtomTerm( Yap_heap_regs->AtomSWIStream_ )
  Atom AtomVStream_;
#define AtomVStream Yap_heap_regs->AtomVStream_
#define TermVStream MkAtomTerm( Yap_heap_regs->AtomVStream_ )
  Atom AtomStreams_;
#define AtomStreams Yap_heap_regs->AtomStreams_
#define TermStreams MkAtomTerm( Yap_heap_regs->AtomStreams_ )
  Atom AtomStreamOrAlias_;
#define AtomStreamOrAlias Yap_heap_regs->AtomStreamOrAlias_
#define TermStreamOrAlias MkAtomTerm( Yap_heap_regs->AtomStreamOrAlias_ )
  Atom AtomStreamPos_;
#define AtomStreamPos Yap_heap_regs->AtomStreamPos_
#define TermStreamPos MkAtomTerm( Yap_heap_regs->AtomStreamPos_ )
  Atom AtomStreamPosition_;
#define AtomStreamPosition Yap_heap_regs->AtomStreamPosition_
#define TermStreamPosition MkAtomTerm( Yap_heap_regs->AtomStreamPosition_ )
  Atom AtomString_;
#define AtomString Yap_heap_regs->AtomString_
#define TermString MkAtomTerm( Yap_heap_regs->AtomString_ )
  Atom AtomStyleCheck_;
#define AtomStyleCheck Yap_heap_regs->AtomStyleCheck_
#define TermStyleCheck MkAtomTerm( Yap_heap_regs->AtomStyleCheck_ )
  Atom AtomSTRING_;
#define AtomSTRING Yap_heap_regs->AtomSTRING_
#define TermSTRING MkAtomTerm( Yap_heap_regs->AtomSTRING_ )
  Atom AtomSwi_;
#define AtomSwi Yap_heap_regs->AtomSwi_
#define TermSwi MkAtomTerm( Yap_heap_regs->AtomSwi_ )
  Atom AtomSymbolChar_;
#define AtomSymbolChar Yap_heap_regs->AtomSymbolChar_
#define TermSymbolChar MkAtomTerm( Yap_heap_regs->AtomSymbolChar_ )
  Atom AtomSyntaxError_;
#define AtomSyntaxError Yap_heap_regs->AtomSyntaxError_
#define TermSyntaxError MkAtomTerm( Yap_heap_regs->AtomSyntaxError_ )
  Atom AtomSyntaxErrors_;
#define AtomSyntaxErrors Yap_heap_regs->AtomSyntaxErrors_
#define TermSyntaxErrors MkAtomTerm( Yap_heap_regs->AtomSyntaxErrors_ )
  Atom AtomSyntaxErrorHandler_;
#define AtomSyntaxErrorHandler Yap_heap_regs->AtomSyntaxErrorHandler_
#define TermSyntaxErrorHandler MkAtomTerm( Yap_heap_regs->AtomSyntaxErrorHandler_ )
  Atom AtomSystem_;
#define AtomSystem Yap_heap_regs->AtomSystem_
#define TermSystem MkAtomTerm( Yap_heap_regs->AtomSystem_ )
  Atom AtomSystemError_;
#define AtomSystemError Yap_heap_regs->AtomSystemError_
#define TermSystemError MkAtomTerm( Yap_heap_regs->AtomSystemError_ )
  Atom AtomSystemLibraryDir_;
#define AtomSystemLibraryDir Yap_heap_regs->AtomSystemLibraryDir_
#define TermSystemLibraryDir MkAtomTerm( Yap_heap_regs->AtomSystemLibraryDir_ )
  Atom AtomTerm_;
#define AtomTerm Yap_heap_regs->AtomTerm_
#define TermTerm MkAtomTerm( Yap_heap_regs->AtomTerm_ )
  Atom AtomTerms_;
#define AtomTerms Yap_heap_regs->AtomTerms_
#define TermTerms MkAtomTerm( Yap_heap_regs->AtomTerms_ )
  Atom AtomTermExpansion_;
#define AtomTermExpansion Yap_heap_regs->AtomTermExpansion_
#define TermTermExpansion MkAtomTerm( Yap_heap_regs->AtomTermExpansion_ )
  Atom AtomText_;
#define AtomText Yap_heap_regs->AtomText_
#define TermText MkAtomTerm( Yap_heap_regs->AtomText_ )
  Atom AtomTextStream_;
#define AtomTextStream Yap_heap_regs->AtomTextStream_
#define TermTextStream MkAtomTerm( Yap_heap_regs->AtomTextStream_ )
  Atom AtomThread_;
#define AtomThread Yap_heap_regs->AtomThread_
#define TermThread MkAtomTerm( Yap_heap_regs->AtomThread_ )
  Atom AtomThreads_;
#define AtomThreads Yap_heap_regs->AtomThreads_
#define TermThreads MkAtomTerm( Yap_heap_regs->AtomThreads_ )
  Atom AtomThrow_;
#define AtomThrow Yap_heap_regs->AtomThrow_
#define TermThrow MkAtomTerm( Yap_heap_regs->AtomThrow_ )
  Atom AtomTimeOutSpec_;
#define AtomTimeOutSpec Yap_heap_regs->AtomTimeOutSpec_
#define TermTimeOutSpec MkAtomTerm( Yap_heap_regs->AtomTimeOutSpec_ )
  Atom AtomTimeoutError_;
#define AtomTimeoutError Yap_heap_regs->AtomTimeoutError_
#define TermTimeoutError MkAtomTerm( Yap_heap_regs->AtomTimeoutError_ )
  Atom AtomTopLevelGoal_;
#define AtomTopLevelGoal Yap_heap_regs->AtomTopLevelGoal_
#define TermTopLevelGoal MkAtomTerm( Yap_heap_regs->AtomTopLevelGoal_ )
  Atom AtomTopThreadGoal_;
#define AtomTopThreadGoal Yap_heap_regs->AtomTopThreadGoal_
#define TermTopThreadGoal MkAtomTerm( Yap_heap_regs->AtomTopThreadGoal_ )
  Atom AtomTraceMetaCall_;
#define AtomTraceMetaCall Yap_heap_regs->AtomTraceMetaCall_
#define TermTraceMetaCall MkAtomTerm( Yap_heap_regs->AtomTraceMetaCall_ )
  Atom AtomTrail_;
#define AtomTrail Yap_heap_regs->AtomTrail_
#define TermTrail MkAtomTerm( Yap_heap_regs->AtomTrail_ )
  Atom AtomTrue_;
#define AtomTrue Yap_heap_regs->AtomTrue_
#define TermTrue MkAtomTerm( Yap_heap_regs->AtomTrue_ )
  Atom AtomTty_;
#define AtomTty Yap_heap_regs->AtomTty_
#define TermTty MkAtomTerm( Yap_heap_regs->AtomTty_ )
  Atom AtomTtys_;
#define AtomTtys Yap_heap_regs->AtomTtys_
#define TermTtys MkAtomTerm( Yap_heap_regs->AtomTtys_ )
  Atom AtomTxt_;
#define AtomTxt Yap_heap_regs->AtomTxt_
#define TermTxt MkAtomTerm( Yap_heap_regs->AtomTxt_ )
  Atom AtomTypeError_;
#define AtomTypeError Yap_heap_regs->AtomTypeError_
#define TermTypeError MkAtomTerm( Yap_heap_regs->AtomTypeError_ )
  Atom AtomUndefined_;
#define AtomUndefined Yap_heap_regs->AtomUndefined_
#define TermUndefined MkAtomTerm( Yap_heap_regs->AtomUndefined_ )
  Atom AtomUndefp_;
#define AtomUndefp Yap_heap_regs->AtomUndefp_
#define TermUndefp MkAtomTerm( Yap_heap_regs->AtomUndefp_ )
  Atom AtomUnderflow_;
#define AtomUnderflow Yap_heap_regs->AtomUnderflow_
#define TermUnderflow MkAtomTerm( Yap_heap_regs->AtomUnderflow_ )
  Atom AtomUnificationStack_;
#define AtomUnificationStack Yap_heap_regs->AtomUnificationStack_
#define TermUnificationStack MkAtomTerm( Yap_heap_regs->AtomUnificationStack_ )
  Atom AtomUnique_;
#define AtomUnique Yap_heap_regs->AtomUnique_
#define TermUnique MkAtomTerm( Yap_heap_regs->AtomUnique_ )
  Atom AtomUnsignedByte_;
#define AtomUnsignedByte Yap_heap_regs->AtomUnsignedByte_
#define TermUnsignedByte MkAtomTerm( Yap_heap_regs->AtomUnsignedByte_ )
  Atom AtomUnsignedChar_;
#define AtomUnsignedChar Yap_heap_regs->AtomUnsignedChar_
#define TermUnsignedChar MkAtomTerm( Yap_heap_regs->AtomUnsignedChar_ )
  Atom AtomUser_;
#define AtomUser Yap_heap_regs->AtomUser_
#define TermUser MkAtomTerm( Yap_heap_regs->AtomUser_ )
  Atom AtomUserErr_;
#define AtomUserErr Yap_heap_regs->AtomUserErr_
#define TermUserErr MkAtomTerm( Yap_heap_regs->AtomUserErr_ )
  Atom AtomUserIn_;
#define AtomUserIn Yap_heap_regs->AtomUserIn_
#define TermUserIn MkAtomTerm( Yap_heap_regs->AtomUserIn_ )
  Atom AtomUserOut_;
#define AtomUserOut Yap_heap_regs->AtomUserOut_
#define TermUserOut MkAtomTerm( Yap_heap_regs->AtomUserOut_ )
  Atom AtomDollarVar_;
#define AtomDollarVar Yap_heap_regs->AtomDollarVar_
#define TermDollarVar MkAtomTerm( Yap_heap_regs->AtomDollarVar_ )
  Atom AtomVBar_;
#define AtomVBar Yap_heap_regs->AtomVBar_
#define TermVBar MkAtomTerm( Yap_heap_regs->AtomVBar_ )
  Atom AtomVarBranches_;
#define AtomVarBranches Yap_heap_regs->AtomVarBranches_
#define TermVarBranches MkAtomTerm( Yap_heap_regs->AtomVarBranches_ )
  Atom AtomVariableNames_;
#define AtomVariableNames Yap_heap_regs->AtomVariableNames_
#define TermVariableNames MkAtomTerm( Yap_heap_regs->AtomVariableNames_ )
  Atom AtomHiddenVar_;
#define AtomHiddenVar Yap_heap_regs->AtomHiddenVar_
#define TermHiddenVar MkAtomTerm( Yap_heap_regs->AtomHiddenVar_ )
  Atom AtomVariable_;
#define AtomVariable Yap_heap_regs->AtomVariable_
#define TermVariable MkAtomTerm( Yap_heap_regs->AtomVariable_ )
  Atom AtomVerbose_;
#define AtomVerbose Yap_heap_regs->AtomVerbose_
#define TermVerbose MkAtomTerm( Yap_heap_regs->AtomVerbose_ )
  Atom AtomVerboseFileSearch_;
#define AtomVerboseFileSearch Yap_heap_regs->AtomVerboseFileSearch_
#define TermVerboseFileSearch MkAtomTerm( Yap_heap_regs->AtomVerboseFileSearch_ )
  Atom AtomVersionNumber_;
#define AtomVersionNumber Yap_heap_regs->AtomVersionNumber_
#define TermVersionNumber MkAtomTerm( Yap_heap_regs->AtomVersionNumber_ )
  Atom AtomVeryVerbose_;
#define AtomVeryVerbose Yap_heap_regs->AtomVeryVerbose_
#define TermVeryVerbose MkAtomTerm( Yap_heap_regs->AtomVeryVerbose_ )
  Atom AtomWakeUpGoal_;
#define AtomWakeUpGoal Yap_heap_regs->AtomWakeUpGoal_
#define TermWakeUpGoal MkAtomTerm( Yap_heap_regs->AtomWakeUpGoal_ )
  Atom AtomWarning_;
#define AtomWarning Yap_heap_regs->AtomWarning_
#define TermWarning MkAtomTerm( Yap_heap_regs->AtomWarning_ )
  Atom AtomWhen_;
#define AtomWhen Yap_heap_regs->AtomWhen_
#define TermWhen MkAtomTerm( Yap_heap_regs->AtomWhen_ )
  Atom AtomWrite_;
#define AtomWrite Yap_heap_regs->AtomWrite_
#define TermWrite MkAtomTerm( Yap_heap_regs->AtomWrite_ )
  Atom AtomXml_;
#define AtomXml Yap_heap_regs->AtomXml_
#define TermXml MkAtomTerm( Yap_heap_regs->AtomXml_ )
  Atom AtomYapHacks_;
#define AtomYapHacks Yap_heap_regs->AtomYapHacks_
#define TermYapHacks MkAtomTerm( Yap_heap_regs->AtomYapHacks_ )
  Atom AtomZeroDivisor_;
#define AtomZeroDivisor Yap_heap_regs->AtomZeroDivisor_
#define TermZeroDivisor MkAtomTerm( Yap_heap_regs->AtomZeroDivisor_ )
  Functor FunctorAfInet_;
#define FunctorAfInet Yap_heap_regs->FunctorAfInet_
  Functor FunctorAfLocal_;
#define FunctorAfLocal Yap_heap_regs->FunctorAfLocal_
  Functor FunctorAfUnix_;
#define FunctorAfUnix Yap_heap_regs->FunctorAfUnix_
  Functor FunctorAltNot_;
#define FunctorAltNot Yap_heap_regs->FunctorAltNot_
  Functor FunctorArg_;
#define FunctorArg Yap_heap_regs->FunctorArg_
  Functor FunctorArrayEntry_;
#define FunctorArrayEntry Yap_heap_regs->FunctorArrayEntry_
  Functor FunctorArrow_;
#define FunctorArrow Yap_heap_regs->FunctorArrow_
  Functor FunctorDoubleArrow_;
#define FunctorDoubleArrow Yap_heap_regs->FunctorDoubleArrow_
  Functor FunctorAssert1_;
#define FunctorAssert1 Yap_heap_regs->FunctorAssert1_
  Functor FunctorAssert_;
#define FunctorAssert Yap_heap_regs->FunctorAssert_
  Functor FunctorAtFoundOne_;
#define FunctorAtFoundOne Yap_heap_regs->FunctorAtFoundOne_
  Functor FunctorAtom_;
#define FunctorAtom Yap_heap_regs->FunctorAtom_
  Functor FunctorAtt1_;
#define FunctorAtt1 Yap_heap_regs->FunctorAtt1_
  Functor FunctorAttGoal_;
#define FunctorAttGoal Yap_heap_regs->FunctorAttGoal_
  Functor FunctorBraces_;
#define FunctorBraces Yap_heap_regs->FunctorBraces_
  Functor FunctorCall_;
#define FunctorCall Yap_heap_regs->FunctorCall_
  Functor FunctorCatch_;
#define FunctorCatch Yap_heap_regs->FunctorCatch_
  Functor FunctorChangeModule_;
#define FunctorChangeModule Yap_heap_regs->FunctorChangeModule_
  Functor FunctorChars_;
#define FunctorChars Yap_heap_regs->FunctorChars_
  Functor FunctorChars1_;
#define FunctorChars1 Yap_heap_regs->FunctorChars1_
  Functor FunctorCleanCall_;
#define FunctorCleanCall Yap_heap_regs->FunctorCleanCall_
  Functor FunctorClist_;
#define FunctorClist Yap_heap_regs->FunctorClist_
  Functor FunctorCodes_;
#define FunctorCodes Yap_heap_regs->FunctorCodes_
  Functor FunctorCodes1_;
#define FunctorCodes1 Yap_heap_regs->FunctorCodes1_
  Functor FunctorComma_;
#define FunctorComma Yap_heap_regs->FunctorComma_
  Functor FunctorCommentHook_;
#define FunctorCommentHook Yap_heap_regs->FunctorCommentHook_
  Functor FunctorContext2_;
#define FunctorContext2 Yap_heap_regs->FunctorContext2_
  Functor FunctorConsistencyError_;
#define FunctorConsistencyError Yap_heap_regs->FunctorConsistencyError_
  Functor FunctorCreep_;
#define FunctorCreep Yap_heap_regs->FunctorCreep_
  Functor FunctorCsult_;
#define FunctorCsult Yap_heap_regs->FunctorCsult_
  Functor FunctorCurrentModule_;
#define FunctorCurrentModule Yap_heap_regs->FunctorCurrentModule_
  Functor FunctorCutBy_;
#define FunctorCutBy Yap_heap_regs->FunctorCutBy_
  Functor FunctorDBREF_;
#define FunctorDBREF Yap_heap_regs->FunctorDBREF_
  Functor FunctorDiff_;
#define FunctorDiff Yap_heap_regs->FunctorDiff_
  Functor FunctorDoLogUpdClause_;
#define FunctorDoLogUpdClause Yap_heap_regs->FunctorDoLogUpdClause_
  Functor FunctorDoLogUpdClause0_;
#define FunctorDoLogUpdClause0 Yap_heap_regs->FunctorDoLogUpdClause0_
  Functor FunctorDoLogUpdClauseErase_;
#define FunctorDoLogUpdClauseErase Yap_heap_regs->FunctorDoLogUpdClauseErase_
  Functor FunctorDoStaticClause_;
#define FunctorDoStaticClause Yap_heap_regs->FunctorDoStaticClause_
  Functor FunctorDollarVar_;
#define FunctorDollarVar Yap_heap_regs->FunctorDollarVar_
  Functor FunctorDomainError_;
#define FunctorDomainError Yap_heap_regs->FunctorDomainError_
  Functor FunctorDot_;
#define FunctorDot Yap_heap_regs->FunctorDot_
  Functor FunctorDot10_;
#define FunctorDot10 Yap_heap_regs->FunctorDot10_
  Functor FunctorDot11_;
#define FunctorDot11 Yap_heap_regs->FunctorDot11_
  Functor FunctorDot12_;
#define FunctorDot12 Yap_heap_regs->FunctorDot12_
  Functor FunctorDot2_;
#define FunctorDot2 Yap_heap_regs->FunctorDot2_
  Functor FunctorDot3_;
#define FunctorDot3 Yap_heap_regs->FunctorDot3_
  Functor FunctorDot4_;
#define FunctorDot4 Yap_heap_regs->FunctorDot4_
  Functor FunctorDot5_;
#define FunctorDot5 Yap_heap_regs->FunctorDot5_
  Functor FunctorDot6_;
#define FunctorDot6 Yap_heap_regs->FunctorDot6_
  Functor FunctorDot7_;
#define FunctorDot7 Yap_heap_regs->FunctorDot7_
  Functor FunctorDot8_;
#define FunctorDot8 Yap_heap_regs->FunctorDot8_
  Functor FunctorDot9_;
#define FunctorDot9 Yap_heap_regs->FunctorDot9_
  Functor FunctorDoubleSlash_;
#define FunctorDoubleSlash Yap_heap_regs->FunctorDoubleSlash_
  Functor FunctorEmptySquareBrackets_;
#define FunctorEmptySquareBrackets Yap_heap_regs->FunctorEmptySquareBrackets_
  Functor FunctorEmptyCurlyBrackets_;
#define FunctorEmptyCurlyBrackets Yap_heap_regs->FunctorEmptyCurlyBrackets_
  Functor FunctorEq_;
#define FunctorEq Yap_heap_regs->FunctorEq_
  Functor FunctorError_;
#define FunctorError Yap_heap_regs->FunctorError_
  Functor FunctorEvaluationError_;
#define FunctorEvaluationError Yap_heap_regs->FunctorEvaluationError_
  Functor FunctorExecute2InMod_;
#define FunctorExecute2InMod Yap_heap_regs->FunctorExecute2InMod_
  Functor FunctorExecuteInMod_;
#define FunctorExecuteInMod Yap_heap_regs->FunctorExecuteInMod_
  Functor FunctorExecuteWithin_;
#define FunctorExecuteWithin Yap_heap_regs->FunctorExecuteWithin_
  Functor FunctorExistenceError_;
#define FunctorExistenceError Yap_heap_regs->FunctorExistenceError_
  Functor FunctorExoClause_;
#define FunctorExoClause Yap_heap_regs->FunctorExoClause_
  Functor FunctorFunctor_;
#define FunctorFunctor Yap_heap_regs->FunctorFunctor_
  Functor FunctorGAtom_;
#define FunctorGAtom Yap_heap_regs->FunctorGAtom_
  Functor FunctorGAtomic_;
#define FunctorGAtomic Yap_heap_regs->FunctorGAtomic_
  Functor FunctorGCompound_;
#define FunctorGCompound Yap_heap_regs->FunctorGCompound_
  Functor FunctorGFloat_;
#define FunctorGFloat Yap_heap_regs->FunctorGFloat_
  Functor FunctorGFormatAt_;
#define FunctorGFormatAt Yap_heap_regs->FunctorGFormatAt_
  Functor FunctorGInteger_;
#define FunctorGInteger Yap_heap_regs->FunctorGInteger_
  Functor FunctorGNumber_;
#define FunctorGNumber Yap_heap_regs->FunctorGNumber_
  Functor FunctorGPrimitive_;
#define FunctorGPrimitive Yap_heap_regs->FunctorGPrimitive_
  Functor FunctorGVar_;
#define FunctorGVar Yap_heap_regs->FunctorGVar_
  Functor FunctorGeneratePredInfo_;
#define FunctorGeneratePredInfo Yap_heap_regs->FunctorGeneratePredInfo_
  Functor FunctorGoalExpansion2_;
#define FunctorGoalExpansion2 Yap_heap_regs->FunctorGoalExpansion2_
  Functor FunctorGoalExpansion_;
#define FunctorGoalExpansion Yap_heap_regs->FunctorGoalExpansion_
  Functor FunctorHandleThrow_;
#define FunctorHandleThrow Yap_heap_regs->FunctorHandleThrow_
  Functor FunctorHat_;
#define FunctorHat Yap_heap_regs->FunctorHat_
  Functor FunctorId_;
#define FunctorId Yap_heap_regs->FunctorId_
  Functor FunctorIs_;
#define FunctorIs Yap_heap_regs->FunctorIs_
  Functor FunctorLastExecuteWithin_;
#define FunctorLastExecuteWithin Yap_heap_regs->FunctorLastExecuteWithin_
  Functor FunctorList_;
#define FunctorList Yap_heap_regs->FunctorList_
  Functor FunctorLOOP_;
#define FunctorLOOP Yap_heap_regs->FunctorLOOP_
  Functor FunctorMegaClause_;
#define FunctorMegaClause Yap_heap_regs->FunctorMegaClause_
  Functor FunctorMetaCall_;
#define FunctorMetaCall Yap_heap_regs->FunctorMetaCall_
  Functor FunctorMinus_;
#define FunctorMinus Yap_heap_regs->FunctorMinus_
  Functor FunctorModule_;
#define FunctorModule Yap_heap_regs->FunctorModule_
  Functor FunctorMultiFileClause_;
#define FunctorMultiFileClause Yap_heap_regs->FunctorMultiFileClause_
  Functor FunctorMutable_;
#define FunctorMutable Yap_heap_regs->FunctorMutable_
  Functor FunctorMutex_;
#define FunctorMutex Yap_heap_regs->FunctorMutex_
  Functor FunctorNotImplemented_;
#define FunctorNotImplemented Yap_heap_regs->FunctorNotImplemented_
  Functor FunctorNBQueue_;
#define FunctorNBQueue Yap_heap_regs->FunctorNBQueue_
  Functor FunctorNot_;
#define FunctorNot Yap_heap_regs->FunctorNot_
  Functor FunctorOr_;
#define FunctorOr Yap_heap_regs->FunctorOr_
  Functor FunctorPermissionError_;
#define FunctorPermissionError Yap_heap_regs->FunctorPermissionError_
  Functor FunctorPlus_;
#define FunctorPlus Yap_heap_regs->FunctorPlus_
  Functor FunctorPortray_;
#define FunctorPortray Yap_heap_regs->FunctorPortray_
  Functor FunctorPrintMessage_;
#define FunctorPrintMessage Yap_heap_regs->FunctorPrintMessage_
  Functor FunctorProcedure_;
#define FunctorProcedure Yap_heap_regs->FunctorProcedure_
  Functor FunctorPrologConstraint_;
#define FunctorPrologConstraint Yap_heap_regs->FunctorPrologConstraint_
  Functor FunctorQuery_;
#define FunctorQuery Yap_heap_regs->FunctorQuery_
  Functor FunctorRecordedWithKey_;
#define FunctorRecordedWithKey Yap_heap_regs->FunctorRecordedWithKey_
  Functor FunctorRDiv_;
#define FunctorRDiv Yap_heap_regs->FunctorRDiv_
  Functor FunctorRedoFreeze_;
#define FunctorRedoFreeze Yap_heap_regs->FunctorRedoFreeze_
  Functor FunctorRepresentationError_;
#define FunctorRepresentationError Yap_heap_regs->FunctorRepresentationError_
  Functor FunctorResourceError_;
#define FunctorResourceError Yap_heap_regs->FunctorResourceError_
  Functor FunctorRestoreRegs_;
#define FunctorRestoreRegs Yap_heap_regs->FunctorRestoreRegs_
  Functor FunctorRestoreRegs1_;
#define FunctorRestoreRegs1 Yap_heap_regs->FunctorRestoreRegs1_
  Functor FunctorSafe_;
#define FunctorSafe Yap_heap_regs->FunctorSafe_
  Functor FunctorSafeCallCleanup_;
#define FunctorSafeCallCleanup Yap_heap_regs->FunctorSafeCallCleanup_
  Functor FunctorSame_;
#define FunctorSame Yap_heap_regs->FunctorSame_
  Functor FunctorSlash_;
#define FunctorSlash Yap_heap_regs->FunctorSlash_
  Functor FunctorStaticClause_;
#define FunctorStaticClause Yap_heap_regs->FunctorStaticClause_
  Functor FunctorStream_;
#define FunctorStream Yap_heap_regs->FunctorStream_
  Functor FunctorStreamEOS_;
#define FunctorStreamEOS Yap_heap_regs->FunctorStreamEOS_
  Functor FunctorStreamPos_;
#define FunctorStreamPos Yap_heap_regs->FunctorStreamPos_
  Functor FunctorString1_;
#define FunctorString1 Yap_heap_regs->FunctorString1_
  Functor FunctorStyleCheck_;
#define FunctorStyleCheck Yap_heap_regs->FunctorStyleCheck_
  Functor FunctorSyntaxError_;
#define FunctorSyntaxError Yap_heap_regs->FunctorSyntaxError_
  Functor FunctorShortSyntaxError_;
#define FunctorShortSyntaxError Yap_heap_regs->FunctorShortSyntaxError_
  Functor FunctorTermExpansion_;
#define FunctorTermExpansion Yap_heap_regs->FunctorTermExpansion_
  Functor FunctorThreadRun_;
#define FunctorThreadRun Yap_heap_regs->FunctorThreadRun_
  Functor FunctorThrow_;
#define FunctorThrow Yap_heap_regs->FunctorThrow_
  Functor FunctorTimeoutError_;
#define FunctorTimeoutError Yap_heap_regs->FunctorTimeoutError_
  Functor FunctorTraceMetaCall_;
#define FunctorTraceMetaCall Yap_heap_regs->FunctorTraceMetaCall_
  Functor FunctorTypeError_;
#define FunctorTypeError Yap_heap_regs->FunctorTypeError_
  Functor FunctorUMinus_;
#define FunctorUMinus Yap_heap_regs->FunctorUMinus_
  Functor FunctorUPlus_;
#define FunctorUPlus Yap_heap_regs->FunctorUPlus_
  Functor FunctorVBar_;
#define FunctorVBar Yap_heap_regs->FunctorVBar_
  Functor FunctorHiddenVar_;
#define FunctorHiddenVar Yap_heap_regs->FunctorHiddenVar_