/******************************************************************************

 * Top contributors (to current version):

 *   Mathias Preiner, Aina Niemetz

 *

 * This file is part of the cvc5 project.

 *

 * Copyright (c) 2009-2021 by the authors listed in the file AUTHORS

 * in the top-level source directory and their institutional affiliations.

 * All rights reserved.  See the file COPYING in the top-level source

 * directory for licensing information.

 * ****************************************************************************

 *

 * Contains code for handling command-line options.

 *

 * For each <module>_options.toml configuration file, mkoptions.py

 * expands this template and generates a <module>_options.h file.

 */

#include "cvc5_private.h"

#ifndef CVC5__OPTIONS__QUANTIFIERS_H

#define CVC5__OPTIONS__QUANTIFIERS_H

#include "options/options.h"

// clang-format off

// clang-format on

namespace cvc5 {

namespace options {

// clang-format off

enum class CegisSampleMode

{

  TRUST,

  NONE,

  USE

};

static constexpr size_t CegisSampleMode__numValues = 3;

std::ostream& operator<<(std::ostream& os, CegisSampleMode mode);

CegisSampleMode stringToCegisSampleMode(const std::string& optarg);

enum class CegqiBvIneqMode

{

  EQ_SLACK,

  EQ_BOUNDARY,

  KEEP

};

static constexpr size_t CegqiBvIneqMode__numValues = 3;

std::ostream& operator<<(std::ostream& os, CegqiBvIneqMode mode);

CegqiBvIneqMode stringToCegqiBvIneqMode(const std::string& optarg);

enum class InstWhenMode

{

  FULL,

  FULL_DELAY_LAST_CALL,

  FULL_DELAY,

  LAST_CALL,

  PRE_FULL,

  FULL_LAST_CALL

};

static constexpr size_t InstWhenMode__numValues = 6;

std::ostream& operator<<(std::ostream& os, InstWhenMode mode);

InstWhenMode stringToInstWhenMode(const std::string& optarg);

enum class IteLiftQuantMode

{

  ALL,

  NONE,

  SIMPLE

};

static constexpr size_t IteLiftQuantMode__numValues = 3;

std::ostream& operator<<(std::ostream& os, IteLiftQuantMode mode);

IteLiftQuantMode stringToIteLiftQuantMode(const std::string& optarg);

enum class LiteralMatchMode

{

  AGG_PREDICATE,

  AGG,

  NONE,

  USE

};

static constexpr size_t LiteralMatchMode__numValues = 4;

std::ostream& operator<<(std::ostream& os, LiteralMatchMode mode);

LiteralMatchMode stringToLiteralMatchMode(const std::string& optarg);

enum class MacrosQuantMode

{

  GROUND,

  ALL,

  GROUND_UF

};

static constexpr size_t MacrosQuantMode__numValues = 3;

std::ostream& operator<<(std::ostream& os, MacrosQuantMode mode);

MacrosQuantMode stringToMacrosQuantMode(const std::string& optarg);

enum class MbqiMode

{

  FMC,

  TRUST,

  NONE

};

static constexpr size_t MbqiMode__numValues = 3;

std::ostream& operator<<(std::ostream& os, MbqiMode mode);

MbqiMode stringToMbqiMode(const std::string& optarg);

enum class PrenexQuantMode

{

  NONE,

  NORMAL,

  SIMPLE

};

static constexpr size_t PrenexQuantMode__numValues = 3;

std::ostream& operator<<(std::ostream& os, PrenexQuantMode mode);

PrenexQuantMode stringToPrenexQuantMode(const std::string& optarg);

enum class QcfMode

{

  PARTIAL,

  PROP_EQ,

  CONFLICT_ONLY

};

static constexpr size_t QcfMode__numValues = 3;

std::ostream& operator<<(std::ostream& os, QcfMode mode);

QcfMode stringToQcfMode(const std::string& optarg);

enum class QcfWhenMode

{

  DEFAULT,

  STD_H,

  STD,

  LAST_CALL

};

static constexpr size_t QcfWhenMode__numValues = 4;

std::ostream& operator<<(std::ostream& os, QcfWhenMode mode);

QcfWhenMode stringToQcfWhenMode(const std::string& optarg);

enum class QuantDSplitMode

{

  DEFAULT,

  AGG,

  NONE

};

static constexpr size_t QuantDSplitMode__numValues = 3;

std::ostream& operator<<(std::ostream& os, QuantDSplitMode mode);

QuantDSplitMode stringToQuantDSplitMode(const std::string& optarg);

enum class QuantRepMode

{

  EE,

  DEPTH,

