/* This file, ratoms.h, was generated automatically by "yap -L misc/buildatoms" {lease do not update, update misc/ATOMS instead */ Atom3Dots = AtomAdjust(Atom3Dots); AtomAbol = AtomAdjust(AtomAbol); TermAbol = MkAtomTerm(AtomAbol); AtomAccess = AtomAdjust(AtomAccess); TermAccess = MkAtomTerm(AtomAccess); AtomAfInet = AtomAdjust(AtomAfInet); TermAfInet = MkAtomTerm(AtomAfInet); AtomAfLocal = AtomAdjust(AtomAfLocal); TermAfLocal = MkAtomTerm(AtomAfLocal); AtomAfUnix = AtomAdjust(AtomAfUnix); TermAfUnix = MkAtomTerm(AtomAfUnix); AtomAlarm = AtomAdjust(AtomAlarm); TermAlarm = MkAtomTerm(AtomAlarm); AtomAlias = AtomAdjust(AtomAlias); TermAlias = MkAtomTerm(AtomAlias); AtomAll = AtomAdjust(AtomAll); TermAll = MkAtomTerm(AtomAll); AtomAltNot = AtomAdjust(AtomAltNot); TermAltNot = MkAtomTerm(AtomAltNot); AtomAnswer = AtomAdjust(AtomAnswer); TermAnswer = MkAtomTerm(AtomAnswer); AtomAny = AtomAdjust(AtomAny); TermAny = MkAtomTerm(AtomAny); AtomAppend = AtomAdjust(AtomAppend); TermAppend = MkAtomTerm(AtomAppend); AtomArg = AtomAdjust(AtomArg); TermArg = MkAtomTerm(AtomArg); AtomArray = AtomAdjust(AtomArray); TermArray = MkAtomTerm(AtomArray); AtomArrayAccess = AtomAdjust(AtomArrayAccess); TermArrayAccess = MkAtomTerm(AtomArrayAccess); AtomArrayOverflow = AtomAdjust(AtomArrayOverflow); TermArrayOverflow = MkAtomTerm(AtomArrayOverflow); AtomArrayType = AtomAdjust(AtomArrayType); TermArrayType = MkAtomTerm(AtomArrayType); AtomArrow = AtomAdjust(AtomArrow); TermArrow = MkAtomTerm(AtomArrow); AtomAttributedModule = AtomAdjust(AtomAttributedModule); TermAttributedModule = MkAtomTerm(AtomAttributedModule); AtomDoubleArrow = AtomAdjust(AtomDoubleArrow); TermDoubleArrow = MkAtomTerm(AtomDoubleArrow); AtomAssert = AtomAdjust(AtomAssert); TermAssert = MkAtomTerm(AtomAssert); AtomBeginBracket = AtomAdjust(AtomBeginBracket); TermBeginBracket = MkAtomTerm(AtomBeginBracket); AtomEndBracket = AtomAdjust(AtomEndBracket); TermEndBracket = MkAtomTerm(AtomEndBracket); AtomBeginSquareBracket = AtomAdjust(AtomBeginSquareBracket); TermBeginSquareBracket = MkAtomTerm(AtomBeginSquareBracket); AtomEndSquareBracket = AtomAdjust(AtomEndSquareBracket); TermEndSquareBracket = MkAtomTerm(AtomEndSquareBracket); AtomBeginCurlyBracket = AtomAdjust(AtomBeginCurlyBracket); TermBeginCurlyBracket = MkAtomTerm(AtomBeginCurlyBracket); AtomEndCurlyBracket = AtomAdjust(AtomEndCurlyBracket); TermEndCurlyBracket = MkAtomTerm(AtomEndCurlyBracket); AtomEmptyBrackets = AtomAdjust(AtomEmptyBrackets); TermEmptyBrackets = MkAtomTerm(AtomEmptyBrackets); AtomEmptySquareBrackets = AtomAdjust(AtomEmptySquareBrackets); TermEmptySquareBrackets = MkAtomTerm(AtomEmptySquareBrackets); AtomAsserta = AtomAdjust(AtomAsserta); TermAsserta = MkAtomTerm(AtomAsserta); AtomAssertaStatic = AtomAdjust(AtomAssertaStatic); TermAssertaStatic = MkAtomTerm(AtomAssertaStatic); AtomAssertz = AtomAdjust(AtomAssertz); TermAssertz = MkAtomTerm(AtomAssertz); AtomAssertzStatic = AtomAdjust(AtomAssertzStatic); TermAssertzStatic = MkAtomTerm(AtomAssertzStatic); AtomAt = AtomAdjust(AtomAt); TermAt = MkAtomTerm(AtomAt); AtomAtom = AtomAdjust(AtomAtom); TermAtom = MkAtomTerm(AtomAtom); AtomAtomic = AtomAdjust(AtomAtomic); TermAtomic = MkAtomTerm(AtomAtomic); AtomAtt = AtomAdjust(AtomAtt); TermAtt = MkAtomTerm(AtomAtt); AtomAtt1 = AtomAdjust(AtomAtt1); TermAtt1 = MkAtomTerm(AtomAtt1); AtomAttDo = AtomAdjust(AtomAttDo); TermAttDo = MkAtomTerm(AtomAttDo); AtomAttributes = AtomAdjust(AtomAttributes); TermAttributes = MkAtomTerm(AtomAttributes); AtomB = AtomAdjust(AtomB); TermB = MkAtomTerm(AtomB); AtomBatched = AtomAdjust(AtomBatched); TermBatched = MkAtomTerm(AtomBatched); AtomBetween = AtomAdjust(AtomBetween); TermBetween = MkAtomTerm(AtomBetween); AtomBinary = AtomAdjust(AtomBinary); TermBinary = MkAtomTerm(AtomBinary); AtomBigNum = AtomAdjust(AtomBigNum); TermBigNum = MkAtomTerm(AtomBigNum); AtomBinaryStream = AtomAdjust(AtomBinaryStream); TermBinaryStream = MkAtomTerm(AtomBinaryStream); AtomBoolean = AtomAdjust(AtomBoolean); TermBoolean = MkAtomTerm(AtomBoolean); AtomBraces = AtomAdjust(AtomBraces); TermBraces = MkAtomTerm(AtomBraces); AtomBreak = AtomAdjust(AtomBreak); TermBreak = MkAtomTerm(AtomBreak); AtomByte = AtomAdjust(AtomByte); TermByte = MkAtomTerm(AtomByte); AtomCArith = AtomAdjust(AtomCArith); TermCArith = MkAtomTerm(AtomCArith); AtomCall = AtomAdjust(AtomCall); TermCall = MkAtomTerm(AtomCall); AtomCallAndRetryCounter = AtomAdjust(AtomCallAndRetryCounter); TermCallAndRetryCounter = MkAtomTerm(AtomCallAndRetryCounter); AtomCallCounter = AtomAdjust(AtomCallCounter); TermCallCounter = MkAtomTerm(AtomCallCounter); AtomCallable = AtomAdjust(AtomCallable); TermCallable = MkAtomTerm(AtomCallable); AtomCatch = AtomAdjust(AtomCatch); TermCatch = MkAtomTerm(AtomCatch); AtomChangeModule = AtomAdjust(AtomChangeModule); TermChangeModule = MkAtomTerm(AtomChangeModule); AtomChar = AtomAdjust(AtomChar); TermChar = MkAtomTerm(AtomChar); AtomCharsio = AtomAdjust(AtomCharsio); TermCharsio = MkAtomTerm(AtomCharsio); AtomCharacter = AtomAdjust(AtomCharacter); TermCharacter = MkAtomTerm(AtomCharacter); AtomCharacterCode = AtomAdjust(AtomCharacterCode); TermCharacterCode = MkAtomTerm(AtomCharacterCode); AtomChars = AtomAdjust(AtomChars); TermChars = MkAtomTerm(AtomChars); AtomCharset = AtomAdjust(AtomCharset); TermCharset = MkAtomTerm(AtomCharset); AtomChType = AtomAdjust(AtomChType); TermChType = MkAtomTerm(AtomChType); AtomCleanCall = AtomAdjust(AtomCleanCall); TermCleanCall = MkAtomTerm(AtomCleanCall); AtomClose = AtomAdjust(AtomClose); TermClose = MkAtomTerm(AtomClose); AtomColon = AtomAdjust(AtomColon); TermColon = MkAtomTerm(AtomColon); AtomCodeSpace = AtomAdjust(AtomCodeSpace); TermCodeSpace = MkAtomTerm(AtomCodeSpace); AtomCodes = AtomAdjust(AtomCodes); TermCodes = MkAtomTerm(AtomCodes); AtomCoInductive = AtomAdjust(AtomCoInductive); TermCoInductive = MkAtomTerm(AtomCoInductive); AtomComma = AtomAdjust(AtomComma); TermComma = MkAtomTerm(AtomComma); AtomCommentHook = AtomAdjust(AtomCommentHook); TermCommentHook = MkAtomTerm(AtomCommentHook); AtomCompact = AtomAdjust(AtomCompact); TermCompact = MkAtomTerm(AtomCompact); AtomCompound = AtomAdjust(AtomCompound); TermCompound = MkAtomTerm(AtomCompound); AtomConsistencyError = AtomAdjust(AtomConsistencyError); TermConsistencyError = MkAtomTerm(AtomConsistencyError); AtomConsult = AtomAdjust(AtomConsult); TermConsult = MkAtomTerm(AtomConsult); AtomConsultOnBoot = AtomAdjust(AtomConsultOnBoot); TermConsultOnBoot = MkAtomTerm(AtomConsultOnBoot); AtomContext = AtomAdjust(AtomContext); TermContext = MkAtomTerm(AtomContext); AtomCputime = AtomAdjust(AtomCputime); TermCputime = MkAtomTerm(AtomCputime); AtomCreate = AtomAdjust(AtomCreate); TermCreate = MkAtomTerm(AtomCreate); AtomCreep = AtomAdjust(AtomCreep); TermCreep = MkAtomTerm(AtomCreep); AtomCryptAtoms = AtomAdjust(AtomCryptAtoms); TermCryptAtoms = MkAtomTerm(AtomCryptAtoms); AtomCurly = AtomAdjust(AtomCurly); TermCurly = MkAtomTerm(AtomCurly); AtomCsult = AtomAdjust(AtomCsult); TermCsult = MkAtomTerm(AtomCsult); AtomCurrentModule = AtomAdjust(AtomCurrentModule); TermCurrentModule = MkAtomTerm(AtomCurrentModule); AtomCut = AtomAdjust(AtomCut); TermCut = MkAtomTerm(AtomCut); AtomCutBy = AtomAdjust(AtomCutBy); TermCutBy = MkAtomTerm(AtomCutBy); AtomDAbort = AtomAdjust(AtomDAbort); TermDAbort = MkAtomTerm(AtomDAbort); AtomDBLoad = AtomAdjust(AtomDBLoad); TermDBLoad = MkAtomTerm(AtomDBLoad); AtomDBREF = AtomAdjust(AtomDBREF); TermDBREF = MkAtomTerm(AtomDBREF); AtomDBReference = AtomAdjust(AtomDBReference); TermDBReference = MkAtomTerm(AtomDBReference); AtomDBTerm = AtomAdjust(AtomDBTerm); TermDBTerm = MkAtomTerm(AtomDBTerm); AtomDBref = AtomAdjust(AtomDBref); TermDBref = MkAtomTerm(AtomDBref); AtomDInteger = AtomAdjust(AtomDInteger); TermDInteger = MkAtomTerm(AtomDInteger); AtomDebugMeta = AtomAdjust(AtomDebugMeta); TermDebugMeta = MkAtomTerm(AtomDebugMeta); AtomDebuggerInput = AtomAdjust(AtomDebuggerInput); TermDebuggerInput = MkAtomTerm(AtomDebuggerInput); AtomDec10 = AtomAdjust(AtomDec10); TermDec10 = MkAtomTerm(AtomDec10); AtomDefault = AtomAdjust(AtomDefault); TermDefault = MkAtomTerm(AtomDefault); AtomDevNull = AtomAdjust(AtomDevNull); TermDevNull = MkAtomTerm(AtomDevNull); AtomDiff = AtomAdjust(AtomDiff); TermDiff = MkAtomTerm(AtomDiff); AtomDirectory = AtomAdjust(AtomDirectory); TermDirectory = MkAtomTerm(AtomDirectory); AtomDiscontiguous = AtomAdjust(AtomDiscontiguous); TermDiscontiguous = MkAtomTerm(AtomDiscontiguous); AtomDiscontiguousWarnings = AtomAdjust(AtomDiscontiguousWarnings); TermDiscontiguousWarnings = MkAtomTerm(AtomDiscontiguousWarnings); AtomDollar = AtomAdjust(AtomDollar); TermDollar = MkAtomTerm(AtomDollar); AtomDoLogUpdClause = AtomAdjust(AtomDoLogUpdClause); TermDoLogUpdClause = MkAtomTerm(AtomDoLogUpdClause); AtomDoLogUpdClause0 = AtomAdjust(AtomDoLogUpdClause0); TermDoLogUpdClause0 = MkAtomTerm(AtomDoLogUpdClause0); AtomDoLogUpdClauseErase = AtomAdjust(AtomDoLogUpdClauseErase); TermDoLogUpdClauseErase = MkAtomTerm(AtomDoLogUpdClauseErase); AtomDollarU = AtomAdjust(AtomDollarU); TermDollarU = MkAtomTerm(AtomDollarU); AtomDollarUndef = AtomAdjust(AtomDollarUndef); TermDollarUndef = MkAtomTerm(AtomDollarUndef); AtomDomainError = AtomAdjust(AtomDomainError); TermDomainError = MkAtomTerm(AtomDomainError); AtomDoStaticClause = AtomAdjust(AtomDoStaticClause); TermDoStaticClause = MkAtomTerm(AtomDoStaticClause); AtomDots = AtomAdjust(AtomDots); TermDots = MkAtomTerm(AtomDots); AtomDOUBLE = AtomAdjust(AtomDOUBLE); TermDOUBLE = MkAtomTerm(AtomDOUBLE); AtomDoubleSlash = AtomAdjust(AtomDoubleSlash); TermDoubleSlash = MkAtomTerm(AtomDoubleSlash); AtomE = AtomAdjust(AtomE); TermE = MkAtomTerm(AtomE); AtomEOFBeforeEOT = AtomAdjust(AtomEOFBeforeEOT); TermEOFBeforeEOT = MkAtomTerm(AtomEOFBeforeEOT); AtomEQ = AtomAdjust(AtomEQ); TermEQ = MkAtomTerm(AtomEQ); AtomEmptyAtom = AtomAdjust(AtomEmptyAtom); TermEmptyAtom = MkAtomTerm(AtomEmptyAtom); AtomEncoding = AtomAdjust(AtomEncoding); TermEncoding = MkAtomTerm(AtomEncoding); AtomEndOfStream = AtomAdjust(AtomEndOfStream); TermEndOfStream = MkAtomTerm(AtomEndOfStream); AtomEof = AtomAdjust(AtomEof); TermEof = MkAtomTerm(AtomEof); AtomEOfCode = AtomAdjust(AtomEOfCode); TermEOfCode = MkAtomTerm(AtomEOfCode); AtomEq = AtomAdjust(AtomEq); TermEq = MkAtomTerm(AtomEq); AtomError = AtomAdjust(AtomError); TermError = MkAtomTerm(AtomError); AtomException = AtomAdjust(AtomException); TermException = MkAtomTerm(AtomException); AtomExtensions = AtomAdjust(AtomExtensions); TermExtensions = MkAtomTerm(AtomExtensions); AtomEvaluable = AtomAdjust(AtomEvaluable); TermEvaluable = MkAtomTerm(AtomEvaluable); AtomEvaluationError = AtomAdjust(AtomEvaluationError); TermEvaluationError = MkAtomTerm(AtomEvaluationError); AtomExecutable = AtomAdjust(AtomExecutable); TermExecutable = MkAtomTerm(AtomExecutable); AtomExecute = AtomAdjust(AtomExecute); TermExecute = MkAtomTerm(AtomExecute); AtomExecAnswers = AtomAdjust(AtomExecAnswers); TermExecAnswers = MkAtomTerm(AtomExecAnswers); AtomExecuteInMod = AtomAdjust(AtomExecuteInMod); TermExecuteInMod = MkAtomTerm(AtomExecuteInMod); AtomExecuteWithin = AtomAdjust(AtomExecuteWithin); TermExecuteWithin = MkAtomTerm(AtomExecuteWithin); AtomExecuteWoMod = AtomAdjust(AtomExecuteWoMod); TermExecuteWoMod = MkAtomTerm(AtomExecuteWoMod); AtomExist = AtomAdjust(AtomExist); TermExist = MkAtomTerm(AtomExist); AtomExists = AtomAdjust(AtomExists); TermExists = MkAtomTerm(AtomExists); AtomExit = AtomAdjust(AtomExit); TermExit = MkAtomTerm(AtomExit); AtomExistenceError = AtomAdjust(AtomExistenceError); TermExistenceError = MkAtomTerm(AtomExistenceError); AtomExoClause = AtomAdjust(AtomExoClause); TermExoClause = MkAtomTerm(AtomExoClause); AtomExpectedNumber = AtomAdjust(AtomExpectedNumber); TermExpectedNumber = MkAtomTerm(AtomExpectedNumber); AtomExpand = AtomAdjust(AtomExpand); TermExpand = MkAtomTerm(AtomExpand); AtomExtendFileSearchPath = AtomAdjust(AtomExtendFileSearchPath); TermExtendFileSearchPath = MkAtomTerm(AtomExtendFileSearchPath); AtomExtendsions = AtomAdjust(AtomExtendsions); TermExtendsions = MkAtomTerm(AtomExtendsions); AtomFB = AtomAdjust(AtomFB); TermFB = MkAtomTerm(AtomFB); AtomFail = AtomAdjust(AtomFail); TermFail = MkAtomTerm(AtomFail); AtomFalse = AtomAdjust(AtomFalse); TermFalse = MkAtomTerm(AtomFalse); AtomFast = AtomAdjust(AtomFast); TermFast = MkAtomTerm(AtomFast); AtomFastFail = AtomAdjust(AtomFastFail); TermFastFail = MkAtomTerm(AtomFastFail); AtomFileErrors = AtomAdjust(AtomFileErrors); TermFileErrors = MkAtomTerm(AtomFileErrors); AtomFileerrors = AtomAdjust(AtomFileerrors); TermFileerrors = MkAtomTerm(AtomFileerrors); AtomFileType = AtomAdjust(AtomFileType); TermFileType = MkAtomTerm(AtomFileType); AtomFirst = AtomAdjust(AtomFirst); TermFirst = MkAtomTerm(AtomFirst); AtomFloat = AtomAdjust(AtomFloat); TermFloat = MkAtomTerm(AtomFloat); AtomFloatFormat = AtomAdjust(AtomFloatFormat); TermFloatFormat = MkAtomTerm(AtomFloatFormat); AtomFloatOverflow = AtomAdjust(AtomFloatOverflow); TermFloatOverflow = MkAtomTerm(AtomFloatOverflow); AtomFloatUnderflow = AtomAdjust(AtomFloatUnderflow); TermFloatUnderflow = MkAtomTerm(AtomFloatUnderflow); AtomFormat = AtomAdjust(AtomFormat); TermFormat = MkAtomTerm(AtomFormat); AtomFormatAt = AtomAdjust(AtomFormatAt); TermFormatAt = MkAtomTerm(AtomFormatAt); AtomFull = AtomAdjust(AtomFull); TermFull = MkAtomTerm(AtomFull); AtomFunctor = AtomAdjust(AtomFunctor); TermFunctor = MkAtomTerm(AtomFunctor); AtomGT = AtomAdjust(AtomGT); TermGT = MkAtomTerm(AtomGT); AtomGVar = AtomAdjust(AtomGVar); TermGVar = MkAtomTerm(AtomGVar); AtomGc = AtomAdjust(AtomGc); TermGc = MkAtomTerm(AtomGc); AtomGcMargin = AtomAdjust(AtomGcMargin); TermGcMargin = MkAtomTerm(AtomGcMargin); AtomGcTrace = AtomAdjust(AtomGcTrace); TermGcTrace = MkAtomTerm(AtomGcTrace); AtomGcVerbose = AtomAdjust(AtomGcVerbose); TermGcVerbose = MkAtomTerm(AtomGcVerbose); AtomGcVeryVerbose = AtomAdjust(AtomGcVeryVerbose); TermGcVeryVerbose = MkAtomTerm(AtomGcVeryVerbose); AtomGeneratePredInfo = AtomAdjust(AtomGeneratePredInfo); TermGeneratePredInfo = MkAtomTerm(AtomGeneratePredInfo); AtomGetwork = AtomAdjust(AtomGetwork); TermGetwork = MkAtomTerm(AtomGetwork); AtomGetworkSeq = AtomAdjust(AtomGetworkSeq); TermGetworkSeq = MkAtomTerm(AtomGetworkSeq); AtomGlob = AtomAdjust(AtomGlob); TermGlob = MkAtomTerm(AtomGlob); AtomGlobal = AtomAdjust(AtomGlobal); TermGlobal = MkAtomTerm(AtomGlobal); AtomGlobalSp = AtomAdjust(AtomGlobalSp); TermGlobalSp = MkAtomTerm(AtomGlobalSp); AtomGlobalTrie = AtomAdjust(AtomGlobalTrie); TermGlobalTrie = MkAtomTerm(AtomGlobalTrie); AtomGoalExpansion = AtomAdjust(AtomGoalExpansion); TermGoalExpansion = MkAtomTerm(AtomGoalExpansion); AtomHat = AtomAdjust(AtomHat); TermHat = MkAtomTerm(AtomHat); AtomHERE = AtomAdjust(AtomHERE); TermHERE = MkAtomTerm(AtomHERE); AtomHandleThrow = AtomAdjust(AtomHandleThrow); TermHandleThrow = MkAtomTerm(AtomHandleThrow); AtomHeap = AtomAdjust(AtomHeap); TermHeap = MkAtomTerm(AtomHeap); AtomHeapUsed = AtomAdjust(AtomHeapUsed); TermHeapUsed = MkAtomTerm(AtomHeapUsed); AtomHugeInt = AtomAdjust(AtomHugeInt); TermHugeInt = MkAtomTerm(AtomHugeInt); AtomIDB = AtomAdjust(AtomIDB); TermIDB = MkAtomTerm(AtomIDB); AtomIOMode = AtomAdjust(AtomIOMode); TermIOMode = MkAtomTerm(AtomIOMode); AtomI = AtomAdjust(AtomI); TermI = MkAtomTerm(AtomI); AtomId = AtomAdjust(AtomId); TermId = MkAtomTerm(AtomId); AtomIgnore = AtomAdjust(AtomIgnore); TermIgnore = MkAtomTerm(AtomIgnore); AtomInf = AtomAdjust(AtomInf); TermInf = MkAtomTerm(AtomInf); AtomInfinity = AtomAdjust(AtomInfinity); TermInfinity = MkAtomTerm(AtomInfinity); AtomInfo = AtomAdjust(AtomInfo); TermInfo = MkAtomTerm(AtomInfo); AtomInitGoal = AtomAdjust(AtomInitGoal); TermInitGoal = MkAtomTerm(AtomInitGoal); AtomInitProlog = AtomAdjust(AtomInitProlog); TermInitProlog = MkAtomTerm(AtomInitProlog); AtomInStackExpansion = AtomAdjust(AtomInStackExpansion); TermInStackExpansion = MkAtomTerm(AtomInStackExpansion); AtomInput = AtomAdjust(AtomInput); TermInput = MkAtomTerm(AtomInput); AtomInstantiationError = AtomAdjust(AtomInstantiationError); TermInstantiationError = MkAtomTerm(AtomInstantiationError); AtomInt = AtomAdjust(AtomInt); TermInt = MkAtomTerm(AtomInt); AtomIntOverflow = AtomAdjust(AtomIntOverflow); TermIntOverflow = MkAtomTerm(AtomIntOverflow); AtomInteger = AtomAdjust(AtomInteger); TermInteger = MkAtomTerm(AtomInteger); AtomInternalCompilerError = AtomAdjust(AtomInternalCompilerError); TermInternalCompilerError = MkAtomTerm(AtomInternalCompilerError); AtomIs = AtomAdjust(AtomIs); TermIs = MkAtomTerm(AtomIs); AtomJ = AtomAdjust(AtomJ); TermJ = MkAtomTerm(AtomJ); Atoml = AtomAdjust(Atoml); Terml = MkAtomTerm(Atoml); AtomKey = AtomAdjust(AtomKey); TermKey = MkAtomTerm(AtomKey); AtomLDLibraryPath = AtomAdjust(AtomLDLibraryPath); TermLDLibraryPath = MkAtomTerm(AtomLDLibraryPath); AtomLONGINT = AtomAdjust(AtomLONGINT); TermLONGINT = MkAtomTerm(AtomLONGINT); AtomLOOP = AtomAdjust(AtomLOOP); TermLOOP = MkAtomTerm(AtomLOOP); AtomLoopStream = AtomAdjust(AtomLoopStream); TermLoopStream = MkAtomTerm(AtomLoopStream); AtomLT = AtomAdjust(AtomLT); TermLT = MkAtomTerm(AtomLT); AtomLastExecuteWithin = AtomAdjust(AtomLastExecuteWithin); TermLastExecuteWithin = MkAtomTerm(AtomLastExecuteWithin); AtomLeash = AtomAdjust(AtomLeash); TermLeash = MkAtomTerm(AtomLeash); AtomLeast = AtomAdjust(AtomLeast); TermLeast = MkAtomTerm(AtomLeast); AtomLength = AtomAdjust(AtomLength); TermLength = MkAtomTerm(AtomLength); AtomList = AtomAdjust(AtomList); TermList = MkAtomTerm(AtomList); AtomLine = AtomAdjust(AtomLine); TermLine = MkAtomTerm(AtomLine); AtomLive = AtomAdjust(AtomLive); TermLive = MkAtomTerm(AtomLive); AtomLoadAnswers = AtomAdjust(AtomLoadAnswers); TermLoadAnswers = MkAtomTerm(AtomLoadAnswers); AtomLocal = AtomAdjust(AtomLocal); TermLocal = MkAtomTerm(AtomLocal); AtomLocalSp = AtomAdjust(AtomLocalSp); TermLocalSp = MkAtomTerm(AtomLocalSp); AtomLocalTrie = AtomAdjust(AtomLocalTrie); TermLocalTrie = MkAtomTerm(AtomLocalTrie); AtomMax = AtomAdjust(AtomMax); TermMax = MkAtomTerm(AtomMax); AtomMaximum = AtomAdjust(AtomMaximum); TermMaximum = MkAtomTerm(AtomMaximum); AtomMaxArity = AtomAdjust(AtomMaxArity); TermMaxArity = MkAtomTerm(AtomMaxArity); AtomMaxFiles = AtomAdjust(AtomMaxFiles); TermMaxFiles = MkAtomTerm(AtomMaxFiles); AtomMegaClause = AtomAdjust(AtomMegaClause); TermMegaClause = MkAtomTerm(AtomMegaClause); AtomMetaCall = AtomAdjust(AtomMetaCall); TermMetaCall = MkAtomTerm(AtomMetaCall); AtomMfClause = AtomAdjust(AtomMfClause); TermMfClause = MkAtomTerm(AtomMfClause); AtomMin = AtomAdjust(AtomMin); TermMin = MkAtomTerm(AtomMin); AtomMinimum = AtomAdjust(AtomMinimum); TermMinimum = MkAtomTerm(AtomMinimum); AtomMinus = AtomAdjust(AtomMinus); TermMinus = MkAtomTerm(AtomMinus); AtomModify = AtomAdjust(AtomModify); TermModify = MkAtomTerm(AtomModify); AtomModule = AtomAdjust(AtomModule); TermModule = MkAtomTerm(AtomModule); AtomMost = AtomAdjust(AtomMost); TermMost = MkAtomTerm(AtomMost); AtomMulti = AtomAdjust(AtomMulti); TermMulti = MkAtomTerm(AtomMulti); AtomMultiFile = AtomAdjust(AtomMultiFile); TermMultiFile = MkAtomTerm(AtomMultiFile); AtomMultiple = AtomAdjust(AtomMultiple); TermMultiple = MkAtomTerm(AtomMultiple); AtomMutable = AtomAdjust(AtomMutable); TermMutable = MkAtomTerm(AtomMutable); AtomMutableVariable = AtomAdjust(AtomMutableVariable); TermMutableVariable = MkAtomTerm(AtomMutableVariable); AtomMutex = AtomAdjust(AtomMutex); TermMutex = MkAtomTerm(AtomMutex); AtomMyddasDB = AtomAdjust(AtomMyddasDB); TermMyddasDB = MkAtomTerm(AtomMyddasDB); AtomMyddasGoal = AtomAdjust(AtomMyddasGoal); TermMyddasGoal = MkAtomTerm(AtomMyddasGoal); AtomMyddasHost = AtomAdjust(AtomMyddasHost); TermMyddasHost = MkAtomTerm(AtomMyddasHost); AtomMyddasPass = AtomAdjust(AtomMyddasPass); TermMyddasPass = MkAtomTerm(AtomMyddasPass); AtomMyddasUser = AtomAdjust(AtomMyddasUser); TermMyddasUser = MkAtomTerm(AtomMyddasUser); AtomMyddasVersionName = AtomAdjust(AtomMyddasVersionName); TermMyddasVersionName = MkAtomTerm(AtomMyddasVersionName); AtomNan = AtomAdjust(AtomNan); TermNan = MkAtomTerm(AtomNan); AtomNb = AtomAdjust(AtomNb); TermNb = MkAtomTerm(AtomNb); AtomNbTerm = AtomAdjust(AtomNbTerm); TermNbTerm = MkAtomTerm(AtomNbTerm); AtomNew = AtomAdjust(AtomNew); TermNew = MkAtomTerm(AtomNew); AtomNewLine = AtomAdjust(AtomNewLine); TermNewLine = MkAtomTerm(AtomNewLine); AtomNl = AtomAdjust(AtomNl); TermNl = MkAtomTerm(AtomNl); AtomNoEffect = AtomAdjust(AtomNoEffect); TermNoEffect = MkAtomTerm(AtomNoEffect); AtomNoMemory = AtomAdjust(AtomNoMemory); TermNoMemory = MkAtomTerm(AtomNoMemory); AtomNone = AtomAdjust(AtomNone); TermNone = MkAtomTerm(AtomNone); AtomNonEmptyList = AtomAdjust(AtomNonEmptyList); TermNonEmptyList = MkAtomTerm(AtomNonEmptyList); AtomNot = AtomAdjust(AtomNot); TermNot = MkAtomTerm(AtomNot); AtomNotImplemented = AtomAdjust(AtomNotImplemented); TermNotImplemented = MkAtomTerm(AtomNotImplemented); AtomNotLessThanZero = AtomAdjust(AtomNotLessThanZero); TermNotLessThanZero = MkAtomTerm(AtomNotLessThanZero); AtomNotNewline = AtomAdjust(AtomNotNewline); TermNotNewline = MkAtomTerm(AtomNotNewline); AtomNotZero = AtomAdjust(AtomNotZero); TermNotZero = MkAtomTerm(AtomNotZero); AtomNumber = AtomAdjust(AtomNumber); TermNumber = MkAtomTerm(AtomNumber); AtomObj = AtomAdjust(AtomObj); TermObj = MkAtomTerm(AtomObj); AtomOff = AtomAdjust(AtomOff); TermOff = MkAtomTerm(AtomOff); AtomOffline = AtomAdjust(AtomOffline); TermOffline = MkAtomTerm(AtomOffline); AtomOn = AtomAdjust(AtomOn); TermOn = MkAtomTerm(AtomOn); AtomOnline = AtomAdjust(AtomOnline); TermOnline = MkAtomTerm(AtomOnline); AtomOpen = AtomAdjust(AtomOpen); TermOpen = MkAtomTerm(AtomOpen); AtomOperatingSystemError = AtomAdjust(AtomOperatingSystemError); TermOperatingSystemError = MkAtomTerm(AtomOperatingSystemError); AtomOperatingSystemSupport = AtomAdjust(AtomOperatingSystemSupport); TermOperatingSystemSupport = MkAtomTerm(AtomOperatingSystemSupport); AtomOperator = AtomAdjust(AtomOperator); TermOperator = MkAtomTerm(AtomOperator); AtomOperatorPriority = AtomAdjust(AtomOperatorPriority); TermOperatorPriority = MkAtomTerm(AtomOperatorPriority); AtomOperatorSpecifier = AtomAdjust(AtomOperatorSpecifier); TermOperatorSpecifier = MkAtomTerm(AtomOperatorSpecifier); AtomOpt = AtomAdjust(AtomOpt); TermOpt = MkAtomTerm(AtomOpt); AtomOtherwise = AtomAdjust(AtomOtherwise); TermOtherwise = MkAtomTerm(AtomOtherwise); AtomOutOfAttvarsError = AtomAdjust(AtomOutOfAttvarsError); TermOutOfAttvarsError = MkAtomTerm(AtomOutOfAttvarsError); AtomOutOfAuxspaceError = AtomAdjust(AtomOutOfAuxspaceError); TermOutOfAuxspaceError = MkAtomTerm(AtomOutOfAuxspaceError); AtomOutOfHeapError = AtomAdjust(AtomOutOfHeapError); TermOutOfHeapError = MkAtomTerm(AtomOutOfHeapError); AtomOutOfRange = AtomAdjust(AtomOutOfRange); TermOutOfRange = MkAtomTerm(AtomOutOfRange); AtomOutOfStackError = AtomAdjust(AtomOutOfStackError); TermOutOfStackError = MkAtomTerm(AtomOutOfStackError); AtomOutOfTrailError = AtomAdjust(AtomOutOfTrailError); TermOutOfTrailError = MkAtomTerm(AtomOutOfTrailError); AtomOutput = AtomAdjust(AtomOutput); TermOutput = MkAtomTerm(AtomOutput); AtomParameter = AtomAdjust(AtomParameter); TermParameter = MkAtomTerm(AtomParameter); AtomPrologCommonsDir = AtomAdjust(AtomPrologCommonsDir); TermPrologCommonsDir = MkAtomTerm(AtomPrologCommonsDir); AtomPast = AtomAdjust(AtomPast); TermPast = MkAtomTerm(AtomPast); AtomPastEndOfStream = AtomAdjust(AtomPastEndOfStream); TermPastEndOfStream = MkAtomTerm(AtomPastEndOfStream); AtomPermissionError = AtomAdjust(AtomPermissionError); TermPermissionError = MkAtomTerm(AtomPermissionError); AtomPi = AtomAdjust(AtomPi); TermPi = MkAtomTerm(AtomPi); AtomPipe = AtomAdjust(AtomPipe); TermPipe = MkAtomTerm(AtomPipe); AtomPriority = AtomAdjust(AtomPriority); TermPriority = MkAtomTerm(AtomPriority); AtomPlus = AtomAdjust(AtomPlus); TermPlus = MkAtomTerm(AtomPlus); AtomPointer = AtomAdjust(AtomPointer); TermPointer = MkAtomTerm(AtomPointer); AtomPortray = AtomAdjust(AtomPortray); TermPortray = MkAtomTerm(AtomPortray); AtomPredicateIndicator = AtomAdjust(AtomPredicateIndicator); TermPredicateIndicator = MkAtomTerm(AtomPredicateIndicator); AtomPrimitive = AtomAdjust(AtomPrimitive); TermPrimitive = MkAtomTerm(AtomPrimitive); AtomPrintMessage = AtomAdjust(AtomPrintMessage); TermPrintMessage = MkAtomTerm(AtomPrintMessage); AtomPrivateProcedure = AtomAdjust(AtomPrivateProcedure); TermPrivateProcedure = MkAtomTerm(AtomPrivateProcedure); AtomProcedure = AtomAdjust(AtomProcedure); TermProcedure = MkAtomTerm(AtomProcedure); AtomProfile = AtomAdjust(AtomProfile); TermProfile = MkAtomTerm(AtomProfile); AtomProlog = AtomAdjust(AtomProlog); TermProlog = MkAtomTerm(AtomProlog); AtomProtectStack = AtomAdjust(AtomProtectStack); TermProtectStack = MkAtomTerm(AtomProtectStack); AtomQly = AtomAdjust(AtomQly); TermQly = MkAtomTerm(AtomQly); AtomQuery = AtomAdjust(AtomQuery); TermQuery = MkAtomTerm(AtomQuery); AtomQueue = AtomAdjust(AtomQueue); TermQueue = MkAtomTerm(AtomQueue); AtomQuiet = AtomAdjust(AtomQuiet); TermQuiet = MkAtomTerm(AtomQuiet); AtomRadix = AtomAdjust(AtomRadix); TermRadix = MkAtomTerm(AtomRadix); AtomRandom = AtomAdjust(AtomRandom); TermRandom = MkAtomTerm(AtomRandom); AtomRange = AtomAdjust(AtomRange); TermRange = MkAtomTerm(AtomRange); AtomRDiv = AtomAdjust(AtomRDiv); TermRDiv = MkAtomTerm(AtomRDiv); AtomRead = AtomAdjust(AtomRead); TermRead = MkAtomTerm(AtomRead); AtomReadOnly = AtomAdjust(AtomReadOnly); TermReadOnly = MkAtomTerm(AtomReadOnly); AtomReadWrite = AtomAdjust(AtomReadWrite); TermReadWrite = MkAtomTerm(AtomReadWrite); AtomReadutil = AtomAdjust(AtomReadutil); TermReadutil = MkAtomTerm(AtomReadutil); AtomReconsult = AtomAdjust(AtomReconsult); TermReconsult = MkAtomTerm(AtomReconsult); AtomRecordedP = AtomAdjust(AtomRecordedP); TermRecordedP = MkAtomTerm(AtomRecordedP); AtomRecordedWithKey = AtomAdjust(AtomRecordedWithKey); TermRecordedWithKey = MkAtomTerm(AtomRecordedWithKey); AtomRedefineWarnings = AtomAdjust(AtomRedefineWarnings); TermRedefineWarnings = MkAtomTerm(AtomRedefineWarnings); AtomRedoFreeze = AtomAdjust(AtomRedoFreeze); TermRedoFreeze = MkAtomTerm(AtomRedoFreeze); AtomRefoundVar = AtomAdjust(AtomRefoundVar); TermRefoundVar = MkAtomTerm(AtomRefoundVar); AtomRelativeTo = AtomAdjust(AtomRelativeTo); TermRelativeTo = MkAtomTerm(AtomRelativeTo); AtomRepeat = AtomAdjust(AtomRepeat); TermRepeat = MkAtomTerm(AtomRepeat); AtomRepeatSpace = AtomAdjust(AtomRepeatSpace); TermRepeatSpace = MkAtomTerm(AtomRepeatSpace); AtomReposition = AtomAdjust(AtomReposition); TermReposition = MkAtomTerm(AtomReposition); AtomRepresentationError = AtomAdjust(AtomRepresentationError); TermRepresentationError = MkAtomTerm(AtomRepresentationError); AtomReset = AtomAdjust(AtomReset); TermReset = MkAtomTerm(AtomReset); AtomResize = AtomAdjust(AtomResize); TermResize = MkAtomTerm(AtomResize); AtomResourceError = AtomAdjust(AtomResourceError); TermResourceError = MkAtomTerm(AtomResourceError); AtomRestoreRegs = AtomAdjust(AtomRestoreRegs); TermRestoreRegs = MkAtomTerm(AtomRestoreRegs); AtomRetry = AtomAdjust(AtomRetry); TermRetry = MkAtomTerm(AtomRetry); AtomRetryCounter = AtomAdjust(AtomRetryCounter); TermRetryCounter = MkAtomTerm(AtomRetryCounter); AtomRTree = AtomAdjust(AtomRTree); TermRTree = MkAtomTerm(AtomRTree); AtomSafe = AtomAdjust(AtomSafe); TermSafe = MkAtomTerm(AtomSafe); AtomSafeCallCleanup = AtomAdjust(AtomSafeCallCleanup); TermSafeCallCleanup = MkAtomTerm(AtomSafeCallCleanup); AtomSame = AtomAdjust(AtomSame); TermSame = MkAtomTerm(AtomSame); AtomSemic = AtomAdjust(AtomSemic); TermSemic = MkAtomTerm(AtomSemic); AtomShiftCountOverflow = AtomAdjust(AtomShiftCountOverflow); TermShiftCountOverflow = MkAtomTerm(AtomShiftCountOverflow); AtomSigAlarm = AtomAdjust(AtomSigAlarm); TermSigAlarm = MkAtomTerm(AtomSigAlarm); AtomSigBreak = AtomAdjust(AtomSigBreak); TermSigBreak = MkAtomTerm(AtomSigBreak); AtomSigCreep = AtomAdjust(AtomSigCreep); TermSigCreep = MkAtomTerm(AtomSigCreep); AtomSigDebug = AtomAdjust(AtomSigDebug); TermSigDebug = MkAtomTerm(AtomSigDebug); AtomSigDelayCreep = AtomAdjust(AtomSigDelayCreep); TermSigDelayCreep = MkAtomTerm(AtomSigDelayCreep); AtomSigFPE = AtomAdjust(AtomSigFPE); TermSigFPE = MkAtomTerm(AtomSigFPE); AtomSigHup = AtomAdjust(AtomSigHup); TermSigHup = MkAtomTerm(AtomSigHup); AtomSigInt = AtomAdjust(AtomSigInt); TermSigInt = MkAtomTerm(AtomSigInt); AtomSigIti = AtomAdjust(AtomSigIti); TermSigIti = MkAtomTerm(AtomSigIti); AtomSigPending = AtomAdjust(AtomSigPending); TermSigPending = MkAtomTerm(AtomSigPending); AtomSigPipe = AtomAdjust(AtomSigPipe); TermSigPipe = MkAtomTerm(AtomSigPipe); AtomSigStackDump = AtomAdjust(AtomSigStackDump); TermSigStackDump = MkAtomTerm(AtomSigStackDump); AtomSigStatistics = AtomAdjust(AtomSigStatistics); TermSigStatistics = MkAtomTerm(AtomSigStatistics); AtomSigTrace = AtomAdjust(AtomSigTrace); TermSigTrace = MkAtomTerm(AtomSigTrace); AtomSigUsr1 = AtomAdjust(AtomSigUsr1); TermSigUsr1 = MkAtomTerm(AtomSigUsr1); AtomSigUsr2 = AtomAdjust(AtomSigUsr2); TermSigUsr2 = MkAtomTerm(AtomSigUsr2); AtomSigVTAlarm = AtomAdjust(AtomSigVTAlarm); TermSigVTAlarm = MkAtomTerm(AtomSigVTAlarm); AtomSigWakeUp = AtomAdjust(AtomSigWakeUp); TermSigWakeUp = MkAtomTerm(AtomSigWakeUp); AtomSilent = AtomAdjust(AtomSilent); TermSilent = MkAtomTerm(AtomSilent); AtomSingle = AtomAdjust(AtomSingle); TermSingle = MkAtomTerm(AtomSingle); AtomSingleVarWarnings = AtomAdjust(AtomSingleVarWarnings); TermSingleVarWarnings = MkAtomTerm(AtomSingleVarWarnings); AtomSingleton = AtomAdjust(AtomSingleton); TermSingleton = MkAtomTerm(AtomSingleton); AtomSlash = AtomAdjust(AtomSlash); TermSlash = MkAtomTerm(AtomSlash); AtomSocket = AtomAdjust(AtomSocket); TermSocket = MkAtomTerm(AtomSocket); AtomSolutions = AtomAdjust(AtomSolutions); TermSolutions = MkAtomTerm(AtomSolutions); AtomSource = AtomAdjust(AtomSource); TermSource = MkAtomTerm(AtomSource); AtomSourceSink = AtomAdjust(AtomSourceSink); TermSourceSink = MkAtomTerm(AtomSourceSink); AtomSpy = AtomAdjust(AtomSpy); TermSpy = MkAtomTerm(AtomSpy); AtomStack = AtomAdjust(AtomStack); TermStack = MkAtomTerm(AtomStack); AtomStackFree = AtomAdjust(AtomStackFree); TermStackFree = MkAtomTerm(AtomStackFree); AtomStartupSavedState = AtomAdjust(AtomStartupSavedState); TermStartupSavedState = MkAtomTerm(AtomStartupSavedState); AtomStaticClause = AtomAdjust(AtomStaticClause); TermStaticClause = MkAtomTerm(AtomStaticClause); AtomStaticProcedure = AtomAdjust(AtomStaticProcedure); TermStaticProcedure = MkAtomTerm(AtomStaticProcedure); AtomStream = AtomAdjust(AtomStream); TermStream = MkAtomTerm(AtomStream); AtomSWIStream = AtomAdjust(AtomSWIStream); TermSWIStream = MkAtomTerm(AtomSWIStream); AtomVStream = AtomAdjust(AtomVStream); TermVStream = MkAtomTerm(AtomVStream); AtomStreams = AtomAdjust(AtomStreams); TermStreams = MkAtomTerm(AtomStreams); AtomStreamOrAlias = AtomAdjust(AtomStreamOrAlias); TermStreamOrAlias = MkAtomTerm(AtomStreamOrAlias); AtomStreamPos = AtomAdjust(AtomStreamPos); TermStreamPos = MkAtomTerm(AtomStreamPos); AtomStreamPosition = AtomAdjust(AtomStreamPosition); TermStreamPosition = MkAtomTerm(AtomStreamPosition); AtomString = AtomAdjust(AtomString); TermString = MkAtomTerm(AtomString); AtomStyleCheck = AtomAdjust(AtomStyleCheck); TermStyleCheck = MkAtomTerm(AtomStyleCheck); AtomSTRING = AtomAdjust(AtomSTRING); TermSTRING = MkAtomTerm(AtomSTRING); AtomSwi = AtomAdjust(AtomSwi); TermSwi = MkAtomTerm(AtomSwi); AtomSymbolChar = AtomAdjust(AtomSymbolChar); TermSymbolChar = MkAtomTerm(AtomSymbolChar); AtomSyntaxError = AtomAdjust(AtomSyntaxError); TermSyntaxError = MkAtomTerm(AtomSyntaxError); AtomSyntaxErrors = AtomAdjust(AtomSyntaxErrors); TermSyntaxErrors = MkAtomTerm(AtomSyntaxErrors); AtomSyntaxErrorHandler = AtomAdjust(AtomSyntaxErrorHandler); TermSyntaxErrorHandler = MkAtomTerm(AtomSyntaxErrorHandler); AtomSystem = AtomAdjust(AtomSystem); TermSystem = MkAtomTerm(AtomSystem); AtomSystemError = AtomAdjust(AtomSystemError); TermSystemError = MkAtomTerm(AtomSystemError); AtomSystemLibraryDir = AtomAdjust(AtomSystemLibraryDir); TermSystemLibraryDir = MkAtomTerm(AtomSystemLibraryDir); AtomT = AtomAdjust(AtomT); TermT = MkAtomTerm(AtomT); AtomTerm = AtomAdjust(AtomTerm); TermTerm = MkAtomTerm(AtomTerm); AtomTermExpansion = AtomAdjust(AtomTermExpansion); TermTermExpansion = MkAtomTerm(AtomTermExpansion); AtomTerms = AtomAdjust(AtomTerms); TermTerms = MkAtomTerm(AtomTerms); AtomText = AtomAdjust(AtomText); TermText = MkAtomTerm(AtomText); AtomTextStream = AtomAdjust(AtomTextStream); TermTextStream = MkAtomTerm(AtomTextStream); AtomThread = AtomAdjust(AtomThread); TermThread = MkAtomTerm(AtomThread); AtomThreads = AtomAdjust(AtomThreads); TermThreads = MkAtomTerm(AtomThreads); AtomThrow = AtomAdjust(AtomThrow); TermThrow = MkAtomTerm(AtomThrow); AtomTimeOutSpec = AtomAdjust(AtomTimeOutSpec); TermTimeOutSpec = MkAtomTerm(AtomTimeOutSpec); AtomTimeoutError = AtomAdjust(AtomTimeoutError); TermTimeoutError = MkAtomTerm(AtomTimeoutError); AtomTopLevelGoal = AtomAdjust(AtomTopLevelGoal); TermTopLevelGoal = MkAtomTerm(AtomTopLevelGoal); AtomTopThreadGoal = AtomAdjust(AtomTopThreadGoal); TermTopThreadGoal = MkAtomTerm(AtomTopThreadGoal); AtomTraceMetaCall = AtomAdjust(AtomTraceMetaCall); TermTraceMetaCall = MkAtomTerm(AtomTraceMetaCall); AtomTrail = AtomAdjust(AtomTrail); AtomTrue = AtomAdjust(AtomTrue); TermTrue = MkAtomTerm(AtomTrue); AtomTty = AtomAdjust(AtomTty); TermTty = MkAtomTerm(AtomTty); AtomTtys = AtomAdjust(AtomTtys); TermTtys = MkAtomTerm(AtomTtys); AtomTuple = AtomAdjust(AtomTuple); TermTuple = MkAtomTerm(AtomTuple); AtomTxt = AtomAdjust(AtomTxt); TermTxt = MkAtomTerm(AtomTxt); AtomTypeError = AtomAdjust(AtomTypeError); TermTypeError = MkAtomTerm(AtomTypeError); AtomUndefined = AtomAdjust(AtomUndefined); TermUndefined = MkAtomTerm(AtomUndefined); AtomUndefp = AtomAdjust(AtomUndefp); TermUndefp = MkAtomTerm(AtomUndefp); AtomUndefp0 = AtomAdjust(AtomUndefp0); TermUndefp0 = MkAtomTerm(AtomUndefp0); AtomUnderflow = AtomAdjust(AtomUnderflow); TermUnderflow = MkAtomTerm(AtomUnderflow); AtomUnificationStack = AtomAdjust(AtomUnificationStack); TermUnificationStack = MkAtomTerm(AtomUnificationStack); AtomUnique = AtomAdjust(AtomUnique); TermUnique = MkAtomTerm(AtomUnique); AtomUnsignedByte = AtomAdjust(AtomUnsignedByte); TermUnsignedByte = MkAtomTerm(AtomUnsignedByte); AtomUnsignedChar = AtomAdjust(AtomUnsignedChar); TermUnsignedChar = MkAtomTerm(AtomUnsignedChar); AtomUser = AtomAdjust(AtomUser); TermUser = MkAtomTerm(AtomUser); AtomUserErr = AtomAdjust(AtomUserErr); TermUserErr = MkAtomTerm(AtomUserErr); AtomUserIn = AtomAdjust(AtomUserIn); TermUserIn = MkAtomTerm(AtomUserIn); AtomUserOut = AtomAdjust(AtomUserOut); TermUserOut = MkAtomTerm(AtomUserOut); AtomDollarVar = AtomAdjust(AtomDollarVar); TermDollarVar = MkAtomTerm(AtomDollarVar); AtomVBar = AtomAdjust(AtomVBar); TermVBar = MkAtomTerm(AtomVBar); AtomVarBranches = AtomAdjust(AtomVarBranches); TermVarBranches = MkAtomTerm(AtomVarBranches); AtomVariableNames = AtomAdjust(AtomVariableNames); TermVariableNames = MkAtomTerm(AtomVariableNames); AtomHiddenVar = AtomAdjust(AtomHiddenVar); TermHiddenVar = MkAtomTerm(AtomHiddenVar); AtomVariable = AtomAdjust(AtomVariable); TermVariable = MkAtomTerm(AtomVariable); AtomVerbose = AtomAdjust(AtomVerbose); TermVerbose = MkAtomTerm(AtomVerbose); AtomVerboseFileSearch = AtomAdjust(AtomVerboseFileSearch); TermVerboseFileSearch = MkAtomTerm(AtomVerboseFileSearch); AtomVersionNumber = AtomAdjust(AtomVersionNumber); TermVersionNumber = MkAtomTerm(AtomVersionNumber); AtomVeryVerbose = AtomAdjust(AtomVeryVerbose); TermVeryVerbose = MkAtomTerm(AtomVeryVerbose); AtomWakeUpGoal = AtomAdjust(AtomWakeUpGoal); TermWakeUpGoal = MkAtomTerm(AtomWakeUpGoal); AtomWarning = AtomAdjust(AtomWarning); TermWarning = MkAtomTerm(AtomWarning); AtomWhen = AtomAdjust(AtomWhen); TermWhen = MkAtomTerm(AtomWhen); AtomWrite = AtomAdjust(AtomWrite); TermWrite = MkAtomTerm(AtomWrite); AtomWriteTerm = AtomAdjust(AtomWriteTerm); TermWriteTerm = MkAtomTerm(AtomWriteTerm); AtomXml = AtomAdjust(AtomXml); TermXml = MkAtomTerm(AtomXml); AtomYapHacks = AtomAdjust(AtomYapHacks); TermYapHacks = MkAtomTerm(AtomYapHacks); AtomZeroDivisor = AtomAdjust(AtomZeroDivisor); TermZeroDivisor = MkAtomTerm(AtomZeroDivisor); FunctorAfInet = FuncAdjust(FunctorAfInet); FunctorAfLocal = FuncAdjust(FunctorAfLocal); FunctorAfUnix = FuncAdjust(FunctorAfUnix); FunctorAltNot = FuncAdjust(FunctorAltNot); FunctorArg = FuncAdjust(FunctorArg); FunctorArrayEntry = FuncAdjust(FunctorArrayEntry); FunctorArrow = FuncAdjust(FunctorArrow); FunctorDoubleArrow = FuncAdjust(FunctorDoubleArrow); FunctorAssert1 = FuncAdjust(FunctorAssert1); FunctorAssert = FuncAdjust(FunctorAssert); FunctorAtFoundOne = FuncAdjust(FunctorAtFoundOne); FunctorAtom = FuncAdjust(FunctorAtom); FunctorAtt1 = FuncAdjust(FunctorAtt1); FunctorAttGoal = FuncAdjust(FunctorAttGoal); FunctorBraces = FuncAdjust(FunctorBraces); FunctorCall = FuncAdjust(FunctorCall); FunctorCatch = FuncAdjust(FunctorCatch); FunctorChangeModule = FuncAdjust(FunctorChangeModule); FunctorChars = FuncAdjust(FunctorChars); FunctorChars1 = FuncAdjust(FunctorChars1); FunctorCleanCall = FuncAdjust(FunctorCleanCall); FunctorClist = FuncAdjust(FunctorClist); FunctorCodes = FuncAdjust(FunctorCodes); FunctorCodes1 = FuncAdjust(FunctorCodes1); FunctorColon = FuncAdjust(FunctorColon); FunctorComma = FuncAdjust(FunctorComma); FunctorCommentHook = FuncAdjust(FunctorCommentHook); FunctorContext2 = FuncAdjust(FunctorContext2); FunctorConsistencyError = FuncAdjust(FunctorConsistencyError); FunctorCreep = FuncAdjust(FunctorCreep); FunctorCsult = FuncAdjust(FunctorCsult); FunctorCurrentModule = FuncAdjust(FunctorCurrentModule); FunctorCutBy = FuncAdjust(FunctorCutBy); FunctorDBREF = FuncAdjust(FunctorDBREF); FunctorDiff = FuncAdjust(FunctorDiff); FunctorDoLogUpdClause = FuncAdjust(FunctorDoLogUpdClause); FunctorDoLogUpdClause0 = FuncAdjust(FunctorDoLogUpdClause0); FunctorDoLogUpdClauseErase = FuncAdjust(FunctorDoLogUpdClauseErase); FunctorDoStaticClause = FuncAdjust(FunctorDoStaticClause); FunctorDollar = FuncAdjust(FunctorDollar); FunctorDollarVar = FuncAdjust(FunctorDollarVar); FunctorDomainError = FuncAdjust(FunctorDomainError); FunctorDot = FuncAdjust(FunctorDot); FunctorDot10 = FuncAdjust(FunctorDot10); FunctorDot11 = FuncAdjust(FunctorDot11); FunctorDot12 = FuncAdjust(FunctorDot12); FunctorDot2 = FuncAdjust(FunctorDot2); FunctorDot3 = FuncAdjust(FunctorDot3); FunctorDot4 = FuncAdjust(FunctorDot4); FunctorDot5 = FuncAdjust(FunctorDot5); FunctorDot6 = FuncAdjust(FunctorDot6); FunctorDot7 = FuncAdjust(FunctorDot7); FunctorDot8 = FuncAdjust(FunctorDot8); FunctorDot9 = FuncAdjust(FunctorDot9); FunctorDoubleArrow = FuncAdjust(FunctorDoubleArrow); FunctorDoubleSlash = FuncAdjust(FunctorDoubleSlash); FunctorEmptySquareBrackets = FuncAdjust(FunctorEmptySquareBrackets); FunctorEq = FuncAdjust(FunctorEq); FunctorError = FuncAdjust(FunctorError); FunctorEvaluationError = FuncAdjust(FunctorEvaluationError); FunctorException = FuncAdjust(FunctorException); FunctorExecute2InMod = FuncAdjust(FunctorExecute2InMod); FunctorExecuteInMod = FuncAdjust(FunctorExecuteInMod); FunctorExecuteWithin = FuncAdjust(FunctorExecuteWithin); FunctorExistenceError = FuncAdjust(FunctorExistenceError); FunctorExoClause = FuncAdjust(FunctorExoClause); FunctorFunctor = FuncAdjust(FunctorFunctor); FunctorGAtom = FuncAdjust(FunctorGAtom); FunctorGAtomic = FuncAdjust(FunctorGAtomic); FunctorGCompound = FuncAdjust(FunctorGCompound); FunctorGFloat = FuncAdjust(FunctorGFloat); FunctorGFormatAt = FuncAdjust(FunctorGFormatAt); FunctorGInteger = FuncAdjust(FunctorGInteger); FunctorGNumber = FuncAdjust(FunctorGNumber); FunctorGPrimitive = FuncAdjust(FunctorGPrimitive); FunctorGVar = FuncAdjust(FunctorGVar); FunctorGeneratePredInfo = FuncAdjust(FunctorGeneratePredInfo); FunctorGoalExpansion2 = FuncAdjust(FunctorGoalExpansion2); FunctorGoalExpansion = FuncAdjust(FunctorGoalExpansion); FunctorHandleThrow = FuncAdjust(FunctorHandleThrow); FunctorHat = FuncAdjust(FunctorHat); FunctorI = FuncAdjust(FunctorI); FunctorId = FuncAdjust(FunctorId); FunctorInfo1 = FuncAdjust(FunctorInfo1); FunctorInfo2 = FuncAdjust(FunctorInfo2); FunctorInfo3 = FuncAdjust(FunctorInfo3); FunctorInfo4 = FuncAdjust(FunctorInfo4); FunctorIs = FuncAdjust(FunctorIs); FunctorJ = FuncAdjust(FunctorJ); FunctorLastExecuteWithin = FuncAdjust(FunctorLastExecuteWithin); FunctorList = FuncAdjust(FunctorList); FunctorLOOP = FuncAdjust(FunctorLOOP); FunctorMegaClause = FuncAdjust(FunctorMegaClause); FunctorMetaCall = FuncAdjust(FunctorMetaCall); FunctorMinus = FuncAdjust(FunctorMinus); FunctorModule = FuncAdjust(FunctorModule); FunctorMultiFileClause = FuncAdjust(FunctorMultiFileClause); FunctorMutable = FuncAdjust(FunctorMutable); FunctorMutex = FuncAdjust(FunctorMutex); FunctorNotImplemented = FuncAdjust(FunctorNotImplemented); FunctorNBQueue = FuncAdjust(FunctorNBQueue); FunctorNot = FuncAdjust(FunctorNot); FunctorObj = FuncAdjust(FunctorObj); FunctorOr = FuncAdjust(FunctorOr); FunctorOutput = FuncAdjust(FunctorOutput); FunctorPermissionError = FuncAdjust(FunctorPermissionError); FunctorPlus = FuncAdjust(FunctorPlus); FunctorPortray = FuncAdjust(FunctorPortray); FunctorPrintMessage = FuncAdjust(FunctorPrintMessage); FunctorProcedure = FuncAdjust(FunctorProcedure); FunctorPriority = FuncAdjust(FunctorPriority); FunctorPrologConstraint = FuncAdjust(FunctorPrologConstraint); FunctorProtectStack = FuncAdjust(FunctorProtectStack); FunctorQuery = FuncAdjust(FunctorQuery); FunctorRecordedWithKey = FuncAdjust(FunctorRecordedWithKey); FunctorRDiv = FuncAdjust(FunctorRDiv); FunctorRedoFreeze = FuncAdjust(FunctorRedoFreeze); FunctorRepresentationError = FuncAdjust(FunctorRepresentationError); FunctorResourceError = FuncAdjust(FunctorResourceError); FunctorRestoreRegs = FuncAdjust(FunctorRestoreRegs); FunctorRestoreRegs1 = FuncAdjust(FunctorRestoreRegs1); FunctorSafe = FuncAdjust(FunctorSafe); FunctorSafeCallCleanup = FuncAdjust(FunctorSafeCallCleanup); FunctorSame = FuncAdjust(FunctorSame); FunctorSlash = FuncAdjust(FunctorSlash); FunctorStaticClause = FuncAdjust(FunctorStaticClause); FunctorStream = FuncAdjust(FunctorStream); FunctorStreamEOS = FuncAdjust(FunctorStreamEOS); FunctorStreamPos = FuncAdjust(FunctorStreamPos); FunctorString1 = FuncAdjust(FunctorString1); FunctorStyleCheck = FuncAdjust(FunctorStyleCheck); FunctorSyntaxError = FuncAdjust(FunctorSyntaxError); FunctorShortSyntaxError = FuncAdjust(FunctorShortSyntaxError); FunctorTermExpansion = FuncAdjust(FunctorTermExpansion); FunctorThreadRun = FuncAdjust(FunctorThreadRun); FunctorThrow = FuncAdjust(FunctorThrow); FunctorTimeoutError = FuncAdjust(FunctorTimeoutError); FunctorTraceMetaCall = FuncAdjust(FunctorTraceMetaCall); FunctorTypeError = FuncAdjust(FunctorTypeError); FunctorUMinus = FuncAdjust(FunctorUMinus); FunctorUPlus = FuncAdjust(FunctorUPlus); FunctorVBar = FuncAdjust(FunctorVBar); FunctorWriteTerm = FuncAdjust(FunctorWriteTerm); FunctorHiddenVar = FuncAdjust(FunctorHiddenVar);