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

  AtomAtSymbol = AtomAdjust(AtomAtSymbol); TermAtSymbol = MkAtomTerm(AtomAtSymbol);
  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);
  AtomAs = AtomAdjust(AtomAs); TermAs = MkAtomTerm(AtomAs);
  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);
  AtomExternalException = AtomAdjust(AtomExternalException); TermExternalException = MkAtomTerm(AtomExternalException);
  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);
  Atomg = AtomAdjust(Atomg); Termg = MkAtomTerm(Atomg);
  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);
  AtomDoubleHat = AtomAdjust(AtomDoubleHat); TermDoubleHat = MkAtomTerm(AtomDoubleHat);
  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);
  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);
  AtomPopen = AtomAdjust(AtomPopen); TermPopen = MkAtomTerm(AtomPopen);
  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);
  AtomPrologCommonsDir = AtomAdjust(AtomPrologCommonsDir); TermPrologCommonsDir = MkAtomTerm(AtomPrologCommonsDir);
  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);
  AtomRedo = AtomAdjust(AtomRedo); TermRedo = MkAtomTerm(AtomRedo);
  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);
  AtomTermPosition = AtomAdjust(AtomTermPosition); TermTermPosition = MkAtomTerm(AtomTermPosition);
  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);
  AtomUndefinedQuery = AtomAdjust(AtomUndefinedQuery); TermUndefinedQuery = MkAtomTerm(AtomUndefinedQuery);
  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);
  AtomUTF8 = AtomAdjust(AtomUTF8); TermUTF8 = MkAtomTerm(AtomUTF8);
  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);
  FunctorAs = FuncAdjust(FunctorAs);
  FunctorAssert1 = FuncAdjust(FunctorAssert1);
  FunctorAssert = FuncAdjust(FunctorAssert);
  FunctorAt = FuncAdjust(FunctorAt);
  FunctorAtSymbol = FuncAdjust(FunctorAtSymbol);
  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);
  FunctorEncoding = FuncAdjust(FunctorEncoding);
  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);
  FunctorExternalException = FuncAdjust(FunctorExternalException);
  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);
  FunctorDoubleHat = FuncAdjust(FunctorDoubleHat);
  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);
  FunctorPopen = FuncAdjust(FunctorPopen);
  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);
  FunctorUndefinedQuery = FuncAdjust(FunctorUndefinedQuery);
  FunctorUPlus = FuncAdjust(FunctorUPlus);
  FunctorVBar = FuncAdjust(FunctorVBar);
  FunctorWriteTerm = FuncAdjust(FunctorWriteTerm);
  FunctorHiddenVar = FuncAdjust(FunctorHiddenVar);