  FIRST

};

static constexpr size_t QuantRepMode__numValues = 3;

std::ostream& operator<<(std::ostream& os, QuantRepMode mode);

QuantRepMode stringToQuantRepMode(const std::string& optarg);

enum class SygusActiveGenMode

{

  NONE,

  AUTO,

  ENUM_BASIC,

  VAR_AGNOSTIC,

  ENUM

};

static constexpr size_t SygusActiveGenMode__numValues = 5;

std::ostream& operator<<(std::ostream& os, SygusActiveGenMode mode);

SygusActiveGenMode stringToSygusActiveGenMode(const std::string& optarg);

enum class SygusFilterSolMode

{

  STRONG,

  NONE,

  WEAK

};

static constexpr size_t SygusFilterSolMode__numValues = 3;

std::ostream& operator<<(std::ostream& os, SygusFilterSolMode mode);

SygusFilterSolMode stringToSygusFilterSolMode(const std::string& optarg);

enum class SygusGrammarConsMode

{

  ANY_TERM,

  ANY_TERM_CONCISE,

  ANY_CONST,

  SIMPLE

};

static constexpr size_t SygusGrammarConsMode__numValues = 4;

std::ostream& operator<<(std::ostream& os, SygusGrammarConsMode mode);

SygusGrammarConsMode stringToSygusGrammarConsMode(const std::string& optarg);

enum class SygusInstMode

{

  PRIORITY_EVAL,

  PRIORITY_INST,

  INTERLEAVE

};

static constexpr size_t SygusInstMode__numValues = 3;

std::ostream& operator<<(std::ostream& os, SygusInstMode mode);

SygusInstMode stringToSygusInstMode(const std::string& optarg);

enum class SygusInstScope

{

  IN,

  OUT,

  BOTH

};

static constexpr size_t SygusInstScope__numValues = 3;

std::ostream& operator<<(std::ostream& os, SygusInstScope mode);

SygusInstScope stringToSygusInstScope(const std::string& optarg);

enum class SygusInstTermSelMode

{

  MAX,

  BOTH,

  MIN

};

static constexpr size_t SygusInstTermSelMode__numValues = 3;

std::ostream& operator<<(std::ostream& os, SygusInstTermSelMode mode);

SygusInstTermSelMode stringToSygusInstTermSelMode(const std::string& optarg);

enum class SygusInvTemplMode

{

  POST,

  NONE,

  PRE

};

static constexpr size_t SygusInvTemplMode__numValues = 3;

std::ostream& operator<<(std::ostream& os, SygusInvTemplMode mode);

SygusInvTemplMode stringToSygusInvTemplMode(const std::string& optarg);

enum class SygusQueryDumpFilesMode

{

  ALL,

  NONE,

  UNSOLVED

};

static constexpr size_t SygusQueryDumpFilesMode__numValues = 3;

std::ostream& operator<<(std::ostream& os, SygusQueryDumpFilesMode mode);

SygusQueryDumpFilesMode stringToSygusQueryDumpFilesMode(const std::string& optarg);

enum class CegqiSingleInvRconsMode

{

  TRY,

  ALL,

  NONE,

  ALL_LIMIT

};

static constexpr size_t CegqiSingleInvRconsMode__numValues = 4;

std::ostream& operator<<(std::ostream& os, CegqiSingleInvRconsMode mode);

CegqiSingleInvRconsMode stringToCegqiSingleInvRconsMode(const std::string& optarg);

enum class CegqiSingleInvMode

{

  ALL,

  NONE,

  USE

};

static constexpr size_t CegqiSingleInvMode__numValues = 3;

std::ostream& operator<<(std::ostream& os, CegqiSingleInvMode mode);

CegqiSingleInvMode stringToCegqiSingleInvMode(const std::string& optarg);

enum class SygusUnifPiMode

{

  CENUM,

  NONE,

  COMPLETE,

  CENUM_IGAIN

};

static constexpr size_t SygusUnifPiMode__numValues = 4;

std::ostream& operator<<(std::ostream& os, SygusUnifPiMode mode);

SygusUnifPiMode stringToSygusUnifPiMode(const std::string& optarg);

enum class TermDbMode

{

  ALL,

  RELEVANT

};

static constexpr size_t TermDbMode__numValues = 2;

std::ostream& operator<<(std::ostream& os, TermDbMode mode);

TermDbMode stringToTermDbMode(const std::string& optarg);

enum class TriggerActiveSelMode

{

  ALL,

  MAX,

  MIN

};

static constexpr size_t TriggerActiveSelMode__numValues = 3;

std::ostream& operator<<(std::ostream& os, TriggerActiveSelMode mode);

TriggerActiveSelMode stringToTriggerActiveSelMode(const std::string& optarg);

enum class TriggerSelMode

{

  ALL,

  MIN_SINGLE_ALL,

  MAX,

  MIN_SINGLE_MAX,

  MIN

};

static constexpr size_t TriggerSelMode__numValues = 5;

std::ostream& operator<<(std::ostream& os, TriggerSelMode mode);

TriggerSelMode stringToTriggerSelMode(const std::string& optarg);

enum class UserPatMode

{

  TRUST,

  RESORT,

  USE,

  IGNORE,

  INTERLEAVE

};

static constexpr size_t UserPatMode__numValues = 5;

std::ostream& operator<<(std::ostream& os, UserPatMode mode);

UserPatMode stringToUserPatMode(const std::string& optarg);

// clang-format on

#if defined(CVC5_MUZZLED) || defined(CVC5_COMPETITION_MODE)

#  define DO_SEMANTIC_CHECKS_BY_DEFAULT false

#else /* CVC5_MUZZLED || CVC5_COMPETITION_MODE */

#  define DO_SEMANTIC_CHECKS_BY_DEFAULT true

#endif /* CVC5_MUZZLED || CVC5_COMPETITION_MODE */

{

// clang-format off

  bool aggressiveMiniscopeQuant = false;

  bool aggressiveMiniscopeQuantWasSetByUser = false;

  CegisSampleMode cegisSample = CegisSampleMode::NONE;

  bool cegisSampleWasSetByUser = false;

  bool cegqi = false;

  bool cegqiWasSetByUser = false;

  bool cegqiAll = false;

  bool cegqiAllWasSetByUser = false;

  bool cegqiBv = true;

  bool cegqiBvWasSetByUser = false;

  bool cegqiBvConcInv = true;

  bool cegqiBvConcInvWasSetByUser = false;

  CegqiBvIneqMode cegqiBvIneqMode = CegqiBvIneqMode::EQ_BOUNDARY;

  bool cegqiBvIneqModeWasSetByUser = false;

  bool cegqiBvInterleaveValue = false;

  bool cegqiBvInterleaveValueWasSetByUser = false;

  bool cegqiBvLinearize = true;

  bool cegqiBvLinearizeWasSetByUser = false;

  bool cegqiBvRmExtract = true;

  bool cegqiBvRmExtractWasSetByUser = false;

  bool cegqiBvSolveNl = false;

  bool cegqiBvSolveNlWasSetByUser = false;

  bool cegqiFullEffort = false;

  bool cegqiFullEffortWasSetByUser = false;

  bool cegqiInnermost = true;

  bool cegqiInnermostWasSetByUser = false;

  bool cegqiMidpoint = false;

  bool cegqiMidpointWasSetByUser = false;

  bool cegqiMinBounds = false;

  bool cegqiMinBoundsWasSetByUser = false;

  bool cegqiModel = true;

  bool cegqiModelWasSetByUser = false;

  bool cegqiMultiInst = false;

  bool cegqiMultiInstWasSetByUser = false;

  bool cegqiNestedQE = false;

  bool cegqiNestedQEWasSetByUser = false;

  bool cegqiNopt = true;

  bool cegqiNoptWasSetByUser = false;

  bool cegqiRepeatLit = false;

  bool cegqiRepeatLitWasSetByUser = false;

  bool cegqiRoundUpLowerLia = false;

  bool cegqiRoundUpLowerLiaWasSetByUser = false;

  bool cegqiSat = true;

  bool cegqiSatWasSetByUser = false;

  bool cegqiUseInfInt = false;

  bool cegqiUseInfIntWasSetByUser = false;

  bool cegqiUseInfReal = false;

  bool cegqiUseInfRealWasSetByUser = false;

  bool condVarSplitQuantAgg = false;

  bool condVarSplitQuantAggWasSetByUser = false;

  bool condVarSplitQuant = true;

  bool condVarSplitQuantWasSetByUser = false;

  bool conjectureFilterActiveTerms = true;

  bool conjectureFilterActiveTermsWasSetByUser = false;

  bool conjectureFilterCanonical = true;

  bool conjectureFilterCanonicalWasSetByUser = false;

  bool conjectureFilterModel = true;

  bool conjectureFilterModelWasSetByUser = false;

  bool conjectureGen = false;

  bool conjectureGenWasSetByUser = false;

  int64_t conjectureGenGtEnum = 50;

  bool conjectureGenGtEnumWasSetByUser = false;

  int64_t conjectureGenMaxDepth = 3;

  bool conjectureGenMaxDepthWasSetByUser = false;

  int64_t conjectureGenPerRound = 1;

  bool conjectureGenPerRoundWasSetByUser = false;

  bool conjectureUeeIntro = false;

  bool conjectureUeeIntroWasSetByUser = false;

  bool conjectureNoFilter = false;

  bool conjectureNoFilterWasSetByUser = false;

  bool dtStcInduction = false;

  bool dtStcInductionWasSetByUser = false;

  bool dtVarExpandQuant = true;

  bool dtVarExpandQuantWasSetByUser = false;

  bool eMatching = true;

  bool eMatchingWasSetByUser = false;

  bool elimTautQuant = true;

  bool elimTautQuantWasSetByUser = false;

  bool extRewriteQuant = false;

  bool extRewriteQuantWasSetByUser = false;

  bool finiteModelFind = false;

  bool finiteModelFindWasSetByUser = false;

  bool fmfBound = false;

  bool fmfBoundWasSetByUser = false;

  bool fmfBoundInt = false;

  bool fmfBoundIntWasSetByUser = false;

  bool fmfBoundLazy = false;

  bool fmfBoundLazyWasSetByUser = false;

  bool fmfFmcSimple = true;

  bool fmfFmcSimpleWasSetByUser = false;

  bool fmfFreshDistConst = false;

  bool fmfFreshDistConstWasSetByUser = false;

  bool fmfFunWellDefined = false;

  bool fmfFunWellDefinedWasSetByUser = false;

  bool fmfFunWellDefinedRelevant = false;

  bool fmfFunWellDefinedRelevantWasSetByUser = false;

  bool fmfInstEngine = false;

  bool fmfInstEngineWasSetByUser = false;

  int64_t fmfTypeCompletionThresh = 1000;

  bool fmfTypeCompletionThreshWasSetByUser = false;

  bool fullSaturateInterleave = false;

  bool fullSaturateInterleaveWasSetByUser = false;

  bool fullSaturateStratify = false;

  bool fullSaturateStratifyWasSetByUser = false;

  bool fullSaturateSum = false;

  bool fullSaturateSumWasSetByUser = false;

  bool fullSaturateQuant = false;

  bool fullSaturateQuantWasSetByUser = false;

  int64_t fullSaturateLimit = -1;

  bool fullSaturateLimitWasSetByUser = false;

  bool fullSaturateQuantRd = true;

  bool fullSaturateQuantRdWasSetByUser = false;

  bool globalNegate = false;

  bool globalNegateWasSetByUser = false;

  bool hoElim = false;

  bool hoElimWasSetByUser = false;

  bool hoElimStoreAx = true;

  bool hoElimStoreAxWasSetByUser = false;

  bool hoMatching = true;

  bool hoMatchingWasSetByUser = false;

  bool hoMatchingVarArgPriority = true;

  bool hoMatchingVarArgPriorityWasSetByUser = false;

  bool hoMergeTermDb = true;

  bool hoMergeTermDbWasSetByUser = false;

  bool incrementTriggers = true;

  bool incrementTriggersWasSetByUser = false;

  bool instLevelInputOnly = true;

  bool instLevelInputOnlyWasSetByUser = false;

  int64_t instMaxLevel = -1;

  bool instMaxLevelWasSetByUser = false;

  int64_t instMaxRounds = -1;

  bool instMaxRoundsWasSetByUser = false;

  bool instNoEntail = true;

  bool instNoEntailWasSetByUser = false;

  int64_t instWhenPhase = 2;

  bool instWhenPhaseWasSetByUser = false;

  bool instWhenStrictInterleave = true;

  bool instWhenStrictInterleaveWasSetByUser = false;

  bool instWhenTcFirst = true;

  bool instWhenTcFirstWasSetByUser = false;

  InstWhenMode instWhenMode = InstWhenMode::FULL_LAST_CALL;

  bool instWhenModeWasSetByUser = false;

  bool intWfInduction = false;

  bool intWfInductionWasSetByUser = false;

  bool iteDtTesterSplitQuant = false;

  bool iteDtTesterSplitQuantWasSetByUser = false;

  IteLiftQuantMode iteLiftQuant = IteLiftQuantMode::SIMPLE;

  bool iteLiftQuantWasSetByUser = false;

  LiteralMatchMode literalMatchMode = LiteralMatchMode::USE;

  bool literalMatchModeWasSetByUser = false;

  bool macrosQuant = false;

  bool macrosQuantWasSetByUser = false;

  MacrosQuantMode macrosQuantMode = MacrosQuantMode::GROUND_UF;

  bool macrosQuantModeWasSetByUser = false;

  bool mbqiInterleave = false;

  bool mbqiInterleaveWasSetByUser = false;

  bool fmfOneInstPerRound = false;

  bool fmfOneInstPerRoundWasSetByUser = false;

  MbqiMode mbqiMode = MbqiMode::FMC;

  bool mbqiModeWasSetByUser = false;

  bool miniscopeQuant = true;

  bool miniscopeQuantWasSetByUser = false;

  bool miniscopeQuantFreeVar = true;

  bool miniscopeQuantFreeVarWasSetByUser = false;

  bool multiTriggerCache = false;

  bool multiTriggerCacheWasSetByUser = false;

  bool multiTriggerLinear = true;

  bool multiTriggerLinearWasSetByUser = false;

  bool multiTriggerPriority = false;

  bool multiTriggerPriorityWasSetByUser = false;

  bool multiTriggerWhenSingle = false;

  bool multiTriggerWhenSingleWasSetByUser = false;

  bool partialTriggers = false;

  bool partialTriggersWasSetByUser = false;

  bool poolInst = true;

  bool poolInstWasSetByUser = false;

  bool preSkolemQuant = false;

  bool preSkolemQuantWasSetByUser = false;

  bool preSkolemQuantAgg = true;

  bool preSkolemQuantAggWasSetByUser = false;

  bool preSkolemQuantNested = true;

  bool preSkolemQuantNestedWasSetByUser = false;

  bool prenexQuantUser = false;

  bool prenexQuantUserWasSetByUser = false;

  PrenexQuantMode prenexQuant = PrenexQuantMode::SIMPLE;

  bool prenexQuantWasSetByUser = false;

  bool purifyTriggers = false;

  bool purifyTriggersWasSetByUser = false;

  bool qcfAllConflict = false;

  bool qcfAllConflictWasSetByUser = false;

  bool qcfEagerCheckRd = true;

  bool qcfEagerCheckRdWasSetByUser = false;

  bool qcfEagerTest = true;

  bool qcfEagerTestWasSetByUser = false;

  bool qcfNestedConflict = false;

  bool qcfNestedConflictWasSetByUser = false;

  bool qcfSkipRd = false;

  bool qcfSkipRdWasSetByUser = false;

  bool qcfTConstraint = false;

  bool qcfTConstraintWasSetByUser = false;

  bool qcfVoExp = false;

  bool qcfVoExpWasSetByUser = false;

  bool quantAlphaEquiv = true;

  bool quantAlphaEquivWasSetByUser = false;

  bool quantConflictFind = true;

  bool quantConflictFindWasSetByUser = false;

  QcfMode qcfMode = QcfMode::PROP_EQ;

  bool qcfModeWasSetByUser = false;

  QcfWhenMode qcfWhenMode = QcfWhenMode::DEFAULT;

  bool qcfWhenModeWasSetByUser = false;

  QuantDSplitMode quantDynamicSplit = QuantDSplitMode::DEFAULT;

  bool quantDynamicSplitWasSetByUser = false;

  bool quantFunWellDefined = false;

  bool quantFunWellDefinedWasSetByUser = false;

  bool quantInduction = false;

  bool quantInductionWasSetByUser = false;

  QuantRepMode quantRepMode = QuantRepMode::FIRST;

  bool quantRepModeWasSetByUser = false;

  bool quantSplit = true;

  bool quantSplitWasSetByUser = false;

  bool registerQuantBodyTerms = false;

  bool registerQuantBodyTermsWasSetByUser = false;

  bool relationalTriggers = false;

  bool relationalTriggersWasSetByUser = false;

  bool relevantTriggers = false;

  bool relevantTriggersWasSetByUser = false;

  bool strictTriggers = false;

  bool strictTriggersWasSetByUser = false;

  bool sygus = false;

  bool sygusWasSetByUser = false;

  uint64_t sygusActiveGenEnumConsts = 5;

  bool sygusActiveGenEnumConstsWasSetByUser = false;

  SygusActiveGenMode sygusActiveGenMode = SygusActiveGenMode::AUTO;

  bool sygusActiveGenModeWasSetByUser = false;

  bool sygusAddConstGrammar = false;

  bool sygusAddConstGrammarWasSetByUser = false;

  bool sygusArgRelevant = false;

  bool sygusArgRelevantWasSetByUser = false;

  bool sygusInvAutoUnfold = true;

  bool sygusInvAutoUnfoldWasSetByUser = false;

  bool sygusBoolIteReturnConst = true;

  bool sygusBoolIteReturnConstWasSetByUser = false;

  bool sygusCoreConnective = false;

  bool sygusCoreConnectiveWasSetByUser = false;

  bool sygusConstRepairAbort = false;

  bool sygusConstRepairAbortWasSetByUser = false;

  bool sygusEvalOpt = true;

  bool sygusEvalOptWasSetByUser = false;

  bool sygusEvalUnfold = true;

  bool sygusEvalUnfoldWasSetByUser = false;

  bool sygusEvalUnfoldBool = true;

  bool sygusEvalUnfoldBoolWasSetByUser = false;

  uint64_t sygusExprMinerCheckTimeout;

  bool sygusExprMinerCheckTimeoutWasSetByUser = false;

  bool sygusExtRew = true;

  bool sygusExtRewWasSetByUser = false;

  bool sygusFilterSolRevSubsume = false;

  bool sygusFilterSolRevSubsumeWasSetByUser = false;

  SygusFilterSolMode sygusFilterSolMode = SygusFilterSolMode::NONE;

  bool sygusFilterSolModeWasSetByUser = false;

  SygusGrammarConsMode sygusGrammarConsMode = SygusGrammarConsMode::SIMPLE;

  bool sygusGrammarConsModeWasSetByUser = false;

  bool sygusGrammarNorm = false;

  bool sygusGrammarNormWasSetByUser = false;

  bool sygusInference = false;

  bool sygusInferenceWasSetByUser = false;

  bool sygusInst = false;

  bool sygusInstWasSetByUser = false;

  SygusInstMode sygusInstMode = SygusInstMode::PRIORITY_INST;

  bool sygusInstModeWasSetByUser = false;

  SygusInstScope sygusInstScope = SygusInstScope::IN;

  bool sygusInstScopeWasSetByUser = false;

  SygusInstTermSelMode sygusInstTermSel = SygusInstTermSelMode::MIN;

  bool sygusInstTermSelWasSetByUser = false;

  bool sygusInvTemplWhenSyntax = false;

  bool sygusInvTemplWhenSyntaxWasSetByUser = false;

  SygusInvTemplMode sygusInvTemplMode = SygusInvTemplMode::POST;

  bool sygusInvTemplModeWasSetByUser = false;

  bool sygusMinGrammar = true;

  bool sygusMinGrammarWasSetByUser = false;

  bool sygusUnifPbe = true;

  bool sygusUnifPbeWasSetByUser = false;

  bool sygusPbeMultiFair = false;

  bool sygusPbeMultiFairWasSetByUser = false;

  int64_t sygusPbeMultiFairDiff = 0;

  bool sygusPbeMultiFairDiffWasSetByUser = false;

  bool sygusQePreproc = false;

  bool sygusQePreprocWasSetByUser = false;

  bool sygusQueryGen = false;

  bool sygusQueryGenWasSetByUser = false;

  bool sygusQueryGenCheck = true;

  bool sygusQueryGenCheckWasSetByUser = false;

  SygusQueryDumpFilesMode sygusQueryGenDumpFiles = SygusQueryDumpFilesMode::NONE;

  bool sygusQueryGenDumpFilesWasSetByUser = false;

  uint64_t sygusQueryGenThresh = 5;

  bool sygusQueryGenThreshWasSetByUser = false;

  bool sygusRecFun = true;

  bool sygusRecFunWasSetByUser = false;

  uint64_t sygusRecFunEvalLimit = 1000;

  bool sygusRecFunEvalLimitWasSetByUser = false;

  bool sygusRepairConst = false;

  bool sygusRepairConstWasSetByUser = false;

  uint64_t sygusRepairConstTimeout;

  bool sygusRepairConstTimeoutWasSetByUser = false;

  bool sygusRew = false;

  bool sygusRewWasSetByUser = false;

  bool sygusRewSynth = false;

  bool sygusRewSynthWasSetByUser = false;

  bool sygusRewSynthAccel = false;

  bool sygusRewSynthAccelWasSetByUser = false;

  bool sygusRewSynthCheck = false;

  bool sygusRewSynthCheckWasSetByUser = false;

  bool sygusRewSynthFilterCong = true;

  bool sygusRewSynthFilterCongWasSetByUser = false;

  bool sygusRewSynthFilterMatch = true;

  bool sygusRewSynthFilterMatchWasSetByUser = false;

  bool sygusRewSynthFilterNonLinear = false;

  bool sygusRewSynthFilterNonLinearWasSetByUser = false;

  bool sygusRewSynthFilterOrder = true;

  bool sygusRewSynthFilterOrderWasSetByUser = false;

  bool sygusRewSynthInput = false;

  bool sygusRewSynthInputWasSetByUser = false;

  int64_t sygusRewSynthInputNVars = 3;

  bool sygusRewSynthInputNVarsWasSetByUser = false;

  bool sygusRewSynthInputUseBool = false;

  bool sygusRewSynthInputUseBoolWasSetByUser = false;

  bool sygusRewSynthRec = false;

  bool sygusRewSynthRecWasSetByUser = false;

  bool sygusRewVerify = false;

  bool sygusRewVerifyWasSetByUser = false;

  bool sygusRewVerifyAbort = true;

  bool sygusRewVerifyAbortWasSetByUser = false;

  bool sygusSampleFpUniform = false;

  bool sygusSampleFpUniformWasSetByUser = false;

  bool sygusSampleGrammar = true;

  bool sygusSampleGrammarWasSetByUser = false;

  int64_t sygusSamples = 1000;

  bool sygusSamplesWasSetByUser = false;

  bool cegqiSingleInvAbort = false;

  bool cegqiSingleInvAbortWasSetByUser = false;

  bool cegqiSingleInvPartial = false;

  bool cegqiSingleInvPartialWasSetByUser = false;

  int64_t cegqiSingleInvReconstructLimit = 10000;

  bool cegqiSingleInvReconstructLimitWasSetByUser = false;

  CegqiSingleInvRconsMode cegqiSingleInvReconstruct = CegqiSingleInvRconsMode::ALL_LIMIT;

  bool cegqiSingleInvReconstructWasSetByUser = false;

  bool cegqiSingleInvReconstructConst = true;

  bool cegqiSingleInvReconstructConstWasSetByUser = false;

  CegqiSingleInvMode cegqiSingleInvMode = CegqiSingleInvMode::NONE;

  bool cegqiSingleInvModeWasSetByUser = false;

  bool sygusStream = false;

  bool sygusStreamWasSetByUser = false;

  bool sygusTemplEmbedGrammar = false;

  bool sygusTemplEmbedGrammarWasSetByUser = false;

  bool sygusUnifCondIndNoRepeatSol = true;

  bool sygusUnifCondIndNoRepeatSolWasSetByUser = false;

  SygusUnifPiMode sygusUnifPi = SygusUnifPiMode::NONE;

  bool sygusUnifPiWasSetByUser = false;

  bool sygusUnifShuffleCond = false;

  bool sygusUnifShuffleCondWasSetByUser = false;

  int64_t sygusVerifyInstMaxRounds = 3;

  bool sygusVerifyInstMaxRoundsWasSetByUser = false;

  bool termDbCd = true;

  bool termDbCdWasSetByUser = false;

  TermDbMode termDbMode = TermDbMode::ALL;

  bool termDbModeWasSetByUser = false;

  TriggerActiveSelMode triggerActiveSelMode = TriggerActiveSelMode::ALL;

  bool triggerActiveSelModeWasSetByUser = false;

  TriggerSelMode triggerSelMode = TriggerSelMode::MIN;

  bool triggerSelModeWasSetByUser = false;

  UserPatMode userPatternsQuant = UserPatMode::TRUST;

  bool userPatternsQuantWasSetByUser = false;

  bool varElimQuant = true;

  bool varElimQuantWasSetByUser = false;

  bool varIneqElimQuant = true;

  bool varIneqElimQuantWasSetByUser = false;

// clang-format on

};

#undef DO_SEMANTIC_CHECKS_BY_DEFAULT

// clang-format off

extern struct aggressiveMiniscopeQuant__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local aggressiveMiniscopeQuant;

extern struct cegisSample__option_t

{

  typedef CegisSampleMode type;

  type operator()() const;

} thread_local cegisSample;

extern struct cegqi__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqi;

extern struct cegqiAll__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiAll;

extern struct cegqiBv__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiBv;

extern struct cegqiBvConcInv__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiBvConcInv;

extern struct cegqiBvIneqMode__option_t

{

  typedef CegqiBvIneqMode type;

  type operator()() const;

} thread_local cegqiBvIneqMode;

extern struct cegqiBvInterleaveValue__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiBvInterleaveValue;

extern struct cegqiBvLinearize__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiBvLinearize;

extern struct cegqiBvRmExtract__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiBvRmExtract;

extern struct cegqiBvSolveNl__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiBvSolveNl;

extern struct cegqiFullEffort__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiFullEffort;

extern struct cegqiInnermost__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiInnermost;

extern struct cegqiMidpoint__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiMidpoint;

extern struct cegqiMinBounds__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiMinBounds;

extern struct cegqiModel__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiModel;

extern struct cegqiMultiInst__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiMultiInst;

extern struct cegqiNestedQE__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiNestedQE;

extern struct cegqiNopt__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiNopt;

extern struct cegqiRepeatLit__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiRepeatLit;

extern struct cegqiRoundUpLowerLia__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiRoundUpLowerLia;

extern struct cegqiSat__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiSat;

extern struct cegqiUseInfInt__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiUseInfInt;

extern struct cegqiUseInfReal__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local cegqiUseInfReal;

extern struct condVarSplitQuantAgg__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local condVarSplitQuantAgg;

extern struct condVarSplitQuant__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local condVarSplitQuant;

extern struct conjectureFilterActiveTerms__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local conjectureFilterActiveTerms;

extern struct conjectureFilterCanonical__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local conjectureFilterCanonical;

extern struct conjectureFilterModel__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local conjectureFilterModel;

extern struct conjectureGen__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local conjectureGen;

extern struct conjectureGenGtEnum__option_t

{

  typedef int64_t type;

  type operator()() const;

} thread_local conjectureGenGtEnum;

extern struct conjectureGenMaxDepth__option_t

{

  typedef int64_t type;

  type operator()() const;

} thread_local conjectureGenMaxDepth;

extern struct conjectureGenPerRound__option_t

{

  typedef int64_t type;

  type operator()() const;

} thread_local conjectureGenPerRound;

extern struct conjectureUeeIntro__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local conjectureUeeIntro;

extern struct conjectureNoFilter__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local conjectureNoFilter;

extern struct dtStcInduction__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local dtStcInduction;

extern struct dtVarExpandQuant__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local dtVarExpandQuant;

extern struct eMatching__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local eMatching;

extern struct elimTautQuant__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local elimTautQuant;

extern struct extRewriteQuant__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local extRewriteQuant;

extern struct finiteModelFind__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local finiteModelFind;

extern struct fmfBound__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local fmfBound;

extern struct fmfBoundInt__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local fmfBoundInt;

extern struct fmfBoundLazy__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local fmfBoundLazy;

extern struct fmfFmcSimple__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local fmfFmcSimple;

extern struct fmfFreshDistConst__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local fmfFreshDistConst;

extern struct fmfFunWellDefined__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local fmfFunWellDefined;

extern struct fmfFunWellDefinedRelevant__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local fmfFunWellDefinedRelevant;

extern struct fmfInstEngine__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local fmfInstEngine;

extern struct fmfTypeCompletionThresh__option_t

{

  typedef int64_t type;

  type operator()() const;

} thread_local fmfTypeCompletionThresh;

extern struct fullSaturateInterleave__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local fullSaturateInterleave;

extern struct fullSaturateStratify__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local fullSaturateStratify;

extern struct fullSaturateSum__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local fullSaturateSum;

extern struct fullSaturateQuant__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local fullSaturateQuant;

extern struct fullSaturateLimit__option_t

{

  typedef int64_t type;

  type operator()() const;

} thread_local fullSaturateLimit;

extern struct fullSaturateQuantRd__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local fullSaturateQuantRd;

extern struct globalNegate__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local globalNegate;

extern struct hoElim__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local hoElim;

extern struct hoElimStoreAx__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local hoElimStoreAx;

extern struct hoMatching__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local hoMatching;

extern struct hoMatchingVarArgPriority__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local hoMatchingVarArgPriority;

extern struct hoMergeTermDb__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local hoMergeTermDb;

extern struct incrementTriggers__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local incrementTriggers;

extern struct instLevelInputOnly__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local instLevelInputOnly;

extern struct instMaxLevel__option_t

{

  typedef int64_t type;

  type operator()() const;

} thread_local instMaxLevel;

extern struct instMaxRounds__option_t

{

  typedef int64_t type;

  type operator()() const;

} thread_local instMaxRounds;

extern struct instNoEntail__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local instNoEntail;

extern struct instWhenPhase__option_t

{

  typedef int64_t type;

  type operator()() const;

} thread_local instWhenPhase;

extern struct instWhenStrictInterleave__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local instWhenStrictInterleave;

extern struct instWhenTcFirst__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local instWhenTcFirst;

extern struct instWhenMode__option_t

{

  typedef InstWhenMode type;

  type operator()() const;

} thread_local instWhenMode;

extern struct intWfInduction__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local intWfInduction;

extern struct iteDtTesterSplitQuant__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local iteDtTesterSplitQuant;

extern struct iteLiftQuant__option_t

{

  typedef IteLiftQuantMode type;

  type operator()() const;

} thread_local iteLiftQuant;

extern struct literalMatchMode__option_t

{

  typedef LiteralMatchMode type;

  type operator()() const;

} thread_local literalMatchMode;

extern struct macrosQuant__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local macrosQuant;

extern struct macrosQuantMode__option_t

{

  typedef MacrosQuantMode type;

  type operator()() const;

} thread_local macrosQuantMode;

extern struct mbqiInterleave__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local mbqiInterleave;

extern struct fmfOneInstPerRound__option_t

{

  typedef bool type;

  type operator()() const;

} thread_local fmfOneInstPerRound;

extern struct mbqiMode__option_t

{

  typedef MbqiMode type;

  type operator()() const